diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 8ec5394..0cfc90b 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,6 +1,6 @@
 {
   "git": {
-    "sha1": "ec31ce829473039ac598ca6fdcb245cbd6fa82ba"
+    "sha1": "7155092f3df112159d55132081937e1fe5c30490"
   },
   "path_in_vcs": "protobuf-codegen"
 }
\ No newline at end of file
diff --git a/Android.bp b/Android.bp
index a698555..b0ae081 100644
--- a/Android.bp
+++ b/Android.bp
@@ -24,11 +24,17 @@
     name: "libprotobuf_codegen",
     crate_name: "protobuf_codegen",
     cargo_env_compat: true,
-    cargo_pkg_version: "2.27.1",
+    cargo_pkg_version: "3.2.0",
     srcs: ["src/lib.rs"],
-    edition: "2015",
+    edition: "2021",
     rustlibs: [
+        "libanyhow",
+        "libonce_cell",
         "libprotobuf",
+        "libprotobuf_parse",
+        "libregex",
+        "libtempfile",
+        "libthiserror",
     ],
     product_available: true,
     vendor_available: true,
@@ -38,16 +44,22 @@
     name: "protobuf-codegen_test_src_lib",
     crate_name: "protobuf_codegen",
     cargo_env_compat: true,
-    cargo_pkg_version: "2.27.1",
+    cargo_pkg_version: "3.2.0",
     srcs: ["src/lib.rs"],
     test_suites: ["general-tests"],
     auto_gen_config: true,
     test_options: {
         unit_test: true,
     },
-    edition: "2015",
+    edition: "2021",
     rustlibs: [
+        "libanyhow",
+        "libonce_cell",
         "libprotobuf",
+        "libprotobuf_parse",
+        "libregex",
+        "libtempfile",
+        "libthiserror",
     ],
 }
 
@@ -55,12 +67,18 @@
     name: "protoc-gen-rust",
     crate_name: "protoc_gen_rust",
     cargo_env_compat: true,
-    cargo_pkg_version: "2.27.1",
+    cargo_pkg_version: "3.2.0",
     srcs: ["src/bin/protoc-gen-rust.rs"],
-    edition: "2015",
+    edition: "2021",
     rustlibs: [
+        "libanyhow",
+        "libonce_cell",
         "libprotobuf",
         "libprotobuf_codegen",
+        "libprotobuf_parse",
+        "libregex",
+        "libtempfile",
+        "libthiserror",
     ],
     product_available: true,
     vendor_available: true,
diff --git a/Cargo.lock b/Cargo.lock
index e9b0703..c92bdea 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3,14 +3,287 @@
 version = 3
 
 [[package]]
-name = "protobuf"
-version = "2.27.1"
+name = "aho-corasick"
+version = "0.7.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf7e6d18738ecd0902d30d1ad232c9125985a3422929b16c65517b38adc14f96"
+checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98161a4e3e2184da77bb14f02184cdd111e83bbbcc9979dfee3c44b9a85f5602"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "either"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
+
+[[package]]
+name = "fastrand"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
+dependencies = [
+ "instant",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "indexmap"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.133"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0f80d65747a3e43d1596c7c5492d95d5edddaabd45a7fcdb02b95f644164966"
+
+[[package]]
+name = "log"
+version = "0.4.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "once_cell"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bd7356a8122b6c4a24a82b278680c73357984ca2fc79a0f9fa6dea7dced7c58"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "protobuf"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b55bad9126f378a853655831eb7363b7b01b81d19f8cb1218861086ca4a1a61e"
+dependencies = [
+ "once_cell",
+ "protobuf-support",
+ "thiserror",
+]
 
 [[package]]
 name = "protobuf-codegen"
-version = "2.27.1"
+version = "3.2.0"
 dependencies = [
+ "anyhow",
+ "once_cell",
  "protobuf",
+ "protobuf-parse",
+ "regex",
+ "tempfile",
+ "thiserror",
 ]
+
+[[package]]
+name = "protobuf-parse"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d39b14605eaa1f6a340aec7f320b34064feb26c93aec35d6a9a2272a8ddfa49"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "log",
+ "protobuf",
+ "protobuf-support",
+ "tempfile",
+ "thiserror",
+ "which",
+]
+
+[[package]]
+name = "protobuf-support"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d4d7b8601c814cfb36bcebb79f0e61e45e1e93640cf778837833bbed05c372"
+dependencies = [
+ "thiserror",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"
+
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52205623b1b0f064a4e71182c3b18ae902267282930c6d5462c91b859668426e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "libc",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a99cb8c4b9a8ef0e7907cd3b617cc8dc04d571c4e73c8ae403d80ac160bb122"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a891860d3c8d66fec8e73ddb3765f90082374dbaaa833407b904a94f1a7eb43"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
+
+[[package]]
+name = "which"
+version = "4.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
+dependencies = [
+ "either",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/Cargo.toml b/Cargo.toml
index ca327e2..43e4376 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,17 +10,17 @@
 # See Cargo.toml.orig for the original contents.
 
 [package]
+edition = "2021"
 name = "protobuf-codegen"
-version = "2.27.1"
+version = "3.2.0"
 authors = ["Stepan Koltsov <stepan.koltsov@gmail.com>"]
 description = """
 Code generator for rust-protobuf.
 
-Includes a library and `protoc-gen-rust` binary.
-
-See `protoc-rust` and `protobuf-codegen-pure` crates.
+Includes a library to invoke programmatically (e. g. from `build.rs`) and `protoc-gen-rust` binary.
 """
 homepage = "https://github.com/stepancheg/rust-protobuf/"
+readme = "README.md"
 license = "MIT"
 repository = "https://github.com/stepancheg/rust-protobuf/"
 
@@ -35,10 +35,23 @@
 path = "src/bin/protoc-gen-rust.rs"
 test = false
 
-[[bin]]
-name = "protobuf-bin-gen-rust-do-not-use"
-path = "src/bin/protobuf-bin-gen-rust-do-not-use.rs"
-test = false
+[dependencies.anyhow]
+version = "1.0.53"
+
+[dependencies.once_cell]
+version = "1.10.0"
 
 [dependencies.protobuf]
-version = "=2.27.1"
+version = "=3.2.0"
+
+[dependencies.protobuf-parse]
+version = "=3.2.0"
+
+[dependencies.regex]
+version = "1.5.5"
+
+[dependencies.tempfile]
+version = "3"
+
+[dependencies.thiserror]
+version = "1.0.30"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 3400e66..4cfd140 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,23 +1,29 @@
 [package]
 name = "protobuf-codegen"
-version = "2.27.1"
+version = "3.2.0"
 authors = ["Stepan Koltsov <stepan.koltsov@gmail.com>"]
+edition = "2021"
 license = "MIT"
 homepage = "https://github.com/stepancheg/rust-protobuf/"
 repository = "https://github.com/stepancheg/rust-protobuf/"
 description = """
 Code generator for rust-protobuf.
 
-Includes a library and `protoc-gen-rust` binary.
-
-See `protoc-rust` and `protobuf-codegen-pure` crates.
+Includes a library to invoke programmatically (e. g. from `build.rs`) and `protoc-gen-rust` binary.
 """
 
 [lib]
 bench = false
 
 [dependencies]
-protobuf = { path = "../protobuf", version = "=2.27.1" }
+thiserror = "1.0.30"
+anyhow    = "1.0.53"
+regex     = "1.5.5"
+once_cell = "1.10.0"
+tempfile  = "3"
+
+protobuf = { path = "../protobuf", version = "=3.2.0" }
+protobuf-parse = { path = "../protobuf-parse", version = "=3.2.0" }
 
 [[bin]]
 
@@ -25,11 +31,5 @@
 path = "src/bin/protoc-gen-rust.rs"
 test = false
 
-[[bin]]
-
-name = "protobuf-bin-gen-rust-do-not-use"
-path = "src/bin/protobuf-bin-gen-rust-do-not-use.rs"
-test = false
-
 [package.metadata.docs.rs]
 all-features = true
diff --git a/METADATA b/METADATA
index 4593845..1aefc7a 100644
--- a/METADATA
+++ b/METADATA
@@ -1,3 +1,7 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/protobuf-codegen
+# For more info, check https://cs.android.com/android/platform/superproject/+/master:tools/external_updater/README.md
+
 name: "protobuf-codegen"
 description: "Code generator for rust-protobuf.  Includes a library and `protoc-gen-rust` binary.  See `protoc-rust` and `protobuf-codegen-pure` crates."
 third_party {
@@ -7,13 +11,13 @@
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/protobuf-codegen/protobuf-codegen-2.27.1.crate"
+    value: "https://static.crates.io/crates/protobuf-codegen/protobuf-codegen-3.2.0.crate"
   }
-  version: "2.27.1"
+  version: "3.2.0"
   license_type: NOTICE
   last_upgrade_date {
-    year: 2022
-    month: 3
-    day: 1
+    year: 2023
+    month: 4
+    day: 3
   }
 }
diff --git a/README.md b/README.md
index 2ab7e05..5f1e2d7 100644
--- a/README.md
+++ b/README.md
@@ -1,37 +1,65 @@
 <!-- cargo-sync-readme start -->
 
-# Protobuf code generator
+# Protobuf code generator for `protobuf` crate
 
-This crate contains protobuf code generator implementation
-and a `protoc-gen-rust` `protoc` plugin.
+This crate is useful mostly from `build.rs` scripts to generate `.rs` files during the build.
 
-This crate:
-* provides `protoc-gen-rust` plugin for `protoc` command
-* implement protobuf codegen
+# How to generate code
 
-This crate is not meant to be used directly, in fact, it does not provide any public API
-(except for `protoc-gen-rust` binary).
+There are three main ways to generate `.rs` files from `.proto` files:
+* using `protoc` command line tool and `protoc-gen-rust` plugin
+* using this crate `Codegen` with pure rust parser
+* using this crate `Codegen` with `protoc` parser
 
-Code can be generated with either:
-* `protoc-gen-rust` plugin for `protoc` or
-* [`protoc-rust`](https://docs.rs/protoc) crate
-  (code generator which depends on `protoc` binary for parsing of `.proto` files)
-* [`protobuf-codegen-pure`](https://docs.rs/protobuf-codegen-pure) crate,
-  similar API to `protoc-rust`, but uses pure rust parser of `.proto` files.
+Which one should you use depends on your needs.
 
-# `protoc-gen-rust` plugin for `protoc`
+If you are using non-cargo build system (like Bazel), you might prefer
+using `protoc-gen-rust` plugin for `protoc`.
 
-When non-cargo build system is used, consider using standard protobuf code generation pattern:
-`protoc` command does all the work of handling paths and parsing `.proto` files.
-When `protoc` is invoked with `--rust_out=` option, it invokes `protoc-gen-rust` plugin.
-provided by this crate.
+If you build with `cargo`, you probably want to use `Codegen` from this crate.
 
-When building with cargo, consider using `protoc-rust` or `protobuf-codegen-pure` crates.
+# Protoc parser vs pure rust parser
 
-## How to use `protoc-gen-rust` if you have to
+There are two protobuf parsers which can be plugged into this crate:
+* `protoc`-based parser (`protoc` is a command like utility from Google protobuf)
+* pure rust parser (`protobuf-parse` crate)
+
+`protoc`-based parser is expected to parse `.proto` files very correctly:
+all Google's protobuf implementations rely on it.
+
+While there are no known bugs in `protobuf-parse`, it is not tested very well.
+Also `protobuf-parse` does not implement certain rarely used features of `.proto` parser,
+mostly complex message options specified in `.proto` files.
+I never saw anyone using them, but you have been warned.
+
+Note `protoc` command can be obtained from
+[`protoc-bin-vendored`](https://docs.rs/protoc-bin-vendored) crate.
+
+# Example
+
+```rust
+// Use this in build.rs
+protobuf_codegen::Codegen::new()
+    // Use `protoc` parser, optional.
+    .protoc()
+    // Use `protoc-bin-vendored` bundled protoc command, optional.
+    .protoc_path(&protoc_bin_vendored::protoc_bin_path().unwrap())
+    // All inputs and imports from the inputs must reside in `includes` directories.
+    .includes(&["src/protos"])
+    // Inputs must reside in some of include paths.
+    .input("src/protos/apple.proto")
+    .input("src/protos/banana.proto")
+    // Specify output directory relative to Cargo output directory.
+    .cargo_out_dir("protos")
+    .run_from_script();
+```
+
+## How to use `protoc-gen-rust`
+
+If you have to.
 
 (Note `protoc` can be invoked programmatically with
-[protoc crate](https://docs.rs/protoc))
+[protoc crate](https://docs.rs/protoc/%3E=3.0.0-alpha))
 
 0) Install protobuf for `protoc` binary.
 
@@ -48,11 +76,11 @@
 ```
 
 Protobuf is needed only for code generation, `rust-protobuf` runtime
-does not use `protobuf` library.
+does not use C++ protobuf library.
 
 1) Install `protoc-gen-rust` program (which is `protoc` plugin)
 
-It can be installed either from source or with `cargo install protobuf` command.
+It can be installed either from source or with `cargo install protobuf-codegen` command.
 
 2) Add `protoc-gen-rust` to $PATH
 
@@ -70,11 +98,32 @@
 
 This will generate .rs files in current directory.
 
-# Version 2
+# Customize generate code
 
-This is documentation for version 2 of the crate.
+Sometimes generated code need to be adjusted, e. g. to have custom derives.
 
-[Version 3 of the crate](https://docs.rs/protobuf-codegen/%3E=3.0.0-alpha)
-(currently in development) encapsulates both `protoc` and pure codegens in this crate.
+rust-protobuf provides two options to do that:
+* generated `.rs` files contain `@@protoc_insertion_point(...)` markers
+  (similar markers inserts Google's protobuf generator for C++ or Java).
+  Simple script `sed` one-liners can be used to replace these markers with custom annotations.
+* `Codegen::customize_callback` can be used to patch generated code
+  when invoked from `build.rs` script.
+
+# Serde
+
+rust-protobuf since version 3 no longer directly supports serde.
+
+Rust-protobuf 3 fully supports:
+* runtime reflection
+* JSON parsing and printing via
+ [`protobuf-json-mapping`](https://docs.rs/protobuf-json-mapping)
+
+Which covers the most of serde use cases.
+
+If you still need serde, generic customization callback (see above) can be used
+to insert `#[serde(...)]` annotations.
+
+[Example project](https://github.com/stepancheg/rust-protobuf/tree/master/protobuf-examples/customize-serde)
+in the rust-protobuf repository demonstrates how to do it.
 
 <!-- cargo-sync-readme end -->
diff --git a/src/bin/protobuf-bin-gen-rust-do-not-use.rs b/src/bin/protobuf-bin-gen-rust-do-not-use.rs
deleted file mode 100644
index a6f96ca..0000000
--- a/src/bin/protobuf-bin-gen-rust-do-not-use.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-extern crate protobuf;
-extern crate protobuf_codegen;
-
-use std::fs::*;
-use std::io::Read;
-use std::path::Path;
-
-use protobuf::descriptor::*;
-use protobuf::Message;
-use protobuf_codegen::*;
-
-fn write_file(bin: &str) {
-    let mut is = File::open(&Path::new(bin)).unwrap();
-    let fds = FileDescriptorSet::parse_from_reader(&mut is as &mut dyn Read).unwrap();
-
-    let file_names: Vec<String> = fds
-        .get_file()
-        .iter()
-        .map(|f| f.get_name().to_string())
-        .collect();
-    gen_and_write(
-        fds.get_file(),
-        &file_names,
-        Path::new("."),
-        &Default::default(),
-    )
-    .expect("gen_and_write");
-}
-
-fn main() {
-    let args: Vec<String> = std::env::args().collect();
-    if args.len() != 2 {
-        panic!("must have exactly one argument");
-    }
-    let ref pb_bin = args[1];
-    write_file(&pb_bin);
-}
diff --git a/src/bin/protoc-gen-rust.rs b/src/bin/protoc-gen-rust.rs
index 97ac7d2..8c34e49 100644
--- a/src/bin/protoc-gen-rust.rs
+++ b/src/bin/protoc-gen-rust.rs
@@ -1,5 +1,3 @@
-extern crate protobuf_codegen;
-
 fn main() {
-    protobuf_codegen::protoc_gen_rust_main();
+    protobuf_codegen::protoc_gen_rust::protoc_gen_rust_main();
 }
diff --git a/src/code_writer.rs b/src/code_writer.rs
deleted file mode 100644
index 50eaeb8..0000000
--- a/src/code_writer.rs
+++ /dev/null
@@ -1,387 +0,0 @@
-// TODO: used by grpc-rust, should move it into separate crate.
-#![doc(hidden)]
-
-use std::io::Write;
-
-use inside::protobuf_crate_path;
-use Customize;
-
-/// Field visibility.
-pub enum Visibility {
-    Public,
-    Default,
-}
-
-pub struct CodeWriter<'a> {
-    writer: &'a mut (dyn Write + 'a),
-    indent: String,
-}
-
-impl<'a> CodeWriter<'a> {
-    pub fn new(writer: &'a mut dyn Write) -> CodeWriter<'a> {
-        CodeWriter {
-            writer: writer,
-            indent: "".to_string(),
-        }
-    }
-
-    pub fn write_line<S: AsRef<str>>(&mut self, line: S) {
-        (if line.as_ref().is_empty() {
-            self.writer.write_all("\n".as_bytes())
-        } else {
-            let s: String = [self.indent.as_ref(), line.as_ref(), "\n"].concat();
-            self.writer.write_all(s.as_bytes())
-        })
-        .unwrap();
-    }
-
-    pub fn write_generated(&mut self) {
-        self.write_line("// This file is generated. Do not edit");
-        self.write_generated_common();
-    }
-
-    pub fn write_generated_by(&mut self, pkg: &str, version: &str) {
-        self.write_line(format!(
-            "// This file is generated by {pkg} {version}. Do not edit",
-            pkg = pkg,
-            version = version
-        ));
-        self.write_generated_common();
-    }
-
-    fn write_generated_common(&mut self) {
-        // https://secure.phabricator.com/T784
-        self.write_line("// @generated");
-
-        self.write_line("");
-        self.comment("https://github.com/rust-lang/rust-clippy/issues/702");
-        self.write_line("#![allow(unknown_lints)]");
-        self.write_line("#![allow(clippy::all)]");
-        self.write_line("");
-        self.write_line("#![allow(unused_attributes)]");
-        self.write_line("#![cfg_attr(rustfmt, rustfmt::skip)]");
-        self.write_line("");
-        self.write_line("#![allow(box_pointers)]");
-        self.write_line("#![allow(dead_code)]");
-        self.write_line("#![allow(missing_docs)]");
-        self.write_line("#![allow(non_camel_case_types)]");
-        self.write_line("#![allow(non_snake_case)]");
-        self.write_line("#![allow(non_upper_case_globals)]");
-        self.write_line("#![allow(trivial_casts)]");
-        self.write_line("#![allow(unused_imports)]");
-        self.write_line("#![allow(unused_results)]");
-    }
-
-    pub fn todo(&mut self, message: &str) {
-        self.write_line(format!("panic!(\"TODO: {}\");", message));
-    }
-
-    pub fn unimplemented(&mut self) {
-        self.write_line(format!("unimplemented!();"));
-    }
-
-    pub fn indented<F>(&mut self, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        cb(&mut CodeWriter {
-            writer: self.writer,
-            indent: format!("{}    ", self.indent),
-        });
-    }
-
-    #[allow(dead_code)]
-    pub fn commented<F>(&mut self, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        cb(&mut CodeWriter {
-            writer: self.writer,
-            indent: format!("// {}", self.indent),
-        });
-    }
-
-    pub fn pub_const(&mut self, name: &str, field_type: &str, init: &str) {
-        self.write_line(&format!("pub const {}: {} = {};", name, field_type, init));
-    }
-
-    pub fn lazy_static(&mut self, name: &str, ty: &str, customize: &Customize) {
-        self.write_line(&format!(
-            "static {}: {}::rt::LazyV2<{}> = {}::rt::LazyV2::INIT;",
-            name,
-            protobuf_crate_path(customize),
-            ty,
-            protobuf_crate_path(customize),
-        ));
-    }
-
-    pub fn lazy_static_decl_get<F>(&mut self, name: &str, ty: &str, customize: &Customize, init: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.lazy_static(name, ty, customize);
-        self.write_line(&format!("{}.get(|| {{", name));
-        self.indented(|w| init(w));
-        self.write_line(&format!("}})"));
-    }
-
-    pub fn lazy_static_decl_get_simple(
-        &mut self,
-        name: &str,
-        ty: &str,
-        init: &str,
-        customize: &Customize,
-    ) {
-        self.lazy_static(name, ty, customize);
-        self.write_line(&format!("{}.get({})", name, init));
-    }
-
-    pub fn block<F>(&mut self, first_line: &str, last_line: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.write_line(first_line);
-        self.indented(cb);
-        self.write_line(last_line);
-    }
-
-    pub fn expr_block<F>(&mut self, prefix: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.block(&format!("{} {{", prefix), "}", cb);
-    }
-
-    pub fn stmt_block<S: AsRef<str>, F>(&mut self, prefix: S, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.block(&format!("{} {{", prefix.as_ref()), "};", cb);
-    }
-
-    pub fn unsafe_expr<F>(&mut self, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block("unsafe", cb);
-    }
-
-    pub fn impl_self_block<S: AsRef<str>, F>(&mut self, name: S, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("impl {}", name.as_ref()), cb);
-    }
-
-    pub fn impl_for_block<S1: AsRef<str>, S2: AsRef<str>, F>(&mut self, tr: S1, ty: S2, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.impl_args_for_block(&[], tr.as_ref(), ty.as_ref(), cb);
-    }
-
-    pub fn impl_args_for_block<F>(&mut self, args: &[&str], tr: &str, ty: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        let args_str = if args.is_empty() {
-            "".to_owned()
-        } else {
-            format!("<{}>", args.join(", "))
-        };
-        self.expr_block(&format!("impl{} {} for {}", args_str, tr, ty), cb);
-    }
-
-    pub fn unsafe_impl(&mut self, what: &str, for_what: &str) {
-        self.write_line(&format!("unsafe impl {} for {} {{}}", what, for_what));
-    }
-
-    pub fn pub_struct<S: AsRef<str>, F>(&mut self, name: S, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("pub struct {}", name.as_ref()), cb);
-    }
-
-    pub fn def_struct<S: AsRef<str>, F>(&mut self, name: S, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("struct {}", name.as_ref()), cb);
-    }
-
-    pub fn pub_enum<F>(&mut self, name: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("pub enum {}", name), cb);
-    }
-
-    pub fn pub_trait<F>(&mut self, name: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("pub trait {}", name), cb);
-    }
-
-    pub fn pub_trait_extend<F>(&mut self, name: &str, extend: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("pub trait {} : {}", name, extend), cb);
-    }
-
-    pub fn field_entry(&mut self, name: &str, value: &str) {
-        self.write_line(&format!("{}: {},", name, value));
-    }
-
-    pub fn field_decl(&mut self, name: &str, field_type: &str) {
-        self.write_line(&format!("{}: {},", name, field_type));
-    }
-
-    pub fn pub_field_decl(&mut self, name: &str, field_type: &str) {
-        self.write_line(&format!("pub {}: {},", name, field_type));
-    }
-
-    pub fn field_decl_vis(&mut self, vis: Visibility, name: &str, field_type: &str) {
-        match vis {
-            Visibility::Public => self.pub_field_decl(name, field_type),
-            Visibility::Default => self.field_decl(name, field_type),
-        }
-    }
-
-    pub fn derive(&mut self, derive: &[&str]) {
-        let v: Vec<String> = derive.iter().map(|&s| s.to_string()).collect();
-        self.write_line(&format!("#[derive({})]", v.join(",")));
-    }
-
-    pub fn allow(&mut self, what: &[&str]) {
-        let v: Vec<String> = what.iter().map(|&s| s.to_string()).collect();
-        self.write_line(&format!("#[allow({})]", v.join(",")));
-    }
-
-    pub fn comment(&mut self, comment: &str) {
-        if comment.is_empty() {
-            self.write_line("//");
-        } else {
-            self.write_line(&format!("// {}", comment));
-        }
-    }
-
-    pub fn fn_def(&mut self, sig: &str) {
-        self.write_line(&format!("fn {};", sig));
-    }
-
-    pub fn fn_block<F>(&mut self, public: bool, sig: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        if public {
-            self.expr_block(&format!("pub fn {}", sig), cb);
-        } else {
-            self.expr_block(&format!("fn {}", sig), cb);
-        }
-    }
-
-    pub fn pub_fn<F>(&mut self, sig: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.fn_block(true, sig, cb);
-    }
-
-    pub fn def_fn<F>(&mut self, sig: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.fn_block(false, sig, cb);
-    }
-
-    pub fn def_mod<F>(&mut self, name: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("mod {}", name), cb)
-    }
-
-    pub fn pub_mod<F>(&mut self, name: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("pub mod {}", name), cb)
-    }
-
-    pub fn while_block<S: AsRef<str>, F>(&mut self, cond: S, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("while {}", cond.as_ref()), cb);
-    }
-
-    // if ... { ... }
-    pub fn if_stmt<S: AsRef<str>, F>(&mut self, cond: S, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("if {}", cond.as_ref()), cb);
-    }
-
-    // if ... {} else { ... }
-    pub fn if_else_stmt<S: AsRef<str>, F>(&mut self, cond: S, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.write_line(&format!("if {} {{", cond.as_ref()));
-        self.write_line("} else {");
-        self.indented(cb);
-        self.write_line("}");
-    }
-
-    // if let ... = ... { ... }
-    pub fn if_let_stmt<F>(&mut self, decl: &str, expr: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.if_stmt(&format!("let {} = {}", decl, expr), cb);
-    }
-
-    // if let ... = ... { } else { ... }
-    pub fn if_let_else_stmt<F>(&mut self, decl: &str, expr: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.if_else_stmt(&format!("let {} = {}", decl, expr), cb);
-    }
-
-    pub fn for_stmt<S1: AsRef<str>, S2: AsRef<str>, F>(&mut self, over: S1, varn: S2, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.stmt_block(&format!("for {} in {}", varn.as_ref(), over.as_ref()), cb)
-    }
-
-    pub fn match_block<S: AsRef<str>, F>(&mut self, value: S, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.stmt_block(&format!("match {}", value.as_ref()), cb);
-    }
-
-    pub fn match_expr<S: AsRef<str>, F>(&mut self, value: S, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.expr_block(&format!("match {}", value.as_ref()), cb);
-    }
-
-    pub fn case_block<S: AsRef<str>, F>(&mut self, cond: S, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        self.block(&format!("{} => {{", cond.as_ref()), "},", cb);
-    }
-
-    pub fn case_expr<S1: AsRef<str>, S2: AsRef<str>>(&mut self, cond: S1, body: S2) {
-        self.write_line(&format!("{} => {},", cond.as_ref(), body.as_ref()));
-    }
-}
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
new file mode 100644
index 0000000..3b8f629
--- /dev/null
+++ b/src/codegen/mod.rs
@@ -0,0 +1,272 @@
+use std::env;
+use std::ffi::OsString;
+use std::fs;
+use std::path::Component;
+use std::path::Path;
+use std::path::PathBuf;
+use std::process;
+
+use anyhow::Context;
+use protobuf_parse::Parser;
+
+use crate::customize::CustomizeCallback;
+use crate::customize::CustomizeCallbackHolder;
+use crate::gen_and_write::gen_and_write;
+use crate::Customize;
+
+#[derive(Debug)]
+enum WhichParser {
+    Pure,
+    Protoc,
+}
+
+impl Default for WhichParser {
+    fn default() -> WhichParser {
+        WhichParser::Pure
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+enum CodegenError {
+    #[error("out_dir is not specified")]
+    OutDirNotSpecified,
+}
+
+/// Entry point for `.proto` to `.rs` code generation.
+///
+/// This is similar to `protoc --rust_out...`.
+#[derive(Debug, Default)]
+pub struct Codegen {
+    /// What parser to use to parse `.proto` files.
+    which_parser: Option<WhichParser>,
+    /// Create out directory.
+    create_out_dir: bool,
+    /// --lang_out= param
+    out_dir: Option<PathBuf>,
+    /// -I args
+    includes: Vec<PathBuf>,
+    /// List of .proto files to compile
+    inputs: Vec<PathBuf>,
+    /// Customize code generation
+    customize: Customize,
+    /// Customize code generation
+    customize_callback: CustomizeCallbackHolder,
+    /// Protoc command path
+    protoc: Option<PathBuf>,
+    /// Extra `protoc` args
+    protoc_extra_args: Vec<OsString>,
+    /// Capture stderr when running `protoc`.
+    capture_stderr: bool,
+}
+
+impl Codegen {
+    /// Create new codegen object.
+    ///
+    /// Uses `protoc` from `$PATH` by default.
+    ///
+    /// Can be switched to pure rust parser using [`pure`](Self::pure) function.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Switch to pure Rust parser of `.proto` files.
+    pub fn pure(&mut self) -> &mut Self {
+        self.which_parser = Some(WhichParser::Pure);
+        self
+    }
+
+    /// Switch to `protoc` parser of `.proto` files.
+    pub fn protoc(&mut self) -> &mut Self {
+        self.which_parser = Some(WhichParser::Protoc);
+        self
+    }
+
+    /// Output directory for generated code.
+    ///
+    /// When invoking from `build.rs`, consider using
+    /// [`cargo_out_dir`](Self::cargo_out_dir) instead.
+    pub fn out_dir(&mut self, out_dir: impl AsRef<Path>) -> &mut Self {
+        self.out_dir = Some(out_dir.as_ref().to_owned());
+        self
+    }
+
+    /// Set output directory relative to Cargo output dir.
+    ///
+    /// With this option, output directory is erased and recreated during invocation.
+    pub fn cargo_out_dir(&mut self, rel: &str) -> &mut Self {
+        let rel = Path::new(rel);
+        let mut not_empty = false;
+        for comp in rel.components() {
+            match comp {
+                Component::ParentDir => {
+                    panic!("parent path in components of rel path: `{}`", rel.display());
+                }
+                Component::CurDir => {
+                    continue;
+                }
+                Component::Normal(..) => {}
+                Component::RootDir | Component::Prefix(..) => {
+                    panic!("root dir in components of rel path: `{}`", rel.display());
+                }
+            }
+            not_empty = true;
+        }
+
+        if !not_empty {
+            panic!("empty rel path: `{}`", rel.display());
+        }
+
+        let cargo_out_dir = env::var("OUT_DIR").expect("OUT_DIR env var not set");
+        let mut path = PathBuf::from(cargo_out_dir);
+        path.push(rel);
+        self.create_out_dir = true;
+        self.out_dir(path)
+    }
+
+    /// Add an include directory.
+    pub fn include(&mut self, include: impl AsRef<Path>) -> &mut Self {
+        self.includes.push(include.as_ref().to_owned());
+        self
+    }
+
+    /// Add include directories.
+    pub fn includes(&mut self, includes: impl IntoIterator<Item = impl AsRef<Path>>) -> &mut Self {
+        for include in includes {
+            self.include(include);
+        }
+        self
+    }
+
+    /// Append a `.proto` file path to compile
+    pub fn input(&mut self, input: impl AsRef<Path>) -> &mut Self {
+        self.inputs.push(input.as_ref().to_owned());
+        self
+    }
+
+    /// Append multiple `.proto` file paths to compile
+    pub fn inputs(&mut self, inputs: impl IntoIterator<Item = impl AsRef<Path>>) -> &mut Self {
+        for input in inputs {
+            self.input(input);
+        }
+        self
+    }
+
+    /// Specify `protoc` command path to be used when invoking code generation.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// # mod protoc_bin_vendored {
+    /// #   pub fn protoc_bin_path() -> Result<std::path::PathBuf, std::io::Error> {
+    /// #       unimplemented!()
+    /// #   }
+    /// # }
+    ///
+    /// use protobuf_codegen::Codegen;
+    ///
+    /// Codegen::new()
+    ///     .protoc()
+    ///     .protoc_path(&protoc_bin_vendored::protoc_bin_path().unwrap())
+    ///     // ...
+    ///     .run()
+    ///     .unwrap();
+    /// ```
+    ///
+    /// This option is ignored when pure Rust parser is used.
+    pub fn protoc_path(&mut self, protoc: &Path) -> &mut Self {
+        self.protoc = Some(protoc.to_owned());
+        self
+    }
+
+    /// Capture stderr to error when running `protoc`.
+    pub fn capture_stderr(&mut self) -> &mut Self {
+        self.capture_stderr = true;
+        self
+    }
+
+    /// Extra command line flags for `protoc` invocation.
+    ///
+    /// For example, `--experimental_allow_proto3_optional` option.
+    ///
+    /// This option is ignored when pure Rust parser is used.
+    pub fn protoc_extra_arg(&mut self, arg: impl Into<OsString>) -> &mut Self {
+        self.protoc_extra_args.push(arg.into());
+        self
+    }
+
+    /// Set options to customize code generation
+    pub fn customize(&mut self, customize: Customize) -> &mut Self {
+        self.customize.update_with(&customize);
+        self
+    }
+
+    /// Callback for dynamic per-element customization.
+    pub fn customize_callback(&mut self, callback: impl CustomizeCallback) -> &mut Self {
+        self.customize_callback = CustomizeCallbackHolder::new(callback);
+        self
+    }
+
+    /// Invoke the code generation.
+    ///
+    /// This is roughly equivalent to `protoc --rust_out=...` but
+    /// without requiring `protoc-gen-rust` command in `$PATH`.
+    ///
+    /// This function uses pure Rust parser or `protoc` parser depending on
+    /// how this object was configured.
+    pub fn run(&self) -> anyhow::Result<()> {
+        let out_dir = match &self.out_dir {
+            Some(out_dir) => out_dir,
+            None => return Err(CodegenError::OutDirNotSpecified.into()),
+        };
+
+        if self.create_out_dir {
+            if out_dir.exists() {
+                fs::remove_dir_all(&out_dir)?;
+            }
+            fs::create_dir(&out_dir)?;
+        }
+
+        let mut parser = Parser::new();
+        parser.protoc();
+        if let Some(protoc) = &self.protoc {
+            parser.protoc_path(protoc);
+        }
+        match &self.which_parser {
+            Some(WhichParser::Protoc) => {
+                parser.protoc();
+            }
+            Some(WhichParser::Pure) => {
+                parser.pure();
+            }
+            None => {}
+        }
+
+        parser.inputs(&self.inputs);
+        parser.includes(&self.includes);
+
+        if self.capture_stderr {
+            parser.capture_stderr();
+        }
+
+        let parsed_and_typechecked = parser
+            .parse_and_typecheck()
+            .context("parse and typecheck")?;
+
+        gen_and_write(
+            &parsed_and_typechecked.file_descriptors,
+            &parsed_and_typechecked.parser,
+            &parsed_and_typechecked.relative_paths,
+            &out_dir,
+            &self.customize,
+            &*self.customize_callback,
+        )
+    }
+
+    /// Similar to `run`, but prints the message to stderr and exits the process on error.
+    pub fn run_from_script(&self) {
+        if let Err(e) = self.run() {
+            eprintln!("codegen failed: {:?}", e);
+            process::exit(1);
+        }
+    }
+}
diff --git a/src/compiler_plugin.rs b/src/compiler_plugin.rs
new file mode 100644
index 0000000..b7ff6ea
--- /dev/null
+++ b/src/compiler_plugin.rs
@@ -0,0 +1,48 @@
+use std::io::stdin;
+use std::io::stdout;
+use std::str;
+
+use protobuf::descriptor::FileDescriptorProto;
+use protobuf::plugin::*;
+use protobuf::Message;
+use protobuf_parse::ProtoPathBuf;
+
+pub struct GenRequest<'a> {
+    pub file_descriptors: &'a [FileDescriptorProto],
+    pub files_to_generate: &'a [ProtoPathBuf],
+    pub parameter: &'a str,
+}
+
+pub struct GenResult {
+    pub name: String,
+    pub content: Vec<u8>,
+}
+
+pub fn plugin_main<F>(gen: F) -> anyhow::Result<()>
+where
+    F: Fn(&GenRequest) -> anyhow::Result<Vec<GenResult>>,
+{
+    let req = CodeGeneratorRequest::parse_from_reader(&mut stdin()).unwrap();
+    let result = gen(&GenRequest {
+        file_descriptors: &req.proto_file,
+        files_to_generate: &req
+            .file_to_generate
+            .iter()
+            .map(|n| ProtoPathBuf::new(n.to_owned()))
+            .collect::<anyhow::Result<Vec<_>>>()?,
+        parameter: req.parameter(),
+    })?;
+    let mut resp = CodeGeneratorResponse::new();
+    resp.set_supported_features(code_generator_response::Feature::FEATURE_PROTO3_OPTIONAL as u64);
+    resp.file = result
+        .iter()
+        .map(|file| {
+            let mut r = code_generator_response::File::new();
+            r.set_name(file.name.to_string());
+            r.set_content(str::from_utf8(file.content.as_ref()).unwrap().to_string());
+            r
+        })
+        .collect();
+    resp.write_to_writer(&mut stdout()).unwrap();
+    Ok(())
+}
diff --git a/src/customize.rs b/src/customize.rs
deleted file mode 100644
index b3415ab..0000000
--- a/src/customize.rs
+++ /dev/null
@@ -1,237 +0,0 @@
-use protobuf::descriptor::EnumOptions;
-use protobuf::descriptor::FieldOptions;
-use protobuf::descriptor::FileOptions;
-use protobuf::descriptor::MessageOptions;
-use protobuf::rustproto;
-
-/// Specifies style of generated code.
-#[derive(Default, Debug, Clone)]
-pub struct Customize {
-    /// Make oneof enum public.
-    pub expose_oneof: Option<bool>,
-    /// When true all fields are public, and accessors are not generated
-    pub expose_fields: Option<bool>,
-    /// When false, `get_`, `set_`, `mut_` etc. accessors are not generated
-    pub generate_accessors: Option<bool>,
-    /// Use `bytes::Bytes` for `bytes` fields
-    pub carllerche_bytes_for_bytes: Option<bool>,
-    /// Use `bytes::Bytes` for `string` fields
-    pub carllerche_bytes_for_string: Option<bool>,
-    /// Implement serde_derive for messages
-    pub serde_derive: Option<bool>,
-    /// When `serde_derive` is set, serde annotations will be guarded with `#[cfg(cfg, ...)]`.
-    pub serde_derive_cfg: Option<String>,
-    /// When `serde_derive` is set, use attribute rename_all
-    pub serde_rename_all: Option<String>,
-    /// Enable lite runtime
-    pub lite_runtime: Option<bool>,
-    /// Generate `mod.rs` in the output directory.
-    ///
-    /// This option allows inclusion of generated files from cargo output directory.
-    ///
-    /// This option will likely be on by default in rust-protobuf version 3.
-    pub gen_mod_rs: Option<bool>,
-    /// Used internally to generate protos bundled in protobuf crate
-    /// like `descriptor.proto`
-    pub inside_protobuf: Option<bool>,
-
-    // When adding more options please keep in sync with `parse_from_parameter` below.
-    /// Make sure `Customize` is always used with `..Default::default()`
-    /// for future compatibility.
-    pub _future_options: (),
-}
-
-#[derive(Debug)]
-pub enum CustomizeParseParameterError {
-    EqNotFound,
-    CannotParseBool,
-    UnknownOptionName(String),
-}
-
-pub type CustomizeParseParameterResult<T> = Result<T, CustomizeParseParameterError>;
-
-impl Customize {
-    /// Update fields of self with fields defined in other customize
-    pub fn update_with(&mut self, that: &Customize) {
-        if let Some(v) = that.expose_oneof {
-            self.expose_oneof = Some(v);
-        }
-        if let Some(v) = that.expose_fields {
-            self.expose_fields = Some(v);
-        }
-        if let Some(v) = that.generate_accessors {
-            self.generate_accessors = Some(v);
-        }
-        if let Some(v) = that.carllerche_bytes_for_bytes {
-            self.carllerche_bytes_for_bytes = Some(v);
-        }
-        if let Some(v) = that.carllerche_bytes_for_string {
-            self.carllerche_bytes_for_string = Some(v);
-        }
-        if let Some(v) = that.serde_derive {
-            self.serde_derive = Some(v);
-        }
-        if let Some(ref v) = that.serde_derive_cfg {
-            self.serde_derive_cfg = Some(v.clone());
-        }
-        if let Some(ref v) = that.serde_rename_all {
-            self.serde_rename_all = Some(v.clone());
-        }
-        if let Some(v) = that.lite_runtime {
-            self.lite_runtime = Some(v);
-        }
-        if let Some(v) = that.gen_mod_rs {
-            self.gen_mod_rs = Some(v);
-        }
-        if let Some(v) = that.inside_protobuf {
-            self.inside_protobuf = Some(v);
-        }
-    }
-
-    /// Update unset fields of self with fields from other customize
-    pub fn set_defaults_from(&mut self, other: &Customize) {
-        let mut tmp = other.clone();
-        tmp.update_with(self);
-        *self = tmp;
-    }
-
-    /// Parse customize options from a string passed via protoc flag.
-    pub fn parse_from_parameter(parameter: &str) -> CustomizeParseParameterResult<Customize> {
-        fn parse_bool(v: &str) -> CustomizeParseParameterResult<bool> {
-            v.parse()
-                .map_err(|_| CustomizeParseParameterError::CannotParseBool)
-        }
-
-        let mut r = Customize::default();
-        for nv in parameter.split_whitespace() {
-            let eq = match nv.find('=') {
-                Some(eq) => eq,
-                None => return Err(CustomizeParseParameterError::EqNotFound),
-            };
-
-            let n = &nv[..eq];
-            let v = &nv[eq + 1..];
-
-            if n == "expose_oneof" {
-                r.expose_oneof = Some(parse_bool(v)?);
-            } else if n == "expose_fields" {
-                r.expose_fields = Some(parse_bool(v)?);
-            } else if n == "generate_accessors" {
-                r.generate_accessors = Some(parse_bool(v)?);
-            } else if n == "carllerche_bytes_for_bytes" {
-                r.carllerche_bytes_for_bytes = Some(parse_bool(v)?);
-            } else if n == "carllerche_bytes_for_string" {
-                r.carllerche_bytes_for_string = Some(parse_bool(v)?);
-            } else if n == "serde_derive" {
-                r.serde_derive = Some(parse_bool(v)?);
-            } else if n == "serde_derive_cfg" {
-                r.serde_derive_cfg = Some(v.to_owned());
-            } else if n == "serde_rename_all" {
-                r.serde_rename_all = Some(v.to_owned());
-            } else if n == "lite_runtime" {
-                r.lite_runtime = Some(parse_bool(v)?);
-            } else if n == "gen_mod_rs" {
-                r.gen_mod_rs = Some(parse_bool(v)?);
-            } else if n == "inside_protobuf" {
-                r.inside_protobuf = Some(parse_bool(v)?);
-            } else {
-                return Err(CustomizeParseParameterError::UnknownOptionName(
-                    n.to_owned(),
-                ));
-            }
-        }
-        Ok(r)
-    }
-}
-
-pub fn customize_from_rustproto_for_message(source: &MessageOptions) -> Customize {
-    let expose_oneof = rustproto::exts::expose_oneof.get(source);
-    let expose_fields = rustproto::exts::expose_fields.get(source);
-    let generate_accessors = rustproto::exts::generate_accessors.get(source);
-    let carllerche_bytes_for_bytes = rustproto::exts::carllerche_bytes_for_bytes.get(source);
-    let carllerche_bytes_for_string = rustproto::exts::carllerche_bytes_for_string.get(source);
-    let serde_derive = rustproto::exts::serde_derive.get(source);
-    let serde_derive_cfg = rustproto::exts::serde_derive_cfg.get(source);
-    let lite_runtime = None;
-    let gen_mod_rs = None;
-    let inside_protobuf = None;
-    let serde_rename_all = None;
-    Customize {
-        expose_oneof,
-        expose_fields,
-        generate_accessors,
-        carllerche_bytes_for_bytes,
-        carllerche_bytes_for_string,
-        serde_derive,
-        serde_derive_cfg,
-        serde_rename_all,
-        lite_runtime,
-        gen_mod_rs,
-        inside_protobuf,
-        _future_options: (),
-    }
-}
-
-pub fn customize_from_rustproto_for_enum(source: &EnumOptions) -> Customize {
-    let serde_rename_all = rustproto::exts::serde_rename_all.get(source);
-    let mut r = Customize::default();
-    r.serde_rename_all = serde_rename_all;
-    return r;
-}
-
-pub fn customize_from_rustproto_for_field(source: &FieldOptions) -> Customize {
-    let expose_oneof = None;
-    let expose_fields = rustproto::exts::expose_fields_field.get(source);
-    let generate_accessors = rustproto::exts::generate_accessors_field.get(source);
-    let carllerche_bytes_for_bytes = rustproto::exts::carllerche_bytes_for_bytes_field.get(source);
-    let carllerche_bytes_for_string =
-        rustproto::exts::carllerche_bytes_for_string_field.get(source);
-    let serde_rename_all = None;
-    let serde_derive = None;
-    let serde_derive_cfg = None;
-    let lite_runtime = None;
-    let gen_mod_rs = None;
-    let inside_protobuf = None;
-    Customize {
-        expose_oneof,
-        expose_fields,
-        generate_accessors,
-        carllerche_bytes_for_bytes,
-        carllerche_bytes_for_string,
-        serde_derive,
-        serde_derive_cfg,
-        serde_rename_all,
-        lite_runtime,
-        gen_mod_rs,
-        inside_protobuf,
-        _future_options: (),
-    }
-}
-
-pub fn customize_from_rustproto_for_file(source: &FileOptions) -> Customize {
-    let expose_oneof = rustproto::exts::expose_oneof_all.get(source);
-    let expose_fields = rustproto::exts::expose_fields_all.get(source);
-    let generate_accessors = rustproto::exts::generate_accessors_all.get(source);
-    let carllerche_bytes_for_bytes = rustproto::exts::carllerche_bytes_for_bytes_all.get(source);
-    let carllerche_bytes_for_string = rustproto::exts::carllerche_bytes_for_string_all.get(source);
-    let serde_derive = rustproto::exts::serde_derive_all.get(source);
-    let serde_derive_cfg = rustproto::exts::serde_derive_cfg_all.get(source);
-    let lite_runtime = rustproto::exts::lite_runtime_all.get(source);
-    let gen_mod_rs = None;
-    let inside_protobuf = None;
-    let serde_rename_all = None;
-    Customize {
-        expose_oneof,
-        expose_fields,
-        generate_accessors,
-        carllerche_bytes_for_bytes,
-        carllerche_bytes_for_string,
-        serde_derive,
-        serde_derive_cfg,
-        serde_rename_all,
-        lite_runtime,
-        inside_protobuf,
-        gen_mod_rs,
-        _future_options: (),
-    }
-}
diff --git a/src/customize/ctx.rs b/src/customize/ctx.rs
new file mode 100644
index 0000000..185fc31
--- /dev/null
+++ b/src/customize/ctx.rs
@@ -0,0 +1,92 @@
+use std::fmt;
+
+use protobuf::reflect::EnumDescriptor;
+use protobuf::reflect::FieldDescriptor;
+use protobuf::reflect::FileDescriptor;
+use protobuf::reflect::MessageDescriptor;
+use protobuf::reflect::OneofDescriptor;
+
+use crate::customize::CustomizeCallback;
+use crate::Customize;
+
+#[derive(Clone)]
+pub(crate) struct CustomizeElemCtx<'a> {
+    pub(crate) for_elem: Customize,
+    pub(crate) for_children: Customize,
+    pub(crate) callback: &'a dyn CustomizeCallback,
+}
+
+impl<'a> fmt::Debug for CustomizeElemCtx<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("CustomizeElemCtx")
+            .field("for_elem", &self.for_elem)
+            .field("for_children", &self.for_children)
+            .finish_non_exhaustive()
+    }
+}
+
+impl<'a> CustomizeElemCtx<'a> {
+    pub(crate) fn child(
+        &self,
+        elem_from_rustproto: &Customize,
+        elem_descriptor: &impl DescriptorForCustomize,
+    ) -> CustomizeElemCtx<'a> {
+        let mut for_elem = self.for_children.clone();
+        for_elem.update_with(elem_from_rustproto);
+
+        let for_children = for_elem.clone();
+
+        for_elem.update_with(&elem_descriptor.customize(self.callback));
+
+        CustomizeElemCtx {
+            for_elem,
+            for_children,
+            callback: self.callback,
+        }
+    }
+}
+
+pub(crate) trait DescriptorForCustomize {
+    fn customize(&self, callback: &dyn CustomizeCallback) -> Customize;
+}
+
+impl DescriptorForCustomize for MessageDescriptor {
+    fn customize(&self, callback: &dyn CustomizeCallback) -> Customize {
+        callback.message(self)
+    }
+}
+
+impl DescriptorForCustomize for FieldDescriptor {
+    fn customize(&self, callback: &dyn CustomizeCallback) -> Customize {
+        callback.field(self)
+    }
+}
+
+impl DescriptorForCustomize for EnumDescriptor {
+    fn customize(&self, callback: &dyn CustomizeCallback) -> Customize {
+        callback.enumeration(self)
+    }
+}
+
+impl DescriptorForCustomize for OneofDescriptor {
+    fn customize(&self, callback: &dyn CustomizeCallback) -> Customize {
+        callback.oneof(self)
+    }
+}
+
+impl DescriptorForCustomize for FileDescriptor {
+    fn customize(&self, callback: &dyn CustomizeCallback) -> Customize {
+        callback.file(self)
+    }
+}
+
+pub(crate) struct SpecialFieldPseudoDescriptor<'a> {
+    pub(crate) message: &'a MessageDescriptor,
+    pub(crate) field: &'a str,
+}
+
+impl<'a> DescriptorForCustomize for SpecialFieldPseudoDescriptor<'a> {
+    fn customize(&self, callback: &dyn CustomizeCallback) -> Customize {
+        callback.special_field(self.message, self.field)
+    }
+}
diff --git a/src/customize/mod.rs b/src/customize/mod.rs
new file mode 100644
index 0000000..826bd3f
--- /dev/null
+++ b/src/customize/mod.rs
@@ -0,0 +1,251 @@
+pub(crate) mod ctx;
+pub(crate) mod rustproto_proto;
+
+use std::fmt;
+use std::ops::Deref;
+use std::rc::Rc;
+
+use protobuf::reflect::EnumDescriptor;
+use protobuf::reflect::FieldDescriptor;
+use protobuf::reflect::FileDescriptor;
+use protobuf::reflect::MessageDescriptor;
+use protobuf::reflect::OneofDescriptor;
+
+/// Dynamic callback to customize code generation.
+pub trait CustomizeCallback: 'static {
+    fn file(&self, file: &FileDescriptor) -> Customize {
+        let _ = file;
+        Customize::default()
+    }
+
+    fn message(&self, message: &MessageDescriptor) -> Customize {
+        let _ = message;
+        Customize::default()
+    }
+
+    fn field(&self, field: &FieldDescriptor) -> Customize {
+        let _ = field;
+        Customize::default()
+    }
+
+    fn special_field(&self, message: &MessageDescriptor, field: &str) -> Customize {
+        let _ = (message, field);
+        Customize::default()
+    }
+
+    fn enumeration(&self, enum_type: &EnumDescriptor) -> Customize {
+        let _ = enum_type;
+        Customize::default()
+    }
+
+    fn oneof(&self, oneof: &OneofDescriptor) -> Customize {
+        let _ = oneof;
+        Customize::default()
+    }
+}
+
+pub(crate) struct CustomizeCallbackDefault;
+impl CustomizeCallback for CustomizeCallbackDefault {}
+
+#[derive(Clone)]
+pub(crate) struct CustomizeCallbackHolder(pub(crate) Rc<dyn CustomizeCallback>);
+
+impl CustomizeCallbackHolder {
+    pub(crate) fn new(callback: impl CustomizeCallback) -> CustomizeCallbackHolder {
+        CustomizeCallbackHolder(Rc::new(callback))
+    }
+}
+
+impl Deref for CustomizeCallbackHolder {
+    type Target = dyn CustomizeCallback;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+
+impl Default for CustomizeCallbackHolder {
+    fn default() -> Self {
+        CustomizeCallbackHolder(Rc::new(CustomizeCallbackDefault))
+    }
+}
+
+impl PartialEq for CustomizeCallbackHolder {
+    fn eq(&self, other: &Self) -> bool {
+        Rc::ptr_eq(&self.0, &other.0)
+    }
+}
+
+impl fmt::Debug for CustomizeCallbackHolder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("CustomizeCallbackWrapper")
+            .finish_non_exhaustive()
+    }
+}
+
+/// Specifies style of generated code.
+/// Generated files can be customized using this proto
+/// or using `rustproto.proto` options.
+#[derive(Default, Debug, Clone, PartialEq)]
+pub struct Customize {
+    /// Code to insert before the element in the generated file.
+    pub(crate) before: Option<String>,
+    /// When false, `get_`, `set_`, `mut_` etc. accessors are not generated
+    pub(crate) generate_accessors: Option<bool>,
+    /// When false, `get_` is not generated even if `syntax = "proto2"`
+    pub(crate) generate_getter: Option<bool>,
+    /// Use `bytes::Bytes` for `bytes` fields
+    pub(crate) tokio_bytes: Option<bool>,
+    /// Use `bytes::Bytes` for `string` fields
+    pub(crate) tokio_bytes_for_string: Option<bool>,
+    /// Enable lite runtime.
+    pub(crate) lite_runtime: Option<bool>,
+    /// Generate `mod.rs` in the output directory.
+    ///
+    /// This option allows inclusion of generated files from cargo output directory.
+    ///
+    /// This option will likely be on by default in rust-protobuf version 3.
+    pub(crate) gen_mod_rs: Option<bool>,
+    /// Used internally to generate protos bundled in protobuf crate
+    /// like `descriptor.proto`
+    pub(crate) inside_protobuf: Option<bool>,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum CustomizeParseParameterError {
+    #[error("Cannot parse bool option value: {:?}", .0)]
+    CannotParseBool(String),
+    #[error("Unknown option name: {:?}", .0)]
+    UnknownOptionName(String),
+}
+
+impl Customize {
+    /// Insert code before the element in the generated file
+    /// (e. g. serde annotations, see
+    /// [example here](https://github.com/stepancheg/rust-protobuf/tree/master/protobuf-examples/customize-serde)).
+    pub fn before(mut self, before: &str) -> Self {
+        self.before = Some(before.to_owned());
+        self
+    }
+
+    pub fn generate_accessors(mut self, generate_accessors: bool) -> Self {
+        self.generate_accessors = Some(generate_accessors);
+        self
+    }
+
+    pub fn generate_getter(mut self, generate_getter: bool) -> Self {
+        self.generate_getter = Some(generate_getter);
+        self
+    }
+
+    pub fn tokio_bytes(mut self, tokio_bytes: bool) -> Self {
+        self.tokio_bytes = Some(tokio_bytes);
+        self
+    }
+
+    pub fn tokio_bytes_for_string(mut self, tokio_bytes_for_string: bool) -> Self {
+        self.tokio_bytes_for_string = Some(tokio_bytes_for_string);
+        self
+    }
+
+    /// Generate code for "lite runtime". Generated code contains no code for reflection.
+    /// So the generated code (and more importantly, generated binary size) is smaller,
+    /// but reflection, text format, JSON serialization won't work.
+    ///
+    /// Note when using `protoc` plugin `protoc-gen-rust`, the option name is just `lite`.
+    pub fn lite_runtime(mut self, lite_runtime: bool) -> Self {
+        self.lite_runtime = Some(lite_runtime);
+        self
+    }
+
+    /// Generate `mod.rs` with all the generated modules.
+    /// This option is on by default in rust-protobuf version 3.
+    pub fn gen_mod_rs(mut self, gen_mod_rs: bool) -> Self {
+        self.gen_mod_rs = Some(gen_mod_rs);
+        self
+    }
+
+    /// Generate code bundled in protobuf crate. Regular users don't need this option.
+    pub fn inside_protobuf(mut self, inside_protobuf: bool) -> Self {
+        self.inside_protobuf = Some(inside_protobuf);
+        self
+    }
+
+    /// Update fields of self with fields defined in other customize
+    pub fn update_with(&mut self, that: &Customize) {
+        if let Some(v) = &that.before {
+            self.before = Some(v.clone());
+        }
+        if let Some(v) = that.generate_accessors {
+            self.generate_accessors = Some(v);
+        }
+        if let Some(v) = that.generate_getter {
+            self.generate_getter = Some(v);
+        }
+        if let Some(v) = that.tokio_bytes {
+            self.tokio_bytes = Some(v);
+        }
+        if let Some(v) = that.tokio_bytes_for_string {
+            self.tokio_bytes_for_string = Some(v);
+        }
+        if let Some(v) = that.lite_runtime {
+            self.lite_runtime = Some(v);
+        }
+        if let Some(v) = that.gen_mod_rs {
+            self.gen_mod_rs = Some(v);
+        }
+        if let Some(v) = that.inside_protobuf {
+            self.inside_protobuf = Some(v);
+        }
+    }
+
+    /// Update unset fields of self with fields from other customize
+    pub fn set_defaults_from(&mut self, other: &Customize) {
+        let mut tmp = other.clone();
+        tmp.update_with(self);
+        *self = tmp;
+    }
+
+    /// Parse customize options from a string passed via protoc flag.
+    pub fn parse_from_parameter(parameter: &str) -> anyhow::Result<Customize> {
+        fn parse_bool(v: &str) -> anyhow::Result<bool> {
+            v.parse()
+                .map_err(|_| CustomizeParseParameterError::CannotParseBool(v.to_owned()).into())
+        }
+
+        let mut r = Customize::default();
+        for nv in parameter.split_whitespace() {
+            let (n, v) = match nv.find('=') {
+                Some(eq) => {
+                    let n = &nv[..eq];
+                    let v = &nv[eq + 1..];
+                    (n, v)
+                }
+                None => (nv, "true"),
+            };
+
+            if n == "generate_accessors" {
+                r.generate_accessors = Some(parse_bool(v)?);
+            } else if n == "generate_getter" {
+                r.generate_getter = Some(parse_bool(v)?);
+            } else if n == "tokio_bytes" {
+                r.tokio_bytes = Some(parse_bool(v)?);
+            } else if n == "tokio_bytes_for_string" {
+                r.tokio_bytes_for_string = Some(parse_bool(v)?);
+            } else if n == "lite_runtime" {
+                r.lite_runtime = Some(parse_bool(v)?);
+            } else if n == "gen_mod_rs" {
+                r.gen_mod_rs = Some(parse_bool(v)?);
+            } else if n == "inside_protobuf" {
+                r.inside_protobuf = Some(parse_bool(v)?);
+            } else if n == "lite" {
+                // Support Java and C++ protoc plugin syntax:
+                // https://github.com/protocolbuffers/protobuf/issues/6489
+                r.lite_runtime = Some(parse_bool(v)?);
+            } else {
+                return Err(CustomizeParseParameterError::UnknownOptionName(n.to_owned()).into());
+            }
+        }
+        Ok(r)
+    }
+}
diff --git a/src/customize/rustproto_proto.rs b/src/customize/rustproto_proto.rs
new file mode 100644
index 0000000..3d9a77b
--- /dev/null
+++ b/src/customize/rustproto_proto.rs
@@ -0,0 +1,74 @@
+use protobuf::descriptor::EnumOptions;
+use protobuf::descriptor::FieldOptions;
+use protobuf::descriptor::FileOptions;
+use protobuf::descriptor::MessageOptions;
+use protobuf::rustproto;
+
+use crate::Customize;
+
+pub(crate) fn customize_from_rustproto_for_message(source: &MessageOptions) -> Customize {
+    let before = None;
+    let generate_accessors = rustproto::exts::generate_accessors.get(source);
+    let generate_getter = rustproto::exts::generate_getter.get(source);
+    let tokio_bytes = rustproto::exts::tokio_bytes.get(source);
+    let tokio_bytes_for_string = rustproto::exts::tokio_bytes_for_string.get(source);
+    let lite_runtime = None;
+    let gen_mod_rs = None;
+    let inside_protobuf = None;
+    Customize {
+        before,
+        generate_accessors,
+        generate_getter,
+        tokio_bytes,
+        tokio_bytes_for_string,
+        lite_runtime,
+        gen_mod_rs,
+        inside_protobuf,
+    }
+}
+
+pub(crate) fn customize_from_rustproto_for_enum(_source: &EnumOptions) -> Customize {
+    Customize::default()
+}
+
+pub(crate) fn customize_from_rustproto_for_field(source: &FieldOptions) -> Customize {
+    let before = None;
+    let generate_accessors = rustproto::exts::generate_accessors_field.get(source);
+    let generate_getter = rustproto::exts::generate_getter_field.get(source);
+    let tokio_bytes = rustproto::exts::tokio_bytes_field.get(source);
+    let tokio_bytes_for_string = rustproto::exts::tokio_bytes_for_string_field.get(source);
+    let lite_runtime = None;
+    let gen_mod_rs = None;
+    let inside_protobuf = None;
+    Customize {
+        before,
+        generate_accessors,
+        generate_getter,
+        tokio_bytes,
+        tokio_bytes_for_string,
+        lite_runtime,
+        gen_mod_rs,
+        inside_protobuf,
+    }
+}
+
+pub(crate) fn customize_from_rustproto_for_file(source: &FileOptions) -> Customize {
+    let before = None;
+    let generate_accessors = rustproto::exts::generate_accessors_all.get(source);
+    let generate_getter = rustproto::exts::generate_getter_all.get(source);
+    let tokio_bytes = rustproto::exts::tokio_bytes_all.get(source);
+    let tokio_bytes_for_string = rustproto::exts::tokio_bytes_for_string_all.get(source);
+    let lite_runtime = rustproto::exts::lite_runtime_all.get(source);
+    let gen_mod_rs = None;
+    let inside_protobuf = None;
+    Customize {
+        before,
+        generate_accessors,
+        generate_getter,
+        tokio_bytes,
+        tokio_bytes_for_string,
+        lite_runtime,
+        inside_protobuf,
+        gen_mod_rs,
+    }
+}
diff --git a/src/enums.rs b/src/enums.rs
deleted file mode 100644
index ec3444e..0000000
--- a/src/enums.rs
+++ /dev/null
@@ -1,377 +0,0 @@
-use std::collections::HashSet;
-
-use file_descriptor::file_descriptor_proto_expr;
-use inside::protobuf_crate_path;
-use protobuf::descriptor::*;
-use protobuf_name::ProtobufAbsolutePath;
-use rust_types_values::type_name_to_rust_relative;
-use scope::EnumWithScope;
-use scope::RootScope;
-use scope::WithScope;
-use serde;
-use CodeWriter;
-
-use crate::customize::customize_from_rustproto_for_enum;
-use crate::Customize;
-
-#[derive(Clone)]
-pub struct EnumValueGen {
-    proto: EnumValueDescriptorProto,
-    enum_rust_name: String,
-    variant_rust_name: String,
-}
-
-impl EnumValueGen {
-    fn parse(
-        proto: &EnumValueDescriptorProto,
-        enum_rust_name: &str,
-        variant_rust_name: &str,
-    ) -> EnumValueGen {
-        EnumValueGen {
-            proto: proto.clone(),
-            enum_rust_name: enum_rust_name.to_string(),
-            variant_rust_name: variant_rust_name.to_string(),
-        }
-    }
-
-    // enum value
-    fn number(&self) -> i32 {
-        self.proto.get_number()
-    }
-
-    // name of enum variant in generated rust code
-    fn rust_name_inner(&self) -> String {
-        self.variant_rust_name.clone()
-    }
-
-    pub fn rust_name_outer(&self) -> String {
-        let mut r = String::new();
-        r.push_str(&self.enum_rust_name);
-        r.push_str("::");
-        r.push_str(&self.rust_name_inner());
-        r
-    }
-}
-
-pub(crate) struct EnumGen<'a> {
-    enum_with_scope: &'a EnumWithScope<'a>,
-    type_name: String,
-    lite_runtime: bool,
-    customize: Customize,
-}
-
-impl<'a> EnumGen<'a> {
-    pub fn new(
-        enum_with_scope: &'a EnumWithScope<'a>,
-        current_file: &FileDescriptorProto,
-        customize: &Customize,
-        root_scope: &RootScope,
-    ) -> EnumGen<'a> {
-        let rust_name = if enum_with_scope.get_scope().get_file_descriptor().get_name()
-            == current_file.get_name()
-        {
-            // field type is a message or enum declared in the same file
-            enum_with_scope.rust_name().to_string()
-        } else {
-            type_name_to_rust_relative(
-                &ProtobufAbsolutePath::from(enum_with_scope.name_absolute()),
-                current_file,
-                false,
-                root_scope,
-                customize,
-            )
-            .to_string()
-        };
-        let lite_runtime = customize.lite_runtime.unwrap_or_else(|| {
-            enum_with_scope
-                .get_scope()
-                .get_file_descriptor()
-                .get_options()
-                .get_optimize_for()
-                == FileOptions_OptimizeMode::LITE_RUNTIME
-        });
-
-        let mut customize = customize.clone();
-        customize.update_with(&customize_from_rustproto_for_enum(
-            enum_with_scope.en.options.as_ref().unwrap_or_default(),
-        ));
-
-        EnumGen {
-            enum_with_scope,
-            type_name: rust_name,
-            lite_runtime,
-            customize,
-        }
-    }
-
-    fn allow_alias(&self) -> bool {
-        self.enum_with_scope.en.get_options().get_allow_alias()
-    }
-
-    fn values_all(&self) -> Vec<EnumValueGen> {
-        let mut r = Vec::new();
-        for p in self.enum_with_scope.values() {
-            r.push(EnumValueGen::parse(
-                &p.proto,
-                &self.type_name,
-                p.rust_name().get(),
-            ));
-        }
-        r
-    }
-
-    pub fn values_unique(&self) -> Vec<EnumValueGen> {
-        let mut used = HashSet::new();
-        let mut r = Vec::new();
-        for p in self.enum_with_scope.values() {
-            // skipping non-unique enums
-            // TODO: should support it
-            if !used.insert(p.proto.get_number()) {
-                continue;
-            }
-            r.push(EnumValueGen::parse(
-                p.proto,
-                &self.type_name,
-                p.rust_name().get(),
-            ));
-        }
-        r
-    }
-
-    // find enum value by name
-    pub fn value_by_name(&'a self, name: &str) -> EnumValueGen {
-        let v = self.enum_with_scope.value_by_name(name);
-        EnumValueGen::parse(v.proto, &self.type_name, v.rust_name().get())
-    }
-
-    pub fn write(&self, w: &mut CodeWriter) {
-        self.write_struct(w);
-        if self.allow_alias() {
-            w.write_line("");
-            self.write_impl_eq(w);
-            w.write_line("");
-            self.write_impl_hash(w);
-        }
-        w.write_line("");
-        self.write_impl_enum(w);
-        w.write_line("");
-        self.write_impl_copy(w);
-        w.write_line("");
-        self.write_impl_default(w);
-        w.write_line("");
-        self.write_impl_value(w);
-    }
-
-    fn write_struct(&self, w: &mut CodeWriter) {
-        let mut derive = Vec::new();
-        derive.push("Clone");
-        if !self.allow_alias() {
-            derive.push("PartialEq");
-        }
-        derive.push("Eq");
-        derive.push("Debug");
-        if !self.allow_alias() {
-            derive.push("Hash");
-        } else {
-            w.comment("Note: you cannot use pattern matching for enums with allow_alias option");
-        }
-        w.derive(&derive);
-        serde::write_serde_attr(
-            w,
-            &self.customize,
-            "derive(::serde::Serialize, ::serde::Deserialize)",
-        );
-        if let Some(ref ren) = self.customize.serde_rename_all {
-            let attr = format!("serde(rename_all = \"{}\")", ren);
-            serde::write_serde_attr(w, &self.customize, &attr);
-        }
-        let ref type_name = self.type_name;
-        w.expr_block(&format!("pub enum {}", type_name), |w| {
-            for value in self.values_all() {
-                if self.allow_alias() {
-                    w.write_line(&format!(
-                        "{}, // {}",
-                        value.rust_name_inner(),
-                        value.number()
-                    ));
-                } else {
-                    w.write_line(&format!(
-                        "{} = {},",
-                        value.rust_name_inner(),
-                        value.number()
-                    ));
-                }
-            }
-        });
-    }
-
-    fn write_fn_value(&self, w: &mut CodeWriter) {
-        w.def_fn("value(&self) -> i32", |w| {
-            if self.allow_alias() {
-                w.match_expr("*self", |w| {
-                    for value in self.values_all() {
-                        w.case_expr(value.rust_name_outer(), format!("{}", value.number()));
-                    }
-                });
-            } else {
-                w.write_line("*self as i32")
-            }
-        });
-    }
-
-    fn write_impl_enum(&self, w: &mut CodeWriter) {
-        let ref type_name = self.type_name;
-        w.impl_for_block(
-            &format!("{}::ProtobufEnum", protobuf_crate_path(&self.customize)),
-            &format!("{}", type_name),
-            |w| {
-                self.write_fn_value(w);
-
-                w.write_line("");
-                let ref type_name = self.type_name;
-                w.def_fn(
-                    &format!(
-                        "from_i32(value: i32) -> ::std::option::Option<{}>",
-                        type_name
-                    ),
-                    |w| {
-                        w.match_expr("value", |w| {
-                            let values = self.values_unique();
-                            for value in values {
-                                w.write_line(&format!(
-                                    "{} => ::std::option::Option::Some({}),",
-                                    value.number(),
-                                    value.rust_name_outer()
-                                ));
-                            }
-                            w.write_line(&format!("_ => ::std::option::Option::None"));
-                        });
-                    },
-                );
-
-                w.write_line("");
-                w.def_fn(&format!("values() -> &'static [Self]"), |w| {
-                    w.write_line(&format!("static values: &'static [{}] = &[", type_name));
-                    w.indented(|w| {
-                        for value in self.values_all() {
-                            w.write_line(&format!("{},", value.rust_name_outer()));
-                        }
-                    });
-                    w.write_line("];");
-                    w.write_line("values");
-                });
-
-                if !self.lite_runtime {
-                    w.write_line("");
-                    w.def_fn(
-                        &format!(
-                            "enum_descriptor_static() -> &'static {}::reflect::EnumDescriptor",
-                            protobuf_crate_path(&self.customize)
-                        ),
-                        |w| {
-                            w.lazy_static_decl_get(
-                                "descriptor",
-                                &format!(
-                                    "{}::reflect::EnumDescriptor",
-                                    protobuf_crate_path(&self.customize)
-                                ),
-                                &self.customize,
-                                |w| {
-                                    let ref type_name = self.type_name;
-                                    w.write_line(&format!(
-                                    "{}::reflect::EnumDescriptor::new_pb_name::<{}>(\"{}\", {})",
-                                    protobuf_crate_path(&self.customize),
-                                    type_name,
-                                    self.enum_with_scope.name_to_package(),
-                                    file_descriptor_proto_expr(&self.enum_with_scope.scope)
-                                ));
-                                },
-                            );
-                        },
-                    );
-                }
-            },
-        );
-    }
-
-    fn write_impl_value(&self, w: &mut CodeWriter) {
-        w.impl_for_block(
-            &format!(
-                "{}::reflect::ProtobufValue",
-                protobuf_crate_path(&self.customize)
-            ),
-            &format!("{}", self.type_name),
-            |w| {
-                w.def_fn(
-                    &format!(
-                        "as_ref(&self) -> {}::reflect::ReflectValueRef",
-                        protobuf_crate_path(&self.customize)
-                    ),
-                    |w| {
-                        w.write_line(&format!(
-                        "{}::reflect::ReflectValueRef::Enum({}::ProtobufEnum::descriptor(self))",
-                        protobuf_crate_path(&self.customize),
-                        protobuf_crate_path(&self.customize)
-                    ))
-                    },
-                )
-            },
-        )
-    }
-
-    fn write_impl_copy(&self, w: &mut CodeWriter) {
-        w.impl_for_block("::std::marker::Copy", &self.type_name, |_w| {});
-    }
-
-    fn write_impl_eq(&self, w: &mut CodeWriter) {
-        assert!(self.allow_alias());
-        w.impl_for_block(
-            "::std::cmp::PartialEq",
-            &format!("{}", self.type_name),
-            |w| {
-                w.def_fn("eq(&self, other: &Self) -> bool", |w| {
-                    w.write_line(&format!(
-                        "{}::ProtobufEnum::value(self) == {}::ProtobufEnum::value(other)",
-                        protobuf_crate_path(&self.customize),
-                        protobuf_crate_path(&self.customize)
-                    ));
-                });
-            },
-        );
-    }
-
-    fn write_impl_hash(&self, w: &mut CodeWriter) {
-        assert!(self.allow_alias());
-        w.impl_for_block("::std::hash::Hash", &format!("{}", self.type_name), |w| {
-            w.def_fn("hash<H : ::std::hash::Hasher>(&self, state: &mut H)", |w| {
-                w.write_line(&format!(
-                    "state.write_i32({}::ProtobufEnum::value(self))",
-                    protobuf_crate_path(&self.customize)
-                ));
-            });
-        });
-    }
-
-    fn write_impl_default(&self, w: &mut CodeWriter) {
-        let first_value = &self.enum_with_scope.values()[0];
-        if first_value.proto.get_number() != 0 {
-            // This warning is emitted only for proto2
-            // (because in proto3 first enum variant number is always 0).
-            // `Default` implemented unconditionally to simplify certain
-            // generic operations, e. g. reading a map.
-            // Also, note that even in proto2 some operations fallback to
-            // first enum value, e. g. `get_xxx` for unset field,
-            // so this implementation is not completely unreasonable.
-            w.comment("Note, `Default` is implemented although default value is not 0");
-        }
-        w.impl_for_block("::std::default::Default", &self.type_name, |w| {
-            w.def_fn("default() -> Self", |w| {
-                w.write_line(&format!(
-                    "{}::{}",
-                    &self.type_name,
-                    &first_value.rust_name()
-                ))
-            });
-        });
-    }
-}
diff --git a/src/extensions.rs b/src/extensions.rs
deleted file mode 100644
index def5948..0000000
--- a/src/extensions.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use field::rust_field_name_for_protobuf_field_name;
-use inside::protobuf_crate_path;
-use protobuf::descriptor::*;
-use protobuf_name::ProtobufAbsolutePath;
-use scope::RootScope;
-use Customize;
-
-use super::code_writer::CodeWriter;
-use super::rust_types_values::*;
-
-struct ExtGen<'a> {
-    file: &'a FileDescriptorProto,
-    root_scope: &'a RootScope<'a>,
-    field: &'a FieldDescriptorProto,
-    customize: Customize,
-}
-
-impl<'a> ExtGen<'a> {
-    fn extendee_rust_name(&self) -> String {
-        type_name_to_rust_relative(
-            &ProtobufAbsolutePath::from(self.field.get_extendee()),
-            self.file,
-            true,
-            self.root_scope,
-            &self.customize,
-        )
-    }
-
-    fn repeated(&self) -> bool {
-        match self.field.get_label() {
-            FieldDescriptorProto_Label::LABEL_REPEATED => true,
-            FieldDescriptorProto_Label::LABEL_OPTIONAL => false,
-            FieldDescriptorProto_Label::LABEL_REQUIRED => {
-                panic!("required ext field: {}", self.field.get_name())
-            }
-        }
-    }
-
-    fn return_type_gen(&self) -> ProtobufTypeGen {
-        if self.field.has_type_name() {
-            let rust_name_relative = type_name_to_rust_relative(
-                &ProtobufAbsolutePath::from(self.field.get_type_name()),
-                self.file,
-                true,
-                self.root_scope,
-                &self.customize,
-            );
-            match self.field.get_field_type() {
-                FieldDescriptorProto_Type::TYPE_MESSAGE => {
-                    ProtobufTypeGen::Message(rust_name_relative)
-                }
-                FieldDescriptorProto_Type::TYPE_ENUM => ProtobufTypeGen::Enum(rust_name_relative),
-                t => panic!("unknown type: {:?}", t),
-            }
-        } else {
-            ProtobufTypeGen::Primitive(self.field.get_field_type(), PrimitiveTypeVariant::Default)
-        }
-    }
-
-    fn write(&self, w: &mut CodeWriter) {
-        let suffix = if self.repeated() {
-            "Repeated"
-        } else {
-            "Optional"
-        };
-        let field_type = format!(
-            "{}::ext::ExtField{}",
-            protobuf_crate_path(&self.customize),
-            suffix
-        );
-        w.pub_const(
-            rust_field_name_for_protobuf_field_name(self.field.get_name()).get(),
-            &format!(
-                "{}<{}, {}>",
-                field_type,
-                self.extendee_rust_name(),
-                self.return_type_gen().rust_type(&self.customize),
-            ),
-            &format!(
-                "{} {{ field_number: {}, phantom: ::std::marker::PhantomData }}",
-                field_type,
-                self.field.get_number()
-            ),
-        );
-    }
-}
-
-pub(crate) fn write_extensions(
-    file: &FileDescriptorProto,
-    root_scope: &RootScope,
-    w: &mut CodeWriter,
-    customize: &Customize,
-) {
-    if file.get_extension().is_empty() {
-        return;
-    }
-
-    w.write_line("");
-    w.write_line("/// Extension fields");
-    w.pub_mod("exts", |w| {
-        for field in file.get_extension() {
-            if field.get_field_type() == FieldDescriptorProto_Type::TYPE_GROUP {
-                continue;
-            }
-
-            w.write_line("");
-            ExtGen {
-                file: file,
-                root_scope: root_scope,
-                field: field,
-                customize: customize.clone(),
-            }
-            .write(w);
-        }
-    });
-}
diff --git a/src/field/mod.rs b/src/field/mod.rs
deleted file mode 100644
index e4be944..0000000
--- a/src/field/mod.rs
+++ /dev/null
@@ -1,2031 +0,0 @@
-use std::marker;
-
-use float;
-use inside::protobuf_crate_path;
-use message::RustTypeMessage;
-use oneof::OneofField;
-use protobuf::descriptor::*;
-use protobuf::rt;
-use protobuf::rust;
-use protobuf::text_format;
-use protobuf::wire_format;
-use protobuf_name::ProtobufAbsolutePath;
-use rust_name::RustIdent;
-use rust_name::RustIdentWithPath;
-use scope::FieldWithContext;
-use scope::MessageOrEnumWithScope;
-use scope::RootScope;
-use scope::WithScope;
-use syntax::Syntax;
-
-use super::code_writer::CodeWriter;
-use super::customize::customize_from_rustproto_for_field;
-use super::customize::Customize;
-use super::enums::*;
-use super::rust_types_values::*;
-
-fn type_is_copy(field_type: FieldDescriptorProto_Type) -> bool {
-    match field_type {
-        FieldDescriptorProto_Type::TYPE_MESSAGE
-        | FieldDescriptorProto_Type::TYPE_STRING
-        | FieldDescriptorProto_Type::TYPE_BYTES => false,
-        _ => true,
-    }
-}
-
-trait FieldDescriptorProtoTypeExt {
-    fn read(&self, is: &str, primitive_type_variant: PrimitiveTypeVariant) -> String;
-    fn is_s_varint(&self) -> bool;
-}
-
-impl FieldDescriptorProtoTypeExt for FieldDescriptorProto_Type {
-    fn read(&self, is: &str, primitive_type_variant: PrimitiveTypeVariant) -> String {
-        match primitive_type_variant {
-            PrimitiveTypeVariant::Default => format!("{}.read_{}()", is, protobuf_name(*self)),
-            PrimitiveTypeVariant::Carllerche => {
-                let protobuf_name = match self {
-                    &FieldDescriptorProto_Type::TYPE_STRING => "chars",
-                    _ => protobuf_name(*self),
-                };
-                format!("{}.read_carllerche_{}()", is, protobuf_name)
-            }
-        }
-    }
-
-    /// True if self is signed integer with zigzag encoding
-    fn is_s_varint(&self) -> bool {
-        match *self {
-            FieldDescriptorProto_Type::TYPE_SINT32 | FieldDescriptorProto_Type::TYPE_SINT64 => true,
-            _ => false,
-        }
-    }
-}
-
-fn field_type_wire_type(field_type: FieldDescriptorProto_Type) -> wire_format::WireType {
-    use protobuf::wire_format::*;
-    match field_type {
-        FieldDescriptorProto_Type::TYPE_INT32 => WireTypeVarint,
-        FieldDescriptorProto_Type::TYPE_INT64 => WireTypeVarint,
-        FieldDescriptorProto_Type::TYPE_UINT32 => WireTypeVarint,
-        FieldDescriptorProto_Type::TYPE_UINT64 => WireTypeVarint,
-        FieldDescriptorProto_Type::TYPE_SINT32 => WireTypeVarint,
-        FieldDescriptorProto_Type::TYPE_SINT64 => WireTypeVarint,
-        FieldDescriptorProto_Type::TYPE_BOOL => WireTypeVarint,
-        FieldDescriptorProto_Type::TYPE_ENUM => WireTypeVarint,
-        FieldDescriptorProto_Type::TYPE_FIXED32 => WireTypeFixed32,
-        FieldDescriptorProto_Type::TYPE_FIXED64 => WireTypeFixed64,
-        FieldDescriptorProto_Type::TYPE_SFIXED32 => WireTypeFixed32,
-        FieldDescriptorProto_Type::TYPE_SFIXED64 => WireTypeFixed64,
-        FieldDescriptorProto_Type::TYPE_FLOAT => WireTypeFixed32,
-        FieldDescriptorProto_Type::TYPE_DOUBLE => WireTypeFixed64,
-        FieldDescriptorProto_Type::TYPE_STRING => WireTypeLengthDelimited,
-        FieldDescriptorProto_Type::TYPE_BYTES => WireTypeLengthDelimited,
-        FieldDescriptorProto_Type::TYPE_MESSAGE => WireTypeLengthDelimited,
-        FieldDescriptorProto_Type::TYPE_GROUP => WireTypeLengthDelimited, // not true
-    }
-}
-
-fn type_protobuf_name(field_type: FieldDescriptorProto_Type) -> &'static str {
-    match field_type {
-        FieldDescriptorProto_Type::TYPE_INT32 => "int32",
-        FieldDescriptorProto_Type::TYPE_INT64 => "int64",
-        FieldDescriptorProto_Type::TYPE_UINT32 => "uint32",
-        FieldDescriptorProto_Type::TYPE_UINT64 => "uint64",
-        FieldDescriptorProto_Type::TYPE_SINT32 => "sint32",
-        FieldDescriptorProto_Type::TYPE_SINT64 => "sint64",
-        FieldDescriptorProto_Type::TYPE_BOOL => "bool",
-        FieldDescriptorProto_Type::TYPE_FIXED32 => "fixed32",
-        FieldDescriptorProto_Type::TYPE_FIXED64 => "fixed64",
-        FieldDescriptorProto_Type::TYPE_SFIXED32 => "sfixed32",
-        FieldDescriptorProto_Type::TYPE_SFIXED64 => "sfixed64",
-        FieldDescriptorProto_Type::TYPE_FLOAT => "float",
-        FieldDescriptorProto_Type::TYPE_DOUBLE => "double",
-        FieldDescriptorProto_Type::TYPE_STRING => "string",
-        FieldDescriptorProto_Type::TYPE_BYTES => "bytes",
-        FieldDescriptorProto_Type::TYPE_ENUM
-        | FieldDescriptorProto_Type::TYPE_MESSAGE
-        | FieldDescriptorProto_Type::TYPE_GROUP => panic!(),
-    }
-}
-
-fn field_type_protobuf_name<'a>(field: &'a FieldDescriptorProto) -> &'a str {
-    if field.has_type_name() {
-        field.get_type_name()
-    } else {
-        type_protobuf_name(field.get_field_type())
-    }
-}
-
-// size of value for type, None if variable
-fn field_type_size(field_type: FieldDescriptorProto_Type) -> Option<u32> {
-    match field_type {
-        FieldDescriptorProto_Type::TYPE_BOOL => Some(1),
-        t if field_type_wire_type(t) == wire_format::WireTypeFixed32 => Some(4),
-        t if field_type_wire_type(t) == wire_format::WireTypeFixed64 => Some(8),
-        _ => None,
-    }
-}
-
-#[derive(Clone, PartialEq, Eq)]
-pub enum SingularFieldFlag {
-    // proto2 or proto3 message
-    WithFlag { required: bool },
-    // proto3
-    WithoutFlag,
-}
-
-impl SingularFieldFlag {
-    pub fn is_required(&self) -> bool {
-        match *self {
-            SingularFieldFlag::WithFlag { required, .. } => required,
-            SingularFieldFlag::WithoutFlag => false,
-        }
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct SingularField<'a> {
-    pub flag: SingularFieldFlag,
-    pub elem: FieldElem<'a>,
-}
-
-impl<'a> SingularField<'a> {
-    fn rust_storage_type(&self) -> RustType {
-        match self.flag {
-            SingularFieldFlag::WithFlag { .. } => match self.elem.proto_type() {
-                FieldDescriptorProto_Type::TYPE_MESSAGE => {
-                    RustType::SingularPtrField(Box::new(self.elem.rust_storage_type()))
-                }
-                FieldDescriptorProto_Type::TYPE_STRING | FieldDescriptorProto_Type::TYPE_BYTES
-                    if self.elem.primitive_type_variant() == PrimitiveTypeVariant::Default =>
-                {
-                    RustType::SingularField(Box::new(self.elem.rust_storage_type()))
-                }
-                _ => RustType::Option(Box::new(self.elem.rust_storage_type())),
-            },
-            SingularFieldFlag::WithoutFlag => self.elem.rust_storage_type(),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct RepeatedField<'a> {
-    pub elem: FieldElem<'a>,
-    pub packed: bool,
-}
-
-impl<'a> RepeatedField<'a> {
-    fn rust_type(&self) -> RustType {
-        if !self.elem.is_copy()
-            && self.elem.primitive_type_variant() != PrimitiveTypeVariant::Carllerche
-        {
-            RustType::RepeatedField(Box::new(self.elem.rust_storage_type()))
-        } else {
-            RustType::Vec(Box::new(self.elem.rust_storage_type()))
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct MapField<'a> {
-    _name: String,
-    key: FieldElem<'a>,
-    value: FieldElem<'a>,
-}
-
-#[derive(Clone)]
-pub(crate) enum FieldKind<'a> {
-    // optional or required
-    Singular(SingularField<'a>),
-    // repeated except map
-    Repeated(RepeatedField<'a>),
-    // map
-    Map(MapField<'a>),
-    // part of oneof
-    Oneof(OneofField<'a>),
-}
-
-impl<'a> FieldKind<'a> {
-    fn elem(&self) -> &FieldElem {
-        match self {
-            &FieldKind::Singular(ref s) => &s.elem,
-            &FieldKind::Repeated(ref r) => &r.elem,
-            &FieldKind::Oneof(ref o) => &o.elem,
-            &FieldKind::Map(..) => {
-                panic!("no single elem type for map field");
-            }
-        }
-    }
-
-    fn primitive_type_variant(&self) -> PrimitiveTypeVariant {
-        self.elem().primitive_type_variant()
-    }
-}
-
-// Representation of map entry: key type and value type
-#[derive(Clone, Debug)]
-pub struct EntryKeyValue<'a>(FieldElem<'a>, FieldElem<'a>);
-
-#[derive(Clone, Debug)]
-pub(crate) enum FieldElem<'a> {
-    Primitive(FieldDescriptorProto_Type, PrimitiveTypeVariant),
-    // name, file name, entry
-    Message(
-        String,
-        String,
-        Option<Box<EntryKeyValue<'a>>>,
-        marker::PhantomData<&'a ()>,
-    ),
-    // name, file name, default value
-    Enum(String, String, RustIdent),
-    Group,
-}
-
-impl<'a> FieldElem<'a> {
-    fn proto_type(&self) -> FieldDescriptorProto_Type {
-        match *self {
-            FieldElem::Primitive(t, ..) => t,
-            FieldElem::Group => FieldDescriptorProto_Type::TYPE_GROUP,
-            FieldElem::Message(..) => FieldDescriptorProto_Type::TYPE_MESSAGE,
-            FieldElem::Enum(..) => FieldDescriptorProto_Type::TYPE_ENUM,
-        }
-    }
-
-    fn is_copy(&self) -> bool {
-        type_is_copy(self.proto_type())
-    }
-
-    pub fn rust_storage_type(&self) -> RustType {
-        match *self {
-            FieldElem::Primitive(t, PrimitiveTypeVariant::Default) => rust_name(t),
-            FieldElem::Primitive(
-                FieldDescriptorProto_Type::TYPE_STRING,
-                PrimitiveTypeVariant::Carllerche,
-            ) => RustType::Chars,
-            FieldElem::Primitive(
-                FieldDescriptorProto_Type::TYPE_BYTES,
-                PrimitiveTypeVariant::Carllerche,
-            ) => RustType::Bytes,
-            FieldElem::Primitive(.., PrimitiveTypeVariant::Carllerche) => unreachable!(),
-            FieldElem::Group => RustType::Group,
-            FieldElem::Message(ref name, ..) => {
-                RustType::Message(RustTypeMessage(RustIdentWithPath::new(name.clone())))
-            }
-            FieldElem::Enum(ref name, _, ref default_value) => {
-                RustType::Enum(name.clone(), default_value.clone())
-            }
-        }
-    }
-
-    fn protobuf_type_gen(&self) -> ProtobufTypeGen {
-        match *self {
-            FieldElem::Primitive(t, v) => ProtobufTypeGen::Primitive(t, v),
-            FieldElem::Message(ref name, ..) => ProtobufTypeGen::Message(name.clone()),
-            FieldElem::Enum(ref name, ..) => ProtobufTypeGen::Enum(name.clone()),
-            FieldElem::Group => unreachable!(),
-        }
-    }
-
-    /// implementation of ProtobufType trait
-    fn lib_protobuf_type(&self, customize: &Customize) -> String {
-        self.protobuf_type_gen().rust_type(customize)
-    }
-
-    fn primitive_type_variant(&self) -> PrimitiveTypeVariant {
-        match self {
-            &FieldElem::Primitive(_, v) => v,
-            _ => PrimitiveTypeVariant::Default,
-        }
-    }
-}
-
-fn field_elem<'a>(
-    field: &FieldWithContext,
-    root_scope: &'a RootScope<'a>,
-    parse_map: bool,
-    customize: &Customize,
-) -> (FieldElem<'a>, Option<EnumValueGen>) {
-    if field.field.get_field_type() == FieldDescriptorProto_Type::TYPE_GROUP {
-        (FieldElem::Group, None)
-    } else if field.field.has_type_name() {
-        let message_or_enum = root_scope
-            .find_message_or_enum(&ProtobufAbsolutePath::from(field.field.get_type_name()));
-        let file_name = message_or_enum
-            .get_scope()
-            .file_scope
-            .file_descriptor
-            .get_name()
-            .to_owned();
-        let rust_relative_name = type_name_to_rust_relative(
-            &ProtobufAbsolutePath::from(field.field.get_type_name()),
-            field.message.get_scope().file_scope.file_descriptor,
-            false,
-            root_scope,
-            customize,
-        );
-        match (field.field.get_field_type(), message_or_enum) {
-            (
-                FieldDescriptorProto_Type::TYPE_MESSAGE,
-                MessageOrEnumWithScope::Message(message_with_scope),
-            ) => {
-                let entry_key_value = if let (true, Some((key, value))) =
-                    (parse_map, message_with_scope.map_entry())
-                {
-                    Some(Box::new(EntryKeyValue(
-                        field_elem(&key, root_scope, false, customize).0,
-                        field_elem(&value, root_scope, false, customize).0,
-                    )))
-                } else {
-                    None
-                };
-                (
-                    FieldElem::Message(
-                        rust_relative_name,
-                        file_name,
-                        entry_key_value,
-                        marker::PhantomData,
-                    ),
-                    None,
-                )
-            }
-            (
-                FieldDescriptorProto_Type::TYPE_ENUM,
-                MessageOrEnumWithScope::Enum(enum_with_scope),
-            ) => {
-                let e = EnumGen::new(
-                    &enum_with_scope,
-                    field.message.get_scope().get_file_descriptor(),
-                    customize,
-                    root_scope,
-                );
-                let ev = if field.field.has_default_value() {
-                    e.value_by_name(field.field.get_default_value()).clone()
-                } else {
-                    e.values_unique().into_iter().next().unwrap()
-                };
-                (
-                    FieldElem::Enum(
-                        rust_relative_name,
-                        file_name,
-                        RustIdent::from(enum_with_scope.values()[0].rust_name().to_owned()),
-                    ),
-                    Some(ev),
-                )
-            }
-            _ => panic!("unknown named type: {:?}", field.field.get_field_type()),
-        }
-    } else if field.field.has_field_type() {
-        let carllerche_for_bytes = customize.carllerche_bytes_for_bytes.unwrap_or(false);
-        let carllerche_for_string = customize.carllerche_bytes_for_string.unwrap_or(false);
-
-        let elem = match field.field.get_field_type() {
-            FieldDescriptorProto_Type::TYPE_STRING if carllerche_for_string => {
-                FieldElem::Primitive(
-                    FieldDescriptorProto_Type::TYPE_STRING,
-                    PrimitiveTypeVariant::Carllerche,
-                )
-            }
-            FieldDescriptorProto_Type::TYPE_BYTES if carllerche_for_bytes => FieldElem::Primitive(
-                FieldDescriptorProto_Type::TYPE_BYTES,
-                PrimitiveTypeVariant::Carllerche,
-            ),
-            t => FieldElem::Primitive(t, PrimitiveTypeVariant::Default),
-        };
-
-        (elem, None)
-    } else {
-        panic!(
-            "neither type_name, nor field_type specified for field: {}",
-            field.field.get_name()
-        );
-    }
-}
-
-pub enum AccessorStyle {
-    Lambda,
-    HasGet,
-}
-
-pub struct AccessorFn {
-    name: String,
-    type_params: Vec<String>,
-    pub style: AccessorStyle,
-}
-
-impl AccessorFn {
-    pub fn sig(&self) -> String {
-        let mut s = self.name.clone();
-        s.push_str("::<_");
-        for p in &self.type_params {
-            s.push_str(", ");
-            s.push_str(&p);
-        }
-        s.push_str(">");
-        s
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct FieldGen<'a> {
-    _root_scope: &'a RootScope<'a>,
-    syntax: Syntax,
-    pub proto_field: FieldWithContext<'a>,
-    // field name in generated code
-    pub rust_name: RustIdent,
-    pub proto_type: FieldDescriptorProto_Type,
-    wire_type: wire_format::WireType,
-    enum_default_value: Option<EnumValueGen>,
-    pub kind: FieldKind<'a>,
-    pub expose_field: bool,
-    pub generate_accessors: bool,
-    pub(crate) customize: Customize,
-}
-
-impl<'a> FieldGen<'a> {
-    pub fn parse(
-        field: FieldWithContext<'a>,
-        root_scope: &'a RootScope<'a>,
-        customize: &Customize,
-    ) -> FieldGen<'a> {
-        let mut customize = customize.clone();
-        customize.update_with(&customize_from_rustproto_for_field(
-            &field.field.get_options(),
-        ));
-
-        let (elem, enum_default_value) = field_elem(&field, root_scope, true, &customize);
-
-        let generate_accessors = customize.generate_accessors.unwrap_or(true);
-
-        let syntax = field.message.scope.file_scope.syntax();
-
-        let field_may_have_custom_default_value = syntax == Syntax::PROTO2
-            && field.field.get_label() != FieldDescriptorProto_Label::LABEL_REPEATED
-            && field.field.get_field_type() != FieldDescriptorProto_Type::TYPE_MESSAGE;
-
-        let default_expose_field = !field_may_have_custom_default_value;
-
-        let expose_field = customize.expose_fields.unwrap_or(default_expose_field);
-
-        let kind = if field.field.get_label() == FieldDescriptorProto_Label::LABEL_REPEATED {
-            match (elem, true) {
-                // map field
-                (FieldElem::Message(name, _, Some(key_value), _), true) => {
-                    FieldKind::Map(MapField {
-                        _name: name,
-                        key: key_value.0.clone(),
-                        value: key_value.1.clone(),
-                    })
-                }
-                // regular repeated field
-                (elem, _) => FieldKind::Repeated(RepeatedField {
-                    elem,
-                    packed: field.field.get_options().get_packed(),
-                }),
-            }
-        } else if let Some(oneof) = field.oneof() {
-            FieldKind::Oneof(OneofField::parse(&oneof, &field, elem, root_scope))
-        } else {
-            let flag = if field.message.scope.file_scope.syntax() == Syntax::PROTO3
-                && field.field.get_field_type() != FieldDescriptorProto_Type::TYPE_MESSAGE
-            {
-                SingularFieldFlag::WithoutFlag
-            } else {
-                SingularFieldFlag::WithFlag {
-                    required: field.field.get_label() == FieldDescriptorProto_Label::LABEL_REQUIRED,
-                }
-            };
-            FieldKind::Singular(SingularField { elem, flag })
-        };
-
-        FieldGen {
-            _root_scope: root_scope,
-            syntax: field.message.get_scope().file_scope.syntax(),
-            rust_name: field.rust_name(),
-            proto_type: field.field.get_field_type(),
-            wire_type: field_type_wire_type(field.field.get_field_type()),
-            enum_default_value,
-            proto_field: field.clone(),
-            kind,
-            expose_field,
-            generate_accessors,
-            customize,
-        }
-    }
-
-    fn tag_size(&self) -> u32 {
-        rt::tag_size(self.proto_field.number())
-    }
-
-    pub fn is_oneof(&self) -> bool {
-        match self.kind {
-            FieldKind::Oneof(..) => true,
-            _ => false,
-        }
-    }
-
-    pub fn oneof(&self) -> &OneofField {
-        match self.kind {
-            FieldKind::Oneof(ref oneof) => &oneof,
-            _ => panic!("not a oneof field: {}", self.reconstruct_def()),
-        }
-    }
-
-    fn is_singular(&self) -> bool {
-        match self.kind {
-            FieldKind::Singular(..) => true,
-            _ => false,
-        }
-    }
-
-    fn is_repeated_not_map(&self) -> bool {
-        match self.kind {
-            FieldKind::Repeated(..) => true,
-            _ => false,
-        }
-    }
-
-    fn is_repeated_or_map(&self) -> bool {
-        match self.kind {
-            FieldKind::Repeated(..) | FieldKind::Map(..) => true,
-            _ => false,
-        }
-    }
-
-    fn is_repeated_packed(&self) -> bool {
-        match self.kind {
-            FieldKind::Repeated(RepeatedField { packed: true, .. }) => true,
-            _ => false,
-        }
-    }
-
-    #[allow(dead_code)]
-    fn repeated(&self) -> &RepeatedField {
-        match self.kind {
-            FieldKind::Repeated(ref repeated) => &repeated,
-            _ => panic!("not a repeated field: {}", self.reconstruct_def()),
-        }
-    }
-
-    fn singular(&self) -> &SingularField {
-        match self.kind {
-            FieldKind::Singular(ref singular) => &singular,
-            _ => panic!("not a singular field: {}", self.reconstruct_def()),
-        }
-    }
-
-    fn map(&self) -> &MapField {
-        match self.kind {
-            FieldKind::Map(ref map) => &map,
-            _ => panic!("not a map field: {}", self.reconstruct_def()),
-        }
-    }
-
-    fn variant_path(&self) -> String {
-        // TODO: should reuse code from OneofVariantGen
-        format!(
-            "{}::{}",
-            self.oneof().oneof_type_name.to_code(&self.customize),
-            self.rust_name
-        )
-    }
-
-    // TODO: drop it
-    pub fn elem(&self) -> &FieldElem {
-        match self.kind {
-            FieldKind::Singular(SingularField { ref elem, .. }) => &elem,
-            FieldKind::Repeated(RepeatedField { ref elem, .. }) => &elem,
-            FieldKind::Oneof(OneofField { ref elem, .. }) => &elem,
-            FieldKind::Map(..) => unreachable!(),
-        }
-    }
-
-    // type of field in struct
-    pub fn full_storage_type(&self) -> RustType {
-        match self.kind {
-            FieldKind::Repeated(ref repeated) => repeated.rust_type(),
-            FieldKind::Map(MapField {
-                ref key, ref value, ..
-            }) => RustType::HashMap(
-                Box::new(key.rust_storage_type()),
-                Box::new(value.rust_storage_type()),
-            ),
-            FieldKind::Singular(ref singular) => singular.rust_storage_type(),
-            FieldKind::Oneof(..) => unreachable!(),
-        }
-    }
-
-    // type of `v` in `for v in field`
-    fn full_storage_iter_elem_type(&self) -> RustType {
-        if let FieldKind::Oneof(ref oneof) = self.kind {
-            oneof.elem.rust_storage_type()
-        } else {
-            self.full_storage_type().iter_elem_type()
-        }
-    }
-
-    // suffix `xxx` as in `os.write_xxx_no_tag(..)`
-    fn os_write_fn_suffix(&self) -> &str {
-        protobuf_name(self.proto_type)
-    }
-
-    // type of `v` in `os.write_xxx_no_tag(v)`
-    fn os_write_fn_param_type(&self) -> RustType {
-        match self.proto_type {
-            FieldDescriptorProto_Type::TYPE_STRING => RustType::Ref(Box::new(RustType::Str)),
-            FieldDescriptorProto_Type::TYPE_BYTES => {
-                RustType::Ref(Box::new(RustType::Slice(Box::new(RustType::Int(false, 8)))))
-            }
-            FieldDescriptorProto_Type::TYPE_ENUM => RustType::Int(true, 32),
-            t => rust_name(t),
-        }
-    }
-
-    // for field `foo`, type of param of `fn set_foo(..)`
-    fn set_xxx_param_type(&self) -> RustType {
-        match self.kind {
-            FieldKind::Singular(SingularField { ref elem, .. })
-            | FieldKind::Oneof(OneofField { ref elem, .. }) => elem.rust_storage_type(),
-            FieldKind::Repeated(..) | FieldKind::Map(..) => self.full_storage_type(),
-        }
-    }
-
-    // for field `foo`, return type if `fn take_foo(..)`
-    fn take_xxx_return_type(&self) -> RustType {
-        self.set_xxx_param_type()
-    }
-
-    // for field `foo`, return type of `fn mut_foo(..)`
-    fn mut_xxx_return_type(&self) -> RustType {
-        RustType::Ref(Box::new(match self.kind {
-            FieldKind::Singular(SingularField { ref elem, .. })
-            | FieldKind::Oneof(OneofField { ref elem, .. }) => elem.rust_storage_type(),
-            FieldKind::Repeated(..) | FieldKind::Map(..) => self.full_storage_type(),
-        }))
-    }
-
-    // for field `foo`, return type of `fn get_foo(..)`
-    fn get_xxx_return_type(&self) -> RustType {
-        match self.kind {
-            FieldKind::Singular(SingularField { ref elem, .. })
-            | FieldKind::Oneof(OneofField { ref elem, .. }) => match elem.is_copy() {
-                true => elem.rust_storage_type(),
-                false => elem.rust_storage_type().ref_type(),
-            },
-            FieldKind::Repeated(RepeatedField { ref elem, .. }) => RustType::Ref(Box::new(
-                RustType::Slice(Box::new(elem.rust_storage_type())),
-            )),
-            FieldKind::Map(..) => RustType::Ref(Box::new(self.full_storage_type())),
-        }
-    }
-
-    // fixed size type?
-    fn is_fixed(&self) -> bool {
-        field_type_size(self.proto_type).is_some()
-    }
-
-    // must use zigzag encoding?
-    fn is_zigzag(&self) -> bool {
-        match self.proto_type {
-            FieldDescriptorProto_Type::TYPE_SINT32 | FieldDescriptorProto_Type::TYPE_SINT64 => true,
-            _ => false,
-        }
-    }
-
-    // data is enum
-    fn is_enum(&self) -> bool {
-        match self.proto_type {
-            FieldDescriptorProto_Type::TYPE_ENUM => true,
-            _ => false,
-        }
-    }
-
-    // elem data is not stored in heap
-    pub fn elem_type_is_copy(&self) -> bool {
-        type_is_copy(self.proto_type)
-    }
-
-    fn defaut_value_from_proto_float(&self) -> String {
-        assert!(self.proto_field.field.has_default_value());
-
-        let type_name = match self.proto_type {
-            FieldDescriptorProto_Type::TYPE_FLOAT => "f32",
-            FieldDescriptorProto_Type::TYPE_DOUBLE => "f64",
-            _ => unreachable!(),
-        };
-        let proto_default = self.proto_field.field.get_default_value();
-
-        let f = float::parse_protobuf_float(proto_default)
-            .expect(&format!("failed to parse float: {:?}", proto_default));
-
-        if f.is_nan() {
-            format!("::std::{}::NAN", type_name)
-        } else if f.is_infinite() {
-            if f > 0.0 {
-                format!("::std::{}::INFINITY", type_name)
-            } else {
-                format!("::std::{}::NEG_INFINITY", type_name)
-            }
-        } else {
-            format!("{:?}{}", f, type_name)
-        }
-    }
-
-    fn default_value_from_proto(&self) -> Option<String> {
-        assert!(self.is_singular() || self.is_oneof());
-        if self.enum_default_value.is_some() {
-            Some(self.enum_default_value.as_ref().unwrap().rust_name_outer())
-        } else if self.proto_field.field.has_default_value() {
-            let proto_default = self.proto_field.field.get_default_value();
-            Some(match self.proto_type {
-                // For numeric types, contains the original text representation of the value
-                FieldDescriptorProto_Type::TYPE_DOUBLE | FieldDescriptorProto_Type::TYPE_FLOAT => {
-                    self.defaut_value_from_proto_float()
-                }
-                FieldDescriptorProto_Type::TYPE_INT32
-                | FieldDescriptorProto_Type::TYPE_SINT32
-                | FieldDescriptorProto_Type::TYPE_SFIXED32 => format!("{}i32", proto_default),
-                FieldDescriptorProto_Type::TYPE_UINT32
-                | FieldDescriptorProto_Type::TYPE_FIXED32 => format!("{}u32", proto_default),
-                FieldDescriptorProto_Type::TYPE_INT64
-                | FieldDescriptorProto_Type::TYPE_SINT64
-                | FieldDescriptorProto_Type::TYPE_SFIXED64 => format!("{}i64", proto_default),
-                FieldDescriptorProto_Type::TYPE_UINT64
-                | FieldDescriptorProto_Type::TYPE_FIXED64 => format!("{}u64", proto_default),
-
-                // For booleans, "true" or "false"
-                FieldDescriptorProto_Type::TYPE_BOOL => format!("{}", proto_default),
-                // For strings, contains the default text contents (not escaped in any way)
-                FieldDescriptorProto_Type::TYPE_STRING => rust::quote_escape_str(proto_default),
-                // For bytes, contains the C escaped value.  All bytes >= 128 are escaped
-                FieldDescriptorProto_Type::TYPE_BYTES => {
-                    rust::quote_escape_bytes(&text_format::unescape_string(proto_default))
-                }
-                // TODO: resolve outer message prefix
-                FieldDescriptorProto_Type::TYPE_GROUP | FieldDescriptorProto_Type::TYPE_ENUM => {
-                    unreachable!()
-                }
-                FieldDescriptorProto_Type::TYPE_MESSAGE => panic!(
-                    "default value is not implemented for type: {:?}",
-                    self.proto_type
-                ),
-            })
-        } else {
-            None
-        }
-    }
-
-    fn default_value_from_proto_typed(&self) -> Option<RustValueTyped> {
-        self.default_value_from_proto().map(|v| {
-            let default_value_type = match self.proto_type {
-                FieldDescriptorProto_Type::TYPE_STRING => RustType::Ref(Box::new(RustType::Str)),
-                FieldDescriptorProto_Type::TYPE_BYTES => {
-                    RustType::Ref(Box::new(RustType::Slice(Box::new(RustType::u8()))))
-                }
-                _ => self.full_storage_iter_elem_type(),
-            };
-
-            RustValueTyped {
-                value: v,
-                rust_type: default_value_type,
-            }
-        })
-    }
-
-    // default value to be returned from fn get_xxx
-    fn get_xxx_default_value_rust(&self) -> String {
-        assert!(self.is_singular() || self.is_oneof());
-        self.default_value_from_proto()
-            .unwrap_or_else(|| self.get_xxx_return_type().default_value(&self.customize))
-    }
-
-    // default to be assigned to field
-    fn element_default_value_rust(&self) -> RustValueTyped {
-        assert!(
-            self.is_singular() || self.is_oneof(),
-            "field is not singular: {}",
-            self.reconstruct_def()
-        );
-        self.default_value_from_proto_typed().unwrap_or_else(|| {
-            self.elem()
-                .rust_storage_type()
-                .default_value_typed(&self.customize)
-        })
-    }
-
-    pub fn reconstruct_def(&self) -> String {
-        let prefix = match (self.proto_field.field.get_label(), self.syntax) {
-            (FieldDescriptorProto_Label::LABEL_REPEATED, _) => "repeated ",
-            (_, Syntax::PROTO3) => "",
-            (FieldDescriptorProto_Label::LABEL_OPTIONAL, _) => "optional ",
-            (FieldDescriptorProto_Label::LABEL_REQUIRED, _) => "required ",
-        };
-        format!(
-            "{}{} {} = {}",
-            prefix,
-            field_type_protobuf_name(&self.proto_field.field),
-            self.proto_field.name(),
-            self.proto_field.number()
-        )
-    }
-
-    pub fn accessor_fn(&self) -> AccessorFn {
-        match self.kind {
-            FieldKind::Repeated(RepeatedField { ref elem, .. }) => {
-                let coll = match self.full_storage_type() {
-                    RustType::Vec(..) => "vec",
-                    RustType::RepeatedField(..) => "repeated_field",
-                    _ => unreachable!(),
-                };
-                let name = format!("make_{}_accessor", coll);
-                AccessorFn {
-                    name: name,
-                    type_params: vec![elem.lib_protobuf_type(&self.customize)],
-                    style: AccessorStyle::Lambda,
-                }
-            }
-            FieldKind::Map(MapField {
-                ref key, ref value, ..
-            }) => AccessorFn {
-                name: "make_map_accessor".to_owned(),
-                type_params: vec![
-                    key.lib_protobuf_type(&self.customize),
-                    value.lib_protobuf_type(&self.customize),
-                ],
-                style: AccessorStyle::Lambda,
-            },
-            FieldKind::Singular(SingularField {
-                ref elem,
-                flag: SingularFieldFlag::WithoutFlag,
-            }) => {
-                if let &FieldElem::Message(ref name, ..) = elem {
-                    // TODO: old style, needed because of default instance
-
-                    AccessorFn {
-                        name: "make_singular_message_accessor".to_owned(),
-                        type_params: vec![name.clone()],
-                        style: AccessorStyle::HasGet,
-                    }
-                } else {
-                    AccessorFn {
-                        name: "make_simple_field_accessor".to_owned(),
-                        type_params: vec![elem.lib_protobuf_type(&self.customize)],
-                        style: AccessorStyle::Lambda,
-                    }
-                }
-            }
-            FieldKind::Singular(SingularField {
-                ref elem,
-                flag: SingularFieldFlag::WithFlag { .. },
-            }) => {
-                let coll = match self.full_storage_type() {
-                    RustType::Option(..) => "option",
-                    RustType::SingularField(..) => "singular_field",
-                    RustType::SingularPtrField(..) => "singular_ptr_field",
-                    _ => unreachable!(),
-                };
-                let name = format!("make_{}_accessor", coll);
-                AccessorFn {
-                    name: name,
-                    type_params: vec![elem.lib_protobuf_type(&self.customize)],
-                    style: AccessorStyle::Lambda,
-                }
-            }
-            FieldKind::Oneof(OneofField { ref elem, .. }) => {
-                // TODO: uses old style
-
-                let suffix = match &self.elem().rust_storage_type() {
-                    t if t.is_primitive() => t.to_code(&self.customize),
-                    &RustType::String | &RustType::Chars => "string".to_string(),
-                    &RustType::Vec(ref t) if t.is_u8() => "bytes".to_string(),
-                    &RustType::Bytes => "bytes".to_string(),
-                    &RustType::Enum(..) => "enum".to_string(),
-                    &RustType::Message(..) => "message".to_string(),
-                    t => panic!("unexpected field type: {:?}", t),
-                };
-
-                let name = format!("make_singular_{}_accessor", suffix);
-
-                let mut type_params = Vec::new();
-                match elem {
-                    &FieldElem::Message(ref name, ..) | &FieldElem::Enum(ref name, ..) => {
-                        type_params.push(name.to_owned());
-                    }
-                    _ => (),
-                }
-
-                AccessorFn {
-                    name: name,
-                    type_params: type_params,
-                    style: AccessorStyle::HasGet,
-                }
-            }
-        }
-    }
-
-    pub fn write_clear(&self, w: &mut CodeWriter) {
-        if self.is_oneof() {
-            w.write_line(&format!(
-                "self.{} = ::std::option::Option::None;",
-                self.oneof().oneof_rust_field_name
-            ));
-        } else {
-            let clear_expr = self
-                .full_storage_type()
-                .clear(&self.self_field(), &self.customize);
-            w.write_line(&format!("{};", clear_expr));
-        }
-    }
-
-    // expression that returns size of data is variable
-    fn element_size(&self, var: &str, var_type: &RustType) -> String {
-        assert!(!self.is_repeated_packed());
-
-        match field_type_size(self.proto_type) {
-            Some(data_size) => format!("{}", data_size + self.tag_size()),
-            None => match self.proto_type {
-                FieldDescriptorProto_Type::TYPE_MESSAGE => panic!("not a single-liner"),
-                FieldDescriptorProto_Type::TYPE_BYTES => format!(
-                    "{}::rt::bytes_size({}, &{})",
-                    protobuf_crate_path(&self.customize),
-                    self.proto_field.number(),
-                    var
-                ),
-                FieldDescriptorProto_Type::TYPE_STRING => format!(
-                    "{}::rt::string_size({}, &{})",
-                    protobuf_crate_path(&self.customize),
-                    self.proto_field.number(),
-                    var
-                ),
-                FieldDescriptorProto_Type::TYPE_ENUM => {
-                    let param_type = match var_type {
-                        &RustType::Ref(ref t) => (**t).clone(),
-                        t => t.clone(),
-                    };
-                    format!(
-                        "{}::rt::enum_size({}, {})",
-                        protobuf_crate_path(&self.customize),
-                        self.proto_field.number(),
-                        var_type.into_target(&param_type, var, &self.customize)
-                    )
-                }
-                _ => {
-                    let param_type = match var_type {
-                        &RustType::Ref(ref t) => (**t).clone(),
-                        t => t.clone(),
-                    };
-                    if self.proto_type.is_s_varint() {
-                        format!(
-                            "{}::rt::value_varint_zigzag_size({}, {})",
-                            protobuf_crate_path(&self.customize),
-                            self.proto_field.number(),
-                            var_type.into_target(&param_type, var, &self.customize)
-                        )
-                    } else {
-                        format!(
-                            "{}::rt::value_size({}, {}, {}::wire_format::{:?})",
-                            protobuf_crate_path(&self.customize),
-                            self.proto_field.number(),
-                            var_type.into_target(&param_type, var, &self.customize),
-                            protobuf_crate_path(&self.customize),
-                            self.wire_type,
-                        )
-                    }
-                }
-            },
-        }
-    }
-
-    // output code that writes single element to stream
-    pub fn write_write_element(&self, w: &mut CodeWriter, os: &str, var: &str, ty: &RustType) {
-        if let FieldKind::Repeated(RepeatedField { packed: true, .. }) = self.kind {
-            unreachable!();
-        };
-
-        match self.proto_type {
-            FieldDescriptorProto_Type::TYPE_MESSAGE => {
-                w.write_line(&format!(
-                    "{}.write_tag({}, {}::wire_format::{:?})?;",
-                    os,
-                    self.proto_field.number(),
-                    protobuf_crate_path(&self.customize),
-                    wire_format::WireTypeLengthDelimited
-                ));
-                w.write_line(&format!(
-                    "{}.write_raw_varint32({}.get_cached_size())?;",
-                    os, var
-                ));
-                w.write_line(&format!("{}.write_to_with_cached_sizes({})?;", var, os));
-            }
-            _ => {
-                let param_type = self.os_write_fn_param_type();
-                let os_write_fn_suffix = self.os_write_fn_suffix();
-                let number = self.proto_field.number();
-                w.write_line(&format!(
-                    "{}.write_{}({}, {})?;",
-                    os,
-                    os_write_fn_suffix,
-                    number,
-                    ty.into_target(&param_type, var, &self.customize)
-                ));
-            }
-        }
-    }
-
-    fn self_field(&self) -> String {
-        format!("self.{}", self.rust_name)
-    }
-
-    fn self_field_is_some(&self) -> String {
-        assert!(self.is_singular());
-        format!("{}.is_some()", self.self_field())
-    }
-
-    fn self_field_is_not_empty(&self) -> String {
-        assert!(self.is_repeated_or_map());
-        format!("!{}.is_empty()", self.self_field())
-    }
-
-    fn self_field_is_none(&self) -> String {
-        assert!(self.is_singular());
-        format!("{}.is_none()", self.self_field())
-    }
-
-    // type of expression returned by `as_option()`
-    fn as_option_type(&self) -> RustType {
-        assert!(self.is_singular());
-        match self.full_storage_type() {
-            RustType::Option(ref e) if e.is_copy() => RustType::Option(e.clone()),
-            RustType::Option(e) => RustType::Option(Box::new(e.ref_type())),
-            RustType::SingularField(ty) | RustType::SingularPtrField(ty) => {
-                RustType::Option(Box::new(RustType::Ref(ty)))
-            }
-            x => panic!("cannot convert {:?} to option", x),
-        }
-    }
-
-    // field data viewed as Option
-    fn self_field_as_option(&self) -> RustValueTyped {
-        assert!(self.is_singular());
-
-        let suffix = match self.full_storage_type() {
-            RustType::Option(ref e) if e.is_copy() => "",
-            _ => ".as_ref()",
-        };
-
-        self.as_option_type()
-            .value(format!("{}{}", self.self_field(), suffix))
-    }
-
-    fn write_if_let_self_field_is_some<F>(&self, w: &mut CodeWriter, cb: F)
-    where
-        F: Fn(&str, &RustType, &mut CodeWriter),
-    {
-        match self.kind {
-            FieldKind::Repeated(..) | FieldKind::Map(..) => panic!("field is not singular"),
-            FieldKind::Singular(SingularField {
-                flag: SingularFieldFlag::WithFlag { .. },
-                ref elem,
-            }) => {
-                let var = "v";
-                let ref_prefix = match elem.rust_storage_type().is_copy() {
-                    true => "",
-                    false => "ref ",
-                };
-                let as_option = self.self_field_as_option();
-                w.if_let_stmt(
-                    &format!("Some({}{})", ref_prefix, var),
-                    &as_option.value,
-                    |w| {
-                        let v_type = as_option.rust_type.elem_type();
-                        cb(var, &v_type, w);
-                    },
-                );
-            }
-            FieldKind::Singular(SingularField {
-                flag: SingularFieldFlag::WithoutFlag,
-                ref elem,
-            }) => match *elem {
-                FieldElem::Primitive(FieldDescriptorProto_Type::TYPE_STRING, ..)
-                | FieldElem::Primitive(FieldDescriptorProto_Type::TYPE_BYTES, ..) => {
-                    w.if_stmt(format!("!{}.is_empty()", self.self_field()), |w| {
-                        cb(&self.self_field(), &self.full_storage_type(), w);
-                    });
-                }
-                _ => {
-                    w.if_stmt(
-                        format!(
-                            "{} != {}",
-                            self.self_field(),
-                            self.full_storage_type().default_value(&self.customize)
-                        ),
-                        |w| {
-                            cb(&self.self_field(), &self.full_storage_type(), w);
-                        },
-                    );
-                }
-            },
-            FieldKind::Oneof(..) => unreachable!(),
-        }
-    }
-
-    fn write_if_self_field_is_not_empty<F>(&self, w: &mut CodeWriter, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        assert!(self.is_repeated_or_map());
-        let self_field_is_not_empty = self.self_field_is_not_empty();
-        w.if_stmt(self_field_is_not_empty, cb);
-    }
-
-    pub fn write_if_self_field_is_none<F>(&self, w: &mut CodeWriter, cb: F)
-    where
-        F: Fn(&mut CodeWriter),
-    {
-        let self_field_is_none = self.self_field_is_none();
-        w.if_stmt(self_field_is_none, cb)
-    }
-
-    // repeated or singular
-    pub fn write_for_self_field<F>(&self, w: &mut CodeWriter, varn: &str, cb: F)
-    where
-        F: Fn(&mut CodeWriter, &RustType),
-    {
-        match self.kind {
-            FieldKind::Oneof(OneofField {
-                ref elem,
-                ref oneof_type_name,
-                ..
-            }) => {
-                let cond = format!(
-                    "Some({}::{}(ref {}))",
-                    oneof_type_name.to_code(&self.customize),
-                    self.rust_name,
-                    varn
-                );
-                w.if_let_stmt(&cond, &self.self_field_oneof(), |w| {
-                    cb(w, &elem.rust_storage_type())
-                })
-            }
-            _ => {
-                let v_type = self.full_storage_iter_elem_type();
-                let self_field = self.self_field();
-                w.for_stmt(&format!("&{}", self_field), varn, |w| cb(w, &v_type));
-            }
-        }
-    }
-
-    fn write_self_field_assign(&self, w: &mut CodeWriter, value: &str) {
-        let self_field = self.self_field();
-        w.write_line(&format!("{} = {};", self_field, value));
-    }
-
-    fn write_self_field_assign_some(&self, w: &mut CodeWriter, value: &str) {
-        let full_storage_type = self.full_storage_type();
-        match self.singular() {
-            &SingularField {
-                flag: SingularFieldFlag::WithFlag { .. },
-                ..
-            } => {
-                self.write_self_field_assign(
-                    w,
-                    &full_storage_type.wrap_value(value, &self.customize),
-                );
-            }
-            &SingularField {
-                flag: SingularFieldFlag::WithoutFlag,
-                ..
-            } => {
-                self.write_self_field_assign(w, value);
-            }
-        }
-    }
-
-    fn write_self_field_assign_value(&self, w: &mut CodeWriter, value: &str, ty: &RustType) {
-        match self.kind {
-            FieldKind::Repeated(..) | FieldKind::Map(..) => {
-                let converted = ty.into_target(&self.full_storage_type(), value, &self.customize);
-                self.write_self_field_assign(w, &converted);
-            }
-            FieldKind::Singular(SingularField { ref elem, ref flag }) => {
-                let converted = ty.into_target(&elem.rust_storage_type(), value, &self.customize);
-                let wrapped = if *flag == SingularFieldFlag::WithoutFlag {
-                    converted
-                } else {
-                    self.full_storage_type()
-                        .wrap_value(&converted, &self.customize)
-                };
-                self.write_self_field_assign(w, &wrapped);
-            }
-            FieldKind::Oneof(..) => unreachable!(),
-        }
-    }
-
-    fn write_self_field_assign_default(&self, w: &mut CodeWriter) {
-        assert!(self.is_singular());
-        if self.is_oneof() {
-            let self_field_oneof = self.self_field_oneof();
-            w.write_line(format!(
-                "{} = ::std::option::Option::Some({}({}))",
-                self_field_oneof,
-                self.variant_path(),
-                // TODO: default from .proto is not needed here (?)
-                self.element_default_value_rust()
-                    .into_type(self.full_storage_iter_elem_type(), &self.customize)
-                    .value
-            ));
-        } else {
-            // Note it is different from C++ protobuf, where field is initialized
-            // with default value
-            match self.full_storage_type() {
-                RustType::SingularField(..) | RustType::SingularPtrField(..) => {
-                    let self_field = self.self_field();
-                    w.write_line(&format!("{}.set_default();", self_field));
-                }
-                _ => {
-                    self.write_self_field_assign_some(
-                        w,
-                        &self
-                            .elem()
-                            .rust_storage_type()
-                            .default_value_typed(&self.customize)
-                            .into_type(self.elem().rust_storage_type(), &self.customize)
-                            .value,
-                    );
-                }
-            }
-        }
-    }
-
-    fn self_field_vec_packed_fixed_data_size(&self) -> String {
-        assert!(self.is_fixed());
-        format!(
-            "({}.len() * {}) as u32",
-            self.self_field(),
-            field_type_size(self.proto_type).unwrap()
-        )
-    }
-
-    fn self_field_vec_packed_varint_data_size(&self) -> String {
-        assert!(!self.is_fixed());
-        let fn_name = if self.is_enum() {
-            "vec_packed_enum_data_size".to_string()
-        } else {
-            let zigzag_suffix = if self.is_zigzag() { "_zigzag" } else { "" };
-            format!("vec_packed_varint{}_data_size", zigzag_suffix)
-        };
-        format!(
-            "{}::rt::{}(&{})",
-            protobuf_crate_path(&self.customize),
-            fn_name,
-            self.self_field()
-        )
-    }
-
-    fn self_field_vec_packed_data_size(&self) -> String {
-        assert!(self.is_repeated_not_map());
-        if self.is_fixed() {
-            self.self_field_vec_packed_fixed_data_size()
-        } else {
-            self.self_field_vec_packed_varint_data_size()
-        }
-    }
-
-    fn self_field_vec_packed_fixed_size(&self) -> String {
-        // zero is filtered outside
-        format!(
-            "{} + {}::rt::compute_raw_varint32_size({}) + {}",
-            self.tag_size(),
-            protobuf_crate_path(&self.customize),
-            self.self_field_vec_packed_fixed_data_size(),
-            self.self_field_vec_packed_fixed_data_size()
-        )
-    }
-
-    fn self_field_vec_packed_varint_size(&self) -> String {
-        // zero is filtered outside
-        assert!(!self.is_fixed());
-        let fn_name = if self.is_enum() {
-            "vec_packed_enum_size".to_string()
-        } else {
-            let zigzag_suffix = if self.is_zigzag() { "_zigzag" } else { "" };
-            format!("vec_packed_varint{}_size", zigzag_suffix)
-        };
-        format!(
-            "{}::rt::{}({}, &{})",
-            protobuf_crate_path(&self.customize),
-            fn_name,
-            self.proto_field.number(),
-            self.self_field()
-        )
-    }
-
-    fn self_field_oneof(&self) -> String {
-        format!("self.{}", self.oneof().oneof_rust_field_name)
-    }
-
-    pub fn clear_field_func(&self) -> String {
-        format!("clear_{}", self.rust_name)
-    }
-
-    // Write `merge_from` part for this singular or repeated field
-    // of type message, string or bytes
-    fn write_merge_from_field_message_string_bytes(&self, w: &mut CodeWriter) {
-        let singular_or_repeated = match self.kind {
-            FieldKind::Repeated(..) => "repeated",
-            FieldKind::Singular(SingularField {
-                flag: SingularFieldFlag::WithFlag { .. },
-                ..
-            }) => "singular",
-            FieldKind::Singular(SingularField {
-                flag: SingularFieldFlag::WithoutFlag,
-                ..
-            }) => "singular_proto3",
-            FieldKind::Map(..) | FieldKind::Oneof(..) => unreachable!(),
-        };
-        let carllerche = match self.kind.primitive_type_variant() {
-            PrimitiveTypeVariant::Carllerche => "carllerche_",
-            PrimitiveTypeVariant::Default => "",
-        };
-        let type_name_for_fn = protobuf_name(self.proto_type);
-        w.write_line(&format!(
-            "{}::rt::read_{}_{}{}_into(wire_type, is, &mut self.{})?;",
-            protobuf_crate_path(&self.customize),
-            singular_or_repeated,
-            carllerche,
-            type_name_for_fn,
-            self.rust_name
-        ));
-    }
-
-    fn write_error_unexpected_wire_type(&self, wire_type_var: &str, w: &mut CodeWriter) {
-        w.write_line(&format!(
-            "return ::std::result::Result::Err({}::rt::unexpected_wire_type({}));",
-            protobuf_crate_path(&self.customize),
-            wire_type_var
-        ));
-    }
-
-    fn write_assert_wire_type(&self, wire_type_var: &str, w: &mut CodeWriter) {
-        w.if_stmt(
-            &format!(
-                "{} != {}::wire_format::{:?}",
-                wire_type_var,
-                protobuf_crate_path(&self.customize),
-                self.wire_type
-            ),
-            |w| {
-                self.write_error_unexpected_wire_type(wire_type_var, w);
-            },
-        );
-    }
-
-    // Write `merge_from` part for this oneof field
-    fn write_merge_from_oneof(&self, f: &OneofField, wire_type_var: &str, w: &mut CodeWriter) {
-        self.write_assert_wire_type(wire_type_var, w);
-
-        let typed = RustValueTyped {
-            value: format!(
-                "{}?",
-                self.proto_type.read("is", f.elem.primitive_type_variant())
-            ),
-            rust_type: self.full_storage_iter_elem_type(),
-        };
-
-        let maybe_boxed = if f.boxed {
-            typed.boxed(&self.customize)
-        } else {
-            typed
-        };
-
-        w.write_line(&format!(
-            "self.{} = ::std::option::Option::Some({}({}));",
-            self.oneof().oneof_rust_field_name,
-            self.variant_path(),
-            maybe_boxed.value
-        )); // TODO: into_type
-    }
-
-    // Write `merge_from` part for this map field
-    fn write_merge_from_map(&self, w: &mut CodeWriter) {
-        let &MapField {
-            ref key, ref value, ..
-        } = self.map();
-        w.write_line(&format!(
-            "{}::rt::read_map_into::<{}, {}>(wire_type, is, &mut {})?;",
-            protobuf_crate_path(&self.customize),
-            key.lib_protobuf_type(&self.customize),
-            value.lib_protobuf_type(&self.customize),
-            self.self_field()
-        ));
-    }
-
-    // Write `merge_from` part for this singular field
-    fn write_merge_from_singular(&self, wire_type_var: &str, w: &mut CodeWriter) {
-        let field = match self.kind {
-            FieldKind::Singular(ref field) => field,
-            _ => panic!(),
-        };
-
-        match field.elem {
-            FieldElem::Message(..)
-            | FieldElem::Primitive(FieldDescriptorProto_Type::TYPE_STRING, ..)
-            | FieldElem::Primitive(FieldDescriptorProto_Type::TYPE_BYTES, ..) => {
-                self.write_merge_from_field_message_string_bytes(w);
-            }
-            FieldElem::Enum(..) => {
-                let version = match field.flag {
-                    SingularFieldFlag::WithFlag { .. } => "proto2",
-                    SingularFieldFlag::WithoutFlag => "proto3",
-                };
-                w.write_line(&format!(
-                    "{}::rt::read_{}_enum_with_unknown_fields_into({}, is, &mut self.{}, {}, &mut self.unknown_fields)?",
-                    protobuf_crate_path(&self.customize),
-                    version,
-                    wire_type_var,
-                    self.rust_name,
-                    self.proto_field.number()
-                ));
-            }
-            _ => {
-                let read_proc = format!(
-                    "{}?",
-                    self.proto_type.read("is", PrimitiveTypeVariant::Default)
-                );
-
-                self.write_assert_wire_type(wire_type_var, w);
-                w.write_line(&format!("let tmp = {};", read_proc));
-                self.write_self_field_assign_some(w, "tmp");
-            }
-        }
-    }
-
-    // Write `merge_from` part for this repeated field
-    fn write_merge_from_repeated(&self, wire_type_var: &str, w: &mut CodeWriter) {
-        let field = match self.kind {
-            FieldKind::Repeated(ref field) => field,
-            _ => panic!(),
-        };
-
-        match field.elem {
-            FieldElem::Message(..)
-            | FieldElem::Primitive(FieldDescriptorProto_Type::TYPE_STRING, ..)
-            | FieldElem::Primitive(FieldDescriptorProto_Type::TYPE_BYTES, ..) => {
-                self.write_merge_from_field_message_string_bytes(w);
-            }
-            FieldElem::Enum(..) => {
-                w.write_line(&format!(
-                    "{}::rt::read_repeated_enum_with_unknown_fields_into({}, is, &mut self.{}, {}, &mut self.unknown_fields)?",
-                    protobuf_crate_path(&self.customize),
-                    wire_type_var,
-                    self.rust_name,
-                    self.proto_field.number()
-                ));
-            }
-            _ => {
-                w.write_line(&format!(
-                    "{}::rt::read_repeated_{}_into({}, is, &mut self.{})?;",
-                    protobuf_crate_path(&self.customize),
-                    protobuf_name(self.proto_type),
-                    wire_type_var,
-                    self.rust_name
-                ));
-            }
-        }
-    }
-
-    // Write `merge_from` part for this field
-    pub fn write_merge_from_field(&self, wire_type_var: &str, w: &mut CodeWriter) {
-        match self.kind {
-            FieldKind::Oneof(ref f) => self.write_merge_from_oneof(&f, wire_type_var, w),
-            FieldKind::Map(..) => self.write_merge_from_map(w),
-            FieldKind::Singular(..) => self.write_merge_from_singular(wire_type_var, w),
-            FieldKind::Repeated(..) => self.write_merge_from_repeated(wire_type_var, w),
-        }
-    }
-
-    fn self_field_vec_packed_size(&self) -> String {
-        match self.kind {
-            FieldKind::Repeated(RepeatedField { packed: true, .. }) => {
-                // zero is filtered outside
-                if self.is_fixed() {
-                    self.self_field_vec_packed_fixed_size()
-                } else {
-                    self.self_field_vec_packed_varint_size()
-                }
-            }
-            _ => {
-                panic!("not packed");
-            }
-        }
-    }
-
-    pub fn write_element_size(
-        &self,
-        w: &mut CodeWriter,
-        item_var: &str,
-        item_var_type: &RustType,
-        sum_var: &str,
-    ) {
-        assert!(!self.is_repeated_packed());
-
-        match self.proto_type {
-            FieldDescriptorProto_Type::TYPE_MESSAGE => {
-                w.write_line(&format!("let len = {}.compute_size();", item_var));
-                let tag_size = self.tag_size();
-                w.write_line(&format!(
-                    "{} += {} + {}::rt::compute_raw_varint32_size(len) + len;",
-                    sum_var,
-                    tag_size,
-                    protobuf_crate_path(&self.customize)
-                ));
-            }
-            _ => {
-                w.write_line(&format!(
-                    "{} += {};",
-                    sum_var,
-                    self.element_size(item_var, item_var_type)
-                ));
-            }
-        }
-    }
-
-    pub fn write_message_write_field(&self, w: &mut CodeWriter) {
-        match self.kind {
-            FieldKind::Singular(..) => {
-                self.write_if_let_self_field_is_some(w, |v, v_type, w| {
-                    self.write_write_element(w, "os", v, v_type);
-                });
-            }
-            FieldKind::Repeated(RepeatedField { packed: false, .. }) => {
-                self.write_for_self_field(w, "v", |w, v_type| {
-                    self.write_write_element(w, "os", "v", v_type);
-                });
-            }
-            FieldKind::Repeated(RepeatedField { packed: true, .. }) => {
-                self.write_if_self_field_is_not_empty(w, |w| {
-                    let number = self.proto_field.number();
-                    w.write_line(&format!(
-                        "os.write_tag({}, {}::wire_format::{:?})?;",
-                        number,
-                        protobuf_crate_path(&self.customize),
-                        wire_format::WireTypeLengthDelimited
-                    ));
-                    w.comment("TODO: Data size is computed again, it should be cached");
-                    let data_size_expr = self.self_field_vec_packed_data_size();
-                    w.write_line(&format!("os.write_raw_varint32({})?;", data_size_expr));
-                    self.write_for_self_field(w, "v", |w, v_type| {
-                        let param_type = self.os_write_fn_param_type();
-                        let os_write_fn_suffix = self.os_write_fn_suffix();
-                        w.write_line(&format!(
-                            "os.write_{}_no_tag({})?;",
-                            os_write_fn_suffix,
-                            v_type.into_target(&param_type, "v", &self.customize)
-                        ));
-                    });
-                });
-            }
-            FieldKind::Map(MapField {
-                ref key, ref value, ..
-            }) => {
-                w.write_line(&format!(
-                    "{}::rt::write_map_with_cached_sizes::<{}, {}>({}, &{}, os)?;",
-                    protobuf_crate_path(&self.customize),
-                    key.lib_protobuf_type(&self.customize),
-                    value.lib_protobuf_type(&self.customize),
-                    self.proto_field.number(),
-                    self.self_field()
-                ));
-            }
-            FieldKind::Oneof(..) => unreachable!(),
-        };
-    }
-
-    pub fn write_message_compute_field_size(&self, sum_var: &str, w: &mut CodeWriter) {
-        match self.kind {
-            FieldKind::Singular(..) => {
-                self.write_if_let_self_field_is_some(w, |v, v_type, w| {
-                    match field_type_size(self.proto_type) {
-                        Some(s) => {
-                            let tag_size = self.tag_size();
-                            w.write_line(&format!("{} += {};", sum_var, (s + tag_size) as isize));
-                        }
-                        None => {
-                            self.write_element_size(w, v, v_type, sum_var);
-                        }
-                    };
-                });
-            }
-            FieldKind::Repeated(RepeatedField { packed: false, .. }) => {
-                match field_type_size(self.proto_type) {
-                    Some(s) => {
-                        let tag_size = self.tag_size();
-                        let self_field = self.self_field();
-                        w.write_line(&format!(
-                            "{} += {} * {}.len() as u32;",
-                            sum_var,
-                            (s + tag_size) as isize,
-                            self_field
-                        ));
-                    }
-                    None => {
-                        self.write_for_self_field(w, "value", |w, value_type| {
-                            self.write_element_size(w, "value", value_type, sum_var);
-                        });
-                    }
-                };
-            }
-            FieldKind::Map(MapField {
-                ref key, ref value, ..
-            }) => {
-                w.write_line(&format!(
-                    "{} += {}::rt::compute_map_size::<{}, {}>({}, &{});",
-                    sum_var,
-                    protobuf_crate_path(&self.customize),
-                    key.lib_protobuf_type(&self.customize),
-                    value.lib_protobuf_type(&self.customize),
-                    self.proto_field.number(),
-                    self.self_field()
-                ));
-            }
-            FieldKind::Repeated(RepeatedField { packed: true, .. }) => {
-                self.write_if_self_field_is_not_empty(w, |w| {
-                    let size_expr = self.self_field_vec_packed_size();
-                    w.write_line(&format!("{} += {};", sum_var, size_expr));
-                });
-            }
-            FieldKind::Oneof(..) => unreachable!(),
-        }
-    }
-
-    fn write_message_field_get_singular(&self, w: &mut CodeWriter) {
-        let get_xxx_return_type = self.get_xxx_return_type();
-
-        if self.proto_type == FieldDescriptorProto_Type::TYPE_MESSAGE {
-            let self_field = self.self_field();
-            let ref rust_type_message = match self.elem().rust_storage_type() {
-                RustType::Message(m) => m,
-                _ => unreachable!(),
-            };
-            w.write_line(&format!(
-                "{}.as_ref().unwrap_or_else(|| {})",
-                self_field,
-                rust_type_message.default_instance(&self.customize)
-            ));
-        } else {
-            let get_xxx_default_value_rust = self.get_xxx_default_value_rust();
-            let self_field = self.self_field();
-            match self.singular() {
-                &SingularField {
-                    flag: SingularFieldFlag::WithFlag { .. },
-                    ..
-                } => {
-                    if get_xxx_return_type.is_ref() {
-                        let as_option = self.self_field_as_option();
-                        w.match_expr(&as_option.value, |w| {
-                            let v_type = as_option.rust_type.elem_type();
-                            let r_type = self.get_xxx_return_type();
-                            w.case_expr(
-                                "Some(v)",
-                                v_type.into_target(&r_type, "v", &self.customize),
-                            );
-                            let get_xxx_default_value_rust = self.get_xxx_default_value_rust();
-                            w.case_expr("None", get_xxx_default_value_rust);
-                        });
-                    } else {
-                        w.write_line(&format!(
-                            "{}.unwrap_or({})",
-                            self_field, get_xxx_default_value_rust
-                        ));
-                    }
-                }
-                &SingularField {
-                    flag: SingularFieldFlag::WithoutFlag,
-                    ..
-                } => {
-                    w.write_line(self.full_storage_type().into_target(
-                        &get_xxx_return_type,
-                        &self_field,
-                        &self.customize,
-                    ));
-                }
-            }
-        }
-    }
-
-    fn write_message_field_get(&self, w: &mut CodeWriter) {
-        let get_xxx_return_type = self.get_xxx_return_type();
-        let fn_def = format!(
-            "get_{}(&self) -> {}",
-            self.rust_name,
-            get_xxx_return_type.to_code(&self.customize)
-        );
-
-        w.pub_fn(&fn_def, |w| match self.kind {
-            FieldKind::Oneof(OneofField { ref elem, .. }) => {
-                let self_field_oneof = self.self_field_oneof();
-                w.match_expr(self_field_oneof, |w| {
-                    let (refv, vtype) = if !self.elem_type_is_copy() {
-                        ("ref v", elem.rust_storage_type().ref_type())
-                    } else {
-                        ("v", elem.rust_storage_type())
-                    };
-                    w.case_expr(
-                        format!(
-                            "::std::option::Option::Some({}({}))",
-                            self.variant_path(),
-                            refv
-                        ),
-                        vtype.into_target(&get_xxx_return_type, "v", &self.customize),
-                    );
-                    w.case_expr("_", self.get_xxx_default_value_rust());
-                })
-            }
-            FieldKind::Singular(..) => {
-                self.write_message_field_get_singular(w);
-            }
-            FieldKind::Repeated(..) | FieldKind::Map(..) => {
-                let self_field = self.self_field();
-                w.write_line(&format!("&{}", self_field));
-            }
-        });
-    }
-
-    fn has_has(&self) -> bool {
-        match self.kind {
-            FieldKind::Repeated(..) | FieldKind::Map(..) => false,
-            FieldKind::Singular(SingularField {
-                flag: SingularFieldFlag::WithFlag { .. },
-                ..
-            }) => true,
-            FieldKind::Singular(SingularField {
-                flag: SingularFieldFlag::WithoutFlag,
-                ..
-            }) => false,
-            FieldKind::Oneof(..) => true,
-        }
-    }
-
-    fn has_mut(&self) -> bool {
-        match self.kind {
-            FieldKind::Repeated(..) | FieldKind::Map(..) => true,
-            // TODO: string should be public, and mut is not needed
-            FieldKind::Singular(..) | FieldKind::Oneof(..) => !self.elem_type_is_copy(),
-        }
-    }
-
-    fn has_take(&self) -> bool {
-        match self.kind {
-            FieldKind::Repeated(..) | FieldKind::Map(..) => true,
-            // TODO: string should be public, and mut is not needed
-            FieldKind::Singular(..) | FieldKind::Oneof(..) => !self.elem_type_is_copy(),
-        }
-    }
-
-    fn has_name(&self) -> String {
-        format!("has_{}", self.rust_name)
-    }
-
-    fn write_message_field_has(&self, w: &mut CodeWriter) {
-        w.pub_fn(&format!("{}(&self) -> bool", self.has_name()), |w| {
-            if !self.is_oneof() {
-                let self_field_is_some = self.self_field_is_some();
-                w.write_line(self_field_is_some);
-            } else {
-                let self_field_oneof = self.self_field_oneof();
-                w.match_expr(self_field_oneof, |w| {
-                    w.case_expr(
-                        format!("::std::option::Option::Some({}(..))", self.variant_path()),
-                        "true",
-                    );
-                    w.case_expr("_", "false");
-                });
-            }
-        });
-    }
-
-    fn write_message_field_set(&self, w: &mut CodeWriter) {
-        let set_xxx_param_type = self.set_xxx_param_type();
-        w.comment("Param is passed by value, moved");
-        let ref name = self.rust_name;
-        w.pub_fn(
-            &format!(
-                "set_{}(&mut self, v: {})",
-                name,
-                set_xxx_param_type.to_code(&self.customize)
-            ),
-            |w| {
-                if !self.is_oneof() {
-                    self.write_self_field_assign_value(w, "v", &set_xxx_param_type);
-                } else {
-                    let self_field_oneof = self.self_field_oneof();
-                    let v = set_xxx_param_type.into_target(
-                        &self.oneof().rust_type(),
-                        "v",
-                        &self.customize,
-                    );
-                    w.write_line(&format!(
-                        "{} = ::std::option::Option::Some({}({}))",
-                        self_field_oneof,
-                        self.variant_path(),
-                        v
-                    ));
-                }
-            },
-        );
-    }
-
-    fn write_message_field_mut(&self, w: &mut CodeWriter) {
-        let mut_xxx_return_type = self.mut_xxx_return_type();
-        w.comment("Mutable pointer to the field.");
-        if self.is_singular() {
-            w.comment("If field is not initialized, it is initialized with default value first.");
-        }
-        let fn_def = match mut_xxx_return_type {
-            RustType::Ref(ref param) => format!(
-                "mut_{}(&mut self) -> &mut {}",
-                self.rust_name,
-                param.to_code(&self.customize)
-            ),
-            _ => panic!(
-                "not a ref: {}",
-                mut_xxx_return_type.to_code(&self.customize)
-            ),
-        };
-        w.pub_fn(&fn_def, |w| {
-            match self.kind {
-                FieldKind::Repeated(..) | FieldKind::Map(..) => {
-                    let self_field = self.self_field();
-                    w.write_line(&format!("&mut {}", self_field));
-                }
-                FieldKind::Singular(SingularField {
-                    flag: SingularFieldFlag::WithFlag { .. },
-                    ..
-                }) => {
-                    self.write_if_self_field_is_none(w, |w| {
-                        self.write_self_field_assign_default(w);
-                    });
-                    let self_field = self.self_field();
-                    w.write_line(&format!("{}.as_mut().unwrap()", self_field));
-                }
-                FieldKind::Singular(SingularField {
-                    flag: SingularFieldFlag::WithoutFlag,
-                    ..
-                }) => w.write_line(&format!("&mut {}", self.self_field())),
-                FieldKind::Oneof(..) => {
-                    let self_field_oneof = self.self_field_oneof();
-
-                    // if oneof does not contain current field
-                    w.if_let_else_stmt(
-                        &format!("::std::option::Option::Some({}(_))", self.variant_path())[..],
-                        &self_field_oneof[..],
-                        |w| {
-                            // initialize it with default value
-                            w.write_line(&format!(
-                                "{} = ::std::option::Option::Some({}({}));",
-                                self_field_oneof,
-                                self.variant_path(),
-                                self.element_default_value_rust()
-                                    .into_type(self.oneof().rust_type(), &self.customize)
-                                    .value
-                            ));
-                        },
-                    );
-
-                    // extract field
-                    w.match_expr(self_field_oneof, |w| {
-                        w.case_expr(
-                            format!(
-                                "::std::option::Option::Some({}(ref mut v))",
-                                self.variant_path()
-                            ),
-                            "v",
-                        );
-                        w.case_expr("_", "panic!()");
-                    });
-                }
-            }
-        });
-    }
-
-    fn write_message_field_take_oneof(&self, w: &mut CodeWriter) {
-        let take_xxx_return_type = self.take_xxx_return_type();
-
-        // TODO: replace with if let
-        w.write_line(&format!("if self.{}() {{", self.has_name()));
-        w.indented(|w| {
-            let self_field_oneof = self.self_field_oneof();
-            w.match_expr(format!("{}.take()", self_field_oneof), |w| {
-                let value_in_some = self.oneof().rust_type().value("v".to_owned());
-                let converted =
-                    value_in_some.into_type(self.take_xxx_return_type(), &self.customize);
-                w.case_expr(
-                    format!("::std::option::Option::Some({}(v))", self.variant_path()),
-                    &converted.value,
-                );
-                w.case_expr("_", "panic!()");
-            });
-        });
-        w.write_line("} else {");
-        w.indented(|w| {
-            w.write_line(
-                self.elem()
-                    .rust_storage_type()
-                    .default_value_typed(&self.customize)
-                    .into_type(take_xxx_return_type.clone(), &self.customize)
-                    .value,
-            );
-        });
-        w.write_line("}");
-    }
-
-    fn write_message_field_take(&self, w: &mut CodeWriter) {
-        let take_xxx_return_type = self.take_xxx_return_type();
-        w.comment("Take field");
-        w.pub_fn(
-            &format!(
-                "take_{}(&mut self) -> {}",
-                self.rust_name,
-                take_xxx_return_type.to_code(&self.customize)
-            ),
-            |w| match self.kind {
-                FieldKind::Oneof(..) => {
-                    self.write_message_field_take_oneof(w);
-                }
-                FieldKind::Repeated(..) | FieldKind::Map(..) => {
-                    w.write_line(&format!(
-                        "::std::mem::replace(&mut self.{}, {})",
-                        self.rust_name,
-                        take_xxx_return_type.default_value(&self.customize)
-                    ));
-                }
-                FieldKind::Singular(SingularField {
-                    ref elem,
-                    flag: SingularFieldFlag::WithFlag { .. },
-                }) => {
-                    if !elem.is_copy() {
-                        w.write_line(&format!(
-                            "{}.take().unwrap_or_else(|| {})",
-                            self.self_field(),
-                            elem.rust_storage_type().default_value(&self.customize)
-                        ));
-                    } else {
-                        w.write_line(&format!(
-                            "{}.take().unwrap_or({})",
-                            self.self_field(),
-                            self.element_default_value_rust().value
-                        ));
-                    }
-                }
-                FieldKind::Singular(SingularField {
-                    flag: SingularFieldFlag::WithoutFlag,
-                    ..
-                }) => w.write_line(&format!(
-                    "::std::mem::replace(&mut {}, {})",
-                    self.self_field(),
-                    self.full_storage_type().default_value(&self.customize)
-                )),
-            },
-        );
-    }
-
-    pub fn write_message_single_field_accessors(&self, w: &mut CodeWriter) {
-        // TODO: do not generate `get` when !proto2 and !generate_accessors`
-        w.write_line("");
-        self.write_message_field_get(w);
-
-        if !self.generate_accessors {
-            return;
-        }
-
-        let clear_field_func = self.clear_field_func();
-        w.pub_fn(&format!("{}(&mut self)", clear_field_func), |w| {
-            self.write_clear(w);
-        });
-
-        if self.has_has() {
-            w.write_line("");
-            self.write_message_field_has(w);
-        }
-
-        w.write_line("");
-        self.write_message_field_set(w);
-
-        if self.has_mut() {
-            w.write_line("");
-            self.write_message_field_mut(w);
-        }
-
-        if self.has_take() {
-            w.write_line("");
-            self.write_message_field_take(w);
-        }
-    }
-}
-
-pub(crate) fn rust_field_name_for_protobuf_field_name(name: &str) -> RustIdent {
-    if rust::is_rust_keyword(name) {
-        RustIdent::new(&format!("field_{}", name))
-    } else {
-        RustIdent::new(name)
-    }
-}
diff --git a/src/file.rs b/src/file.rs
deleted file mode 100644
index 413e1bc..0000000
--- a/src/file.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-use crate::rust;
-use crate::rust_name::RustIdent;
-use crate::strx;
-
-// Copy-pasted from libsyntax.
-fn ident_start(c: char) -> bool {
-    (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'
-}
-
-// Copy-pasted from libsyntax.
-fn ident_continue(c: char) -> bool {
-    (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_'
-}
-
-pub(crate) fn proto_path_to_rust_mod(path: &str) -> RustIdent {
-    let without_dir = strx::remove_to(path, std::path::is_separator);
-    let without_suffix = strx::remove_suffix(without_dir, ".proto");
-
-    let name = without_suffix
-        .chars()
-        .enumerate()
-        .map(|(i, c)| {
-            let valid = if i == 0 {
-                ident_start(c)
-            } else {
-                ident_continue(c)
-            };
-            if valid {
-                c
-            } else {
-                '_'
-            }
-        })
-        .collect::<String>();
-
-    let name = if rust::is_rust_keyword(&name) {
-        format!("{}_pb", name)
-    } else {
-        name
-    };
-    RustIdent::from(name)
-}
-
-#[cfg(test)]
-mod test {
-
-    use super::proto_path_to_rust_mod;
-    use crate::rust_name::RustIdent;
-
-    #[test]
-    fn test_mod_path_proto_ext() {
-        assert_eq!(
-            RustIdent::from("proto"),
-            proto_path_to_rust_mod("proto.proto")
-        );
-    }
-
-    #[test]
-    fn test_mod_path_unknown_ext() {
-        assert_eq!(
-            RustIdent::from("proto_proto3"),
-            proto_path_to_rust_mod("proto.proto3")
-        );
-    }
-
-    #[test]
-    fn test_mod_path_empty_ext() {
-        assert_eq!(RustIdent::from("proto"), proto_path_to_rust_mod("proto"));
-    }
-
-    #[test]
-    fn test_mod_path_dir() {
-        assert_eq!(
-            RustIdent::from("baz"),
-            proto_path_to_rust_mod("foo/bar/baz.proto"),
-        )
-    }
-
-    #[cfg(target_os = "windows")]
-    #[test]
-    fn test_mod_path_dir_backslashes() {
-        assert_eq!(
-            RustIdent::from("baz"),
-            proto_path_to_rust_mod("foo\\bar\\baz.proto"),
-        )
-    }
-}
diff --git a/src/file_descriptor.rs b/src/file_descriptor.rs
deleted file mode 100644
index dde8603..0000000
--- a/src/file_descriptor.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use crate::scope::Scope;
-
-pub(crate) fn file_descriptor_proto_expr(_scope: &Scope) -> String {
-    format!("file_descriptor_proto()")
-}
diff --git a/src/float.rs b/src/float.rs
deleted file mode 100644
index 78ca622..0000000
--- a/src/float.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use std::f64;
-
-#[derive(Debug)]
-pub enum ProtobufFloatParseError {
-    EmptyString,
-    CannotParseFloat,
-}
-
-pub type ProtobufFloatParseResult<T> = Result<T, ProtobufFloatParseError>;
-
-pub const PROTOBUF_NAN: &str = "nan";
-pub const PROTOBUF_INF: &str = "inf";
-
-/// Format float as in protobuf `.proto` files
-pub fn format_protobuf_float(f: f64) -> String {
-    if f.is_nan() {
-        PROTOBUF_NAN.to_owned()
-    } else if f.is_infinite() {
-        if f > 0.0 {
-            format!("{}", PROTOBUF_INF)
-        } else {
-            format!("-{}", PROTOBUF_INF)
-        }
-    } else {
-        let i = f as i64;
-        if i as f64 == f {
-            // Older rust versions did print float without `.0` suffix
-            format!("{:?}.0", i)
-        } else {
-            // TODO: make sure doesn't lose precision
-            format!("{:?}", f)
-        }
-    }
-}
-
-/// Parse float from `.proto` format
-pub fn parse_protobuf_float(s: &str) -> ProtobufFloatParseResult<f64> {
-    if s.is_empty() {
-        return Err(ProtobufFloatParseError::EmptyString);
-    }
-    if s == PROTOBUF_NAN {
-        return Ok(f64::NAN);
-    }
-    if s == PROTOBUF_INF || s == format!("+{}", PROTOBUF_INF) {
-        return Ok(f64::INFINITY);
-    }
-    if s == format!("-{}", PROTOBUF_INF) {
-        return Ok(f64::NEG_INFINITY);
-    }
-    match s.parse() {
-        Ok(f) => Ok(f),
-        Err(_) => Err(ProtobufFloatParseError::CannotParseFloat),
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_format_protobuf_float() {
-        assert_eq!("10.0", format_protobuf_float(10.0));
-        assert_eq!("-10.0", format_protobuf_float(-10.0));
-        assert_eq!("10.5", format_protobuf_float(10.5));
-        assert_eq!("-10.5", format_protobuf_float(-10.5));
-    }
-}
diff --git a/src/gen/all.rs b/src/gen/all.rs
new file mode 100644
index 0000000..312b8db
--- /dev/null
+++ b/src/gen/all.rs
@@ -0,0 +1,64 @@
+use std::collections::HashMap;
+
+use protobuf::descriptor::FileDescriptorProto;
+use protobuf::reflect::FileDescriptor;
+use protobuf_parse::ProtoPath;
+use protobuf_parse::ProtoPathBuf;
+
+use crate::compiler_plugin;
+use crate::customize::ctx::CustomizeElemCtx;
+use crate::customize::CustomizeCallback;
+use crate::gen::file::gen_file;
+use crate::gen::mod_rs::gen_mod_rs;
+use crate::gen::scope::RootScope;
+use crate::gen::well_known_types::gen_well_known_types_mod;
+use crate::Customize;
+
+pub(crate) fn gen_all(
+    file_descriptors: &[FileDescriptorProto],
+    parser: &str,
+    files_to_generate: &[ProtoPathBuf],
+    customize: &Customize,
+    customize_callback: &dyn CustomizeCallback,
+) -> anyhow::Result<Vec<compiler_plugin::GenResult>> {
+    let file_descriptors = FileDescriptor::new_dynamic_fds(file_descriptors.to_vec(), &[])?;
+
+    let root_scope = RootScope {
+        file_descriptors: &file_descriptors,
+    };
+
+    let mut results: Vec<compiler_plugin::GenResult> = Vec::new();
+    let files_map: HashMap<&ProtoPath, &FileDescriptor> = file_descriptors
+        .iter()
+        .map(|f| Ok((ProtoPath::new(f.proto().name())?, f)))
+        .collect::<Result<_, anyhow::Error>>()?;
+
+    let mut mods = Vec::new();
+
+    let customize = CustomizeElemCtx {
+        for_elem: customize.clone(),
+        for_children: customize.clone(),
+        callback: customize_callback,
+    };
+
+    for file_name in files_to_generate {
+        let file = files_map.get(file_name.as_path()).expect(&format!(
+            "file not found in file descriptors: {:?}, files: {:?}",
+            file_name,
+            files_map.keys()
+        ));
+        let gen_file_result = gen_file(file, &files_map, &root_scope, &customize, parser)?;
+        results.push(gen_file_result.compiler_plugin_result);
+        mods.push(gen_file_result.mod_name);
+    }
+
+    if customize.for_elem.inside_protobuf.unwrap_or(false) {
+        results.push(gen_well_known_types_mod());
+    }
+
+    if customize.for_elem.gen_mod_rs.unwrap_or(true) {
+        results.push(gen_mod_rs(&mods));
+    }
+
+    Ok(results)
+}
diff --git a/src/gen/code_writer.rs b/src/gen/code_writer.rs
new file mode 100644
index 0000000..28b3817
--- /dev/null
+++ b/src/gen/code_writer.rs
@@ -0,0 +1,455 @@
+use std::convert::Infallible;
+
+use crate::gen::rust::rel_path::RustRelativePath;
+
+/// Field visibility.
+pub(crate) enum Visibility {
+    Public,
+    Default,
+    Path(RustRelativePath),
+}
+
+pub(crate) struct CodeWriter<'a> {
+    writer: &'a mut String,
+    indent: String,
+}
+
+impl<'a> CodeWriter<'a> {
+    pub(crate) fn new(writer: &'a mut String) -> CodeWriter<'a> {
+        CodeWriter {
+            writer,
+            indent: "".to_string(),
+        }
+    }
+
+    pub(crate) fn with_no_error(f: impl FnOnce(&mut CodeWriter)) -> String {
+        Self::with_impl::<Infallible, _>(|w| Ok(f(w))).unwrap_or_else(|e| match e {})
+    }
+
+    pub(crate) fn with<F>(f: F) -> anyhow::Result<String>
+    where
+        F: FnOnce(&mut CodeWriter) -> anyhow::Result<()>,
+    {
+        Self::with_impl(f)
+    }
+
+    fn with_impl<E, F>(f: F) -> Result<String, E>
+    where
+        F: FnOnce(&mut CodeWriter) -> Result<(), E>,
+    {
+        let mut writer = String::new();
+        {
+            let mut cw = CodeWriter::new(&mut writer);
+            f(&mut cw)?;
+        }
+        Ok(writer)
+    }
+
+    pub(crate) fn write_line<S: AsRef<str>>(&mut self, line: S) {
+        if line.as_ref().is_empty() {
+            self.writer.push_str("\n");
+        } else {
+            let s: String = [self.indent.as_ref(), line.as_ref(), "\n"].concat();
+            self.writer.push_str(&s);
+        }
+    }
+
+    pub(crate) fn _write_text(&mut self, text: &str) {
+        for line in text.lines() {
+            self.write_line(line);
+        }
+    }
+
+    pub(crate) fn write_generated_by(&mut self, pkg: &str, version: &str, parser: &str) {
+        self.write_line(format!(
+            "// This file is generated by {pkg} {version}. Do not edit",
+            pkg = pkg,
+            version = version
+        ));
+        self.write_line(format!(
+            "// .proto file is parsed by {parser}",
+            parser = parser
+        ));
+        self.write_generated_common();
+    }
+
+    fn write_generated_common(&mut self) {
+        // https://secure.phabricator.com/T784
+        self.write_line(&format!("// {}generated", "@"));
+
+        self.write_line("");
+        self.comment("https://github.com/rust-lang/rust-clippy/issues/702");
+        self.write_line("#![allow(unknown_lints)]");
+        self.write_line("#![allow(clippy::all)]");
+        self.write_line("");
+        self.write_line("#![allow(unused_attributes)]");
+        self.write_line("#![cfg_attr(rustfmt, rustfmt::skip)]");
+        self.write_line("");
+        self.write_line("#![allow(box_pointers)]");
+        self.write_line("#![allow(dead_code)]");
+        self.write_line("#![allow(missing_docs)]");
+        self.write_line("#![allow(non_camel_case_types)]");
+        self.write_line("#![allow(non_snake_case)]");
+        self.write_line("#![allow(non_upper_case_globals)]");
+        self.write_line("#![allow(trivial_casts)]");
+        self.write_line("#![allow(unused_results)]");
+        self.write_line("#![allow(unused_mut)]");
+    }
+
+    pub(crate) fn unimplemented(&mut self) {
+        self.write_line(format!("unimplemented!();"));
+    }
+
+    pub(crate) fn indented<F>(&mut self, cb: F)
+    where
+        F: FnOnce(&mut CodeWriter),
+    {
+        cb(&mut CodeWriter {
+            writer: self.writer,
+            indent: format!("{}    ", self.indent),
+        });
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn commented<F>(&mut self, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        cb(&mut CodeWriter {
+            writer: self.writer,
+            indent: format!("// {}", self.indent),
+        });
+    }
+
+    pub(crate) fn pub_const(&mut self, name: &str, field_type: &str, init: &str) {
+        self.write_line(&format!("pub const {}: {} = {};", name, field_type, init));
+    }
+
+    pub(crate) fn lazy_static(&mut self, name: &str, ty: &str, protobuf_crate_path: &str) {
+        self.write_line(&format!(
+            "static {}: {}::rt::Lazy<{}> = {}::rt::Lazy::new();",
+            name, protobuf_crate_path, ty, protobuf_crate_path,
+        ));
+    }
+
+    pub(crate) fn lazy_static_decl_get_simple(
+        &mut self,
+        name: &str,
+        ty: &str,
+        init: &str,
+        protobuf_crate_path: &str,
+    ) {
+        self.lazy_static(name, ty, protobuf_crate_path);
+        self.write_line(&format!("{}.get({})", name, init));
+    }
+
+    pub(crate) fn lazy_static_decl_get(
+        &mut self,
+        name: &str,
+        ty: &str,
+        protobuf_crate_path: &str,
+        init: impl FnOnce(&mut CodeWriter),
+    ) {
+        self.lazy_static(name, ty, protobuf_crate_path);
+        self.block(&format!("{}.get(|| {{", name), "})", init);
+    }
+
+    pub(crate) fn block<F>(&mut self, first_line: &str, last_line: &str, cb: F)
+    where
+        F: FnOnce(&mut CodeWriter),
+    {
+        self.write_line(first_line);
+        self.indented(cb);
+        self.write_line(last_line);
+    }
+
+    pub(crate) fn expr_block<F>(&mut self, prefix: &str, cb: F)
+    where
+        F: FnOnce(&mut CodeWriter),
+    {
+        self.block(&format!("{} {{", prefix), "}", cb);
+    }
+
+    pub(crate) fn stmt_block<S: AsRef<str>, F>(&mut self, prefix: S, cb: F)
+    where
+        F: FnOnce(&mut CodeWriter),
+    {
+        self.block(&format!("{} {{", prefix.as_ref()), "};", cb);
+    }
+
+    pub(crate) fn impl_self_block<S: AsRef<str>, F>(&mut self, name: S, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        self.expr_block(&format!("impl {}", name.as_ref()), cb);
+    }
+
+    pub(crate) fn impl_for_block<S1: AsRef<str>, S2: AsRef<str>, F>(
+        &mut self,
+        tr: S1,
+        ty: S2,
+        cb: F,
+    ) where
+        F: Fn(&mut CodeWriter),
+    {
+        self.impl_args_for_block(&[], tr.as_ref(), ty.as_ref(), cb);
+    }
+
+    pub(crate) fn impl_args_for_block<F>(&mut self, args: &[&str], tr: &str, ty: &str, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        let args_str = if args.is_empty() {
+            "".to_owned()
+        } else {
+            format!("<{}>", args.join(", "))
+        };
+        self.expr_block(&format!("impl{} {} for {}", args_str, tr, ty), cb);
+    }
+
+    pub(crate) fn pub_struct<S: AsRef<str>, F>(&mut self, name: S, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        self.expr_block(&format!("pub struct {}", name.as_ref()), cb);
+    }
+
+    pub(crate) fn pub_enum<F>(&mut self, name: &str, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        self.expr_block(&format!("pub enum {}", name), cb);
+    }
+
+    pub(crate) fn field_entry(&mut self, name: &str, value: &str) {
+        self.write_line(&format!("{}: {},", name, value));
+    }
+
+    pub(crate) fn field_decl(&mut self, name: &str, field_type: &str) {
+        self.write_line(&format!("{}: {},", name, field_type));
+    }
+
+    pub(crate) fn pub_field_decl(&mut self, name: &str, field_type: &str) {
+        self.write_line(&format!("pub {}: {},", name, field_type));
+    }
+
+    pub(crate) fn field_decl_vis(&mut self, vis: Visibility, name: &str, field_type: &str) {
+        match vis {
+            Visibility::Public => self.pub_field_decl(name, field_type),
+            Visibility::Default => self.field_decl(name, field_type),
+            Visibility::Path(..) => unimplemented!(),
+        }
+    }
+
+    pub(crate) fn derive(&mut self, derive: &[&str]) {
+        let v: Vec<String> = derive.iter().map(|&s| s.to_string()).collect();
+        self.write_line(&format!("#[derive({})]", v.join(",")));
+    }
+
+    pub(crate) fn allow(&mut self, what: &[&str]) {
+        let v: Vec<String> = what.iter().map(|&s| s.to_string()).collect();
+        self.write_line(&format!("#[allow({})]", v.join(",")));
+    }
+
+    pub(crate) fn comment(&mut self, comment: &str) {
+        if comment.is_empty() {
+            self.write_line("//");
+        } else {
+            self.write_line(&format!("// {}", comment));
+        }
+    }
+
+    fn documentation(&mut self, comment: &str) {
+        if comment.is_empty() {
+            self.write_line("///");
+        } else {
+            self.write_line(&format!("/// {}", comment));
+        }
+    }
+
+    pub(crate) fn mod_doc(&mut self, comment: &str) {
+        if comment.is_empty() {
+            self.write_line("//!");
+        } else {
+            self.write_line(&format!("//! {}", comment));
+        }
+    }
+
+    /// Writes the documentation of the given path.
+    ///
+    /// Protobuf paths are defined in proto/google/protobuf/descriptor.proto,
+    /// in the `SourceCodeInfo` message.
+    ///
+    /// For example, say we have a file like:
+    ///
+    /// ```ignore
+    /// message Foo {
+    ///   optional string foo = 1;
+    /// }
+    /// ```
+    ///
+    /// Let's look at just the field definition. We have the following paths:
+    ///
+    /// ```ignore
+    /// path               represents
+    /// [ 4, 0, 2, 0 ]     The whole field definition.
+    /// [ 4, 0, 2, 0, 4 ]  The label (optional).
+    /// [ 4, 0, 2, 0, 5 ]  The type (string).
+    /// [ 4, 0, 2, 0, 1 ]  The name (foo).
+    /// [ 4, 0, 2, 0, 3 ]  The number (1).
+    /// ```
+    ///
+    /// The `4`s can be obtained using simple introspection:
+    ///
+    /// ```
+    /// use protobuf::descriptor::FileDescriptorProto;
+    /// use protobuf::reflect::MessageDescriptor;
+    ///
+    /// let id = MessageDescriptor::for_type::<FileDescriptorProto>()
+    ///     .field_by_name("message_type")
+    ///     .expect("`message_type` must exist")
+    ///     .proto()
+    ///     .number();
+    ///
+    /// assert_eq!(id, 4);
+    /// ```
+    ///
+    /// The first `0` here means this path refers to the first message.
+    ///
+    /// The `2` then refers to the `field` field on the `DescriptorProto` message.
+    ///
+    /// Then comes another `0` to refer to the first field of the current message.
+    ///
+    /// Etc.
+
+    pub(crate) fn all_documentation(
+        &mut self,
+        info: Option<&protobuf::descriptor::SourceCodeInfo>,
+        path: &[i32],
+    ) {
+        let doc = info
+            .map(|v| &v.location)
+            .and_then(|ls| ls.iter().find(|l| l.path == path))
+            .map(|l| l.leading_comments());
+
+        let lines = doc
+            .iter()
+            .map(|doc| doc.lines())
+            .flatten()
+            .collect::<Vec<_>>();
+
+        // Skip comments with code blocks to avoid rustdoc trying to compile them.
+        if !lines.iter().any(|line| line.starts_with("    ")) {
+            for doc in &lines {
+                self.documentation(doc);
+            }
+        }
+    }
+
+    pub(crate) fn fn_block<F>(&mut self, vis: Visibility, sig: &str, cb: F)
+    where
+        F: FnOnce(&mut CodeWriter),
+    {
+        match vis {
+            Visibility::Public => self.expr_block(&format!("pub fn {}", sig), cb),
+            Visibility::Default => self.expr_block(&format!("fn {}", sig), cb),
+            Visibility::Path(p) if p.is_empty() => self.expr_block(&format!("fn {}", sig), cb),
+            Visibility::Path(p) => self.expr_block(&format!("pub(in {}) fn {}", p, sig), cb),
+        }
+    }
+
+    pub(crate) fn pub_fn<F>(&mut self, sig: &str, cb: F)
+    where
+        F: FnOnce(&mut CodeWriter),
+    {
+        self.fn_block(Visibility::Public, sig, cb);
+    }
+
+    pub(crate) fn def_fn<F>(&mut self, sig: &str, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        self.fn_block(Visibility::Default, sig, cb);
+    }
+
+    pub(crate) fn pub_mod<F>(&mut self, name: &str, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        self.expr_block(&format!("pub mod {}", name), cb)
+    }
+
+    pub(crate) fn while_block<S: AsRef<str>, F>(&mut self, cond: S, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        self.expr_block(&format!("while {}", cond.as_ref()), cb);
+    }
+
+    // if ... { ... }
+    pub(crate) fn if_stmt<S: AsRef<str>, F>(&mut self, cond: S, cb: F)
+    where
+        F: FnOnce(&mut CodeWriter),
+    {
+        self.expr_block(&format!("if {}", cond.as_ref()), cb);
+    }
+
+    // if ... {} else { ... }
+    pub(crate) fn if_else_stmt<S: AsRef<str>, F>(&mut self, cond: S, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        self.write_line(&format!("if {} {{", cond.as_ref()));
+        self.write_line("} else {");
+        self.indented(cb);
+        self.write_line("}");
+    }
+
+    // if let ... = ... { ... }
+    pub(crate) fn if_let_stmt<F>(&mut self, decl: &str, expr: &str, cb: F)
+    where
+        F: FnOnce(&mut CodeWriter),
+    {
+        self.if_stmt(&format!("let {} = {}", decl, expr), cb);
+    }
+
+    // if let ... = ... { } else { ... }
+    pub(crate) fn if_let_else_stmt<F>(&mut self, decl: &str, expr: &str, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        self.if_else_stmt(&format!("let {} = {}", decl, expr), cb);
+    }
+
+    pub(crate) fn for_stmt<S1: AsRef<str>, S2: AsRef<str>, F>(&mut self, over: S1, varn: S2, cb: F)
+    where
+        F: FnOnce(&mut CodeWriter),
+    {
+        self.stmt_block(&format!("for {} in {}", varn.as_ref(), over.as_ref()), cb)
+    }
+
+    pub(crate) fn match_block<S: AsRef<str>, F>(&mut self, value: S, cb: F)
+    where
+        F: FnOnce(&mut CodeWriter),
+    {
+        self.stmt_block(&format!("match {}", value.as_ref()), cb);
+    }
+
+    pub(crate) fn match_expr<S: AsRef<str>, F>(&mut self, value: S, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        self.expr_block(&format!("match {}", value.as_ref()), cb);
+    }
+
+    pub(crate) fn case_block<S: AsRef<str>, F>(&mut self, cond: S, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        self.block(&format!("{} => {{", cond.as_ref()), "},", cb);
+    }
+
+    pub(crate) fn case_expr<S1: AsRef<str>, S2: AsRef<str>>(&mut self, cond: S1, body: S2) {
+        self.write_line(&format!("{} => {},", cond.as_ref(), body.as_ref()));
+    }
+}
diff --git a/src/gen/descriptor.rs b/src/gen/descriptor.rs
new file mode 100644
index 0000000..53ed061
--- /dev/null
+++ b/src/gen/descriptor.rs
@@ -0,0 +1,68 @@
+use protobuf::reflect::EnumDescriptor;
+use protobuf::reflect::MessageDescriptor;
+
+use crate::gen::code_writer::CodeWriter;
+use crate::gen::file_descriptor::file_descriptor_call_expr;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::scope::Scope;
+use crate::Customize;
+
+/// Abstract message or enum descriptor.
+pub(crate) trait Descriptor {
+    const DESCRIPTOR_FN: &'static str;
+    const TYPE_NAME: &'static str;
+    const GET_BY_RELATIVE_NAME_NAME: &'static str;
+    fn name_to_package(&self) -> &str;
+}
+
+impl Descriptor for MessageDescriptor {
+    const DESCRIPTOR_FN: &'static str = "descriptor";
+    const TYPE_NAME: &'static str = "MessageDescriptor";
+    const GET_BY_RELATIVE_NAME_NAME: &'static str = "message_by_package_relative_name";
+
+    fn name_to_package(&self) -> &str {
+        self.name_to_package()
+    }
+}
+
+impl Descriptor for EnumDescriptor {
+    const DESCRIPTOR_FN: &'static str = "enum_descriptor";
+    const TYPE_NAME: &'static str = "EnumDescriptor";
+    const GET_BY_RELATIVE_NAME_NAME: &'static str = "enum_by_package_relative_name";
+
+    fn name_to_package(&self) -> &str {
+        self.name_to_package()
+    }
+}
+
+pub(crate) fn write_fn_descriptor<D: Descriptor>(
+    descriptor: &D,
+    scope: &Scope,
+    customize: &Customize,
+    w: &mut CodeWriter,
+) {
+    let sig = format!(
+        "{}() -> {}::reflect::{}",
+        D::DESCRIPTOR_FN,
+        protobuf_crate_path(customize),
+        D::TYPE_NAME,
+    );
+    w.def_fn(&sig, |w| {
+        let expr = format!(
+            "{}.{}(\"{}\").unwrap()",
+            file_descriptor_call_expr(scope),
+            D::GET_BY_RELATIVE_NAME_NAME,
+            descriptor.name_to_package()
+        );
+        w.lazy_static(
+            "descriptor",
+            &format!(
+                "{}::reflect::{}",
+                protobuf_crate_path(customize),
+                D::TYPE_NAME,
+            ),
+            &protobuf_crate_path(customize).to_string(),
+        );
+        w.write_line(&format!("descriptor.get(|| {}).clone()", expr));
+    });
+}
diff --git a/src/gen/enums.rs b/src/gen/enums.rs
new file mode 100644
index 0000000..69e9e14
--- /dev/null
+++ b/src/gen/enums.rs
@@ -0,0 +1,413 @@
+use std::collections::HashSet;
+
+use protobuf::descriptor::*;
+
+use crate::customize::ctx::CustomizeElemCtx;
+use crate::customize::rustproto_proto::customize_from_rustproto_for_enum;
+use crate::gen::code_writer::CodeWriter;
+use crate::gen::code_writer::Visibility;
+use crate::gen::descriptor::write_fn_descriptor;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::protoc_insertion_point::write_protoc_insertion_point_for_enum;
+use crate::gen::protoc_insertion_point::write_protoc_insertion_point_for_enum_value;
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::ident_with_path::RustIdentWithPath;
+use crate::gen::rust::snippets::EXPR_NONE;
+use crate::gen::scope::EnumValueWithContext;
+use crate::gen::scope::EnumWithScope;
+use crate::gen::scope::RootScope;
+use crate::gen::scope::WithScope;
+
+#[derive(Clone)]
+pub(crate) struct EnumValueGen<'a> {
+    value: EnumValueWithContext<'a>,
+    enum_rust_name: RustIdentWithPath,
+}
+
+impl<'a> EnumValueGen<'a> {
+    fn parse(
+        value: EnumValueWithContext<'a>,
+        enum_rust_name: &RustIdentWithPath,
+    ) -> EnumValueGen<'a> {
+        EnumValueGen {
+            value: value.clone(),
+            enum_rust_name: enum_rust_name.clone(),
+        }
+    }
+
+    // enum value
+    fn number(&self) -> i32 {
+        self.value.proto.proto().number()
+    }
+
+    // name of enum variant in generated rust code
+    pub fn rust_name_inner(&self) -> RustIdent {
+        self.value.rust_name()
+    }
+
+    pub fn rust_name_outer(&self) -> RustIdentWithPath {
+        self.enum_rust_name
+            .to_path()
+            .with_ident(self.rust_name_inner())
+    }
+}
+
+// Codegen for enum definition
+pub(crate) struct EnumGen<'a> {
+    enum_with_scope: &'a EnumWithScope<'a>,
+    type_name: RustIdentWithPath,
+    lite_runtime: bool,
+    customize: CustomizeElemCtx<'a>,
+    path: &'a [i32],
+    info: Option<&'a SourceCodeInfo>,
+}
+
+impl<'a> EnumGen<'a> {
+    pub fn new(
+        enum_with_scope: &'a EnumWithScope<'a>,
+        customize: &CustomizeElemCtx<'a>,
+        _root_scope: &RootScope,
+        path: &'a [i32],
+        info: Option<&'a SourceCodeInfo>,
+    ) -> EnumGen<'a> {
+        let customize = customize.child(
+            &customize_from_rustproto_for_enum(enum_with_scope.en.proto().options.get_or_default()),
+            &enum_with_scope.en,
+        );
+        let lite_runtime = customize.for_elem.lite_runtime.unwrap_or_else(|| {
+            enum_with_scope
+                .file_descriptor()
+                .proto()
+                .options
+                .optimize_for()
+                == file_options::OptimizeMode::LITE_RUNTIME
+        });
+
+        EnumGen {
+            enum_with_scope,
+            type_name: enum_with_scope.rust_name().to_path(),
+            lite_runtime,
+            customize,
+            path,
+            info,
+        }
+    }
+
+    fn allow_alias(&self) -> bool {
+        self.enum_with_scope
+            .en
+            .proto()
+            .options
+            .get_or_default()
+            .allow_alias()
+    }
+
+    fn values_all(&self) -> Vec<EnumValueGen> {
+        let mut r = Vec::new();
+        for p in self.enum_with_scope.values() {
+            r.push(EnumValueGen::parse(p, &self.type_name));
+        }
+        r
+    }
+
+    fn values_unique(&self) -> Vec<EnumValueGen> {
+        let mut used = HashSet::new();
+        let mut r = Vec::new();
+        for p in self.enum_with_scope.values() {
+            if !used.insert(p.proto.proto().number()) {
+                continue;
+            }
+            r.push(EnumValueGen::parse(p, &self.type_name));
+        }
+        r
+    }
+
+    pub fn write(&self, w: &mut CodeWriter) {
+        self.write_enum(w);
+        if self.allow_alias() {
+            w.write_line("");
+            self.write_impl_eq(w);
+            w.write_line("");
+            self.write_impl_hash(w);
+        }
+        w.write_line("");
+        self.write_impl_enum(w);
+        if !self.lite_runtime {
+            w.write_line("");
+            self.write_impl_enum_full(w);
+        }
+        w.write_line("");
+        self.write_impl_default(w);
+        w.write_line("");
+        self.write_impl_self(w);
+    }
+
+    fn write_impl_self(&self, w: &mut CodeWriter) {
+        if !self.lite_runtime {
+            w.impl_self_block(&format!("{}", self.type_name), |w| {
+                self.write_generated_enum_descriptor_data(w);
+            });
+        }
+    }
+
+    fn write_enum(&self, w: &mut CodeWriter) {
+        w.all_documentation(self.info, self.path);
+
+        let mut derive = Vec::new();
+        derive.push("Clone");
+        derive.push("Copy");
+        if !self.allow_alias() {
+            derive.push("PartialEq");
+        }
+        derive.push("Eq");
+        derive.push("Debug");
+        if !self.allow_alias() {
+            derive.push("Hash");
+        } else {
+            w.comment("Note: you cannot use pattern matching for enums with allow_alias option");
+        }
+        w.derive(&derive);
+        let ref type_name = self.type_name;
+        write_protoc_insertion_point_for_enum(
+            w,
+            &self.customize.for_elem,
+            &self.enum_with_scope.en,
+        );
+        w.expr_block(&format!("pub enum {}", type_name), |w| {
+            for value in self.values_all() {
+                write_protoc_insertion_point_for_enum_value(
+                    w,
+                    &self.customize.for_children,
+                    &value.value.proto,
+                );
+                if self.allow_alias() {
+                    w.write_line(&format!(
+                        "{}, // {}",
+                        value.rust_name_inner(),
+                        value.number()
+                    ));
+                } else {
+                    w.write_line(&format!(
+                        "{} = {},",
+                        value.rust_name_inner(),
+                        value.number()
+                    ));
+                }
+            }
+        });
+    }
+
+    fn write_impl_enum_fn_value(&self, w: &mut CodeWriter) {
+        w.def_fn("value(&self) -> i32", |w| {
+            if self.allow_alias() {
+                w.match_expr("*self", |w| {
+                    for value in self.values_all() {
+                        w.case_expr(
+                            &format!("{}", value.rust_name_outer()),
+                            &format!("{}", value.number()),
+                        );
+                    }
+                });
+            } else {
+                w.write_line("*self as i32")
+            }
+        });
+    }
+
+    fn write_impl_enum_const_name(&self, w: &mut CodeWriter) {
+        w.write_line(&format!(
+            "const NAME: &'static str = \"{}\";",
+            self.enum_with_scope.en.name()
+        ));
+    }
+
+    fn write_impl_enum_fn_from_i32(&self, w: &mut CodeWriter) {
+        w.def_fn(
+            &format!(
+                "from_i32(value: i32) -> ::std::option::Option<{}>",
+                self.type_name
+            ),
+            |w| {
+                w.match_expr("value", |w| {
+                    let values = self.values_unique();
+                    for value in values {
+                        w.write_line(&format!(
+                            "{} => ::std::option::Option::Some({}),",
+                            value.number(),
+                            value.rust_name_outer()
+                        ));
+                    }
+                    w.write_line(&format!("_ => {}", EXPR_NONE));
+                });
+            },
+        );
+    }
+
+    fn write_impl_enum_const_values(&self, w: &mut CodeWriter) {
+        w.write_line(&format!("const VALUES: &'static [{}] = &[", self.type_name));
+        w.indented(|w| {
+            for value in self.values_all() {
+                w.write_line(&format!("{},", value.rust_name_outer()));
+            }
+        });
+        w.write_line("];");
+    }
+
+    fn write_impl_enum(&self, w: &mut CodeWriter) {
+        w.impl_for_block(
+            &format!("{}::Enum", protobuf_crate_path(&self.customize.for_elem)),
+            &format!("{}", self.type_name),
+            |w| {
+                self.write_impl_enum_const_name(w);
+                w.write_line("");
+                self.write_impl_enum_fn_value(w);
+                w.write_line("");
+                self.write_impl_enum_fn_from_i32(w);
+                w.write_line("");
+                self.write_impl_enum_const_values(w);
+            },
+        );
+    }
+
+    fn write_impl_enum_full(&self, w: &mut CodeWriter) {
+        let ref type_name = self.type_name;
+        w.impl_for_block(
+            &format!(
+                "{}::EnumFull",
+                protobuf_crate_path(&self.customize.for_elem)
+            ),
+            &format!("{}", type_name),
+            |w| {
+                self.write_impl_enum_full_fn_enum_descriptor(w);
+                w.write_line("");
+                self.write_impl_enum_full_fn_descriptor(w);
+            },
+        );
+    }
+
+    fn write_impl_enum_full_fn_enum_descriptor(&self, w: &mut CodeWriter) {
+        write_fn_descriptor(
+            &self.enum_with_scope.en,
+            self.enum_with_scope.scope(),
+            &self.customize.for_elem,
+            w,
+        );
+    }
+
+    fn rust_enum_descriptor_is_enum_index(&self) -> bool {
+        if self.allow_alias() {
+            false
+        } else {
+            self.values_all()
+                .into_iter()
+                .enumerate()
+                .all(|(i, value)| (i as i32) == value.number())
+        }
+    }
+
+    fn write_impl_enum_full_fn_descriptor(&self, w: &mut CodeWriter) {
+        let sig = format!(
+            "descriptor(&self) -> {}::reflect::EnumValueDescriptor",
+            protobuf_crate_path(&self.customize.for_elem)
+        );
+        w.def_fn(&sig, |w| {
+            if self.rust_enum_descriptor_is_enum_index() {
+                w.write_line("let index = *self as usize;");
+            } else {
+                w.write_line("let index = match self {");
+                w.indented(|w| {
+                    for (i, value) in self.values_all().into_iter().enumerate() {
+                        w.write_line(&format!(
+                            "{}::{} => {},",
+                            self.type_name,
+                            value.rust_name_inner(),
+                            i
+                        ));
+                    }
+                });
+                w.write_line("};");
+            }
+            w.write_line(&format!("Self::enum_descriptor().value_by_index(index)"));
+        });
+    }
+
+    fn write_generated_enum_descriptor_data(&self, w: &mut CodeWriter) {
+        let sig = format!(
+            "generated_enum_descriptor_data() -> {}::reflect::GeneratedEnumDescriptorData",
+            protobuf_crate_path(&self.customize.for_elem)
+        );
+        w.fn_block(
+            Visibility::Path(
+                self.enum_with_scope
+                    .scope()
+                    .rust_path_to_file()
+                    .to_reverse(),
+            ),
+            &sig,
+            |w| {
+                w.write_line(&format!(
+                    "{}::reflect::GeneratedEnumDescriptorData::new::<{}>(\"{}\")",
+                    protobuf_crate_path(&self.customize.for_elem),
+                    self.type_name,
+                    self.enum_with_scope.name_to_package(),
+                ));
+            },
+        );
+    }
+
+    fn write_impl_eq(&self, w: &mut CodeWriter) {
+        assert!(self.allow_alias());
+        w.impl_for_block(
+            "::std::cmp::PartialEq",
+            &format!("{}", self.type_name),
+            |w| {
+                w.def_fn("eq(&self, other: &Self) -> bool", |w| {
+                    w.write_line(&format!(
+                        "{}::Enum::value(self) == {}::Enum::value(other)",
+                        protobuf_crate_path(&self.customize.for_elem),
+                        protobuf_crate_path(&self.customize.for_elem)
+                    ));
+                });
+            },
+        );
+    }
+
+    fn write_impl_hash(&self, w: &mut CodeWriter) {
+        assert!(self.allow_alias());
+        w.impl_for_block("::std::hash::Hash", &format!("{}", self.type_name), |w| {
+            w.def_fn("hash<H : ::std::hash::Hasher>(&self, state: &mut H)", |w| {
+                w.write_line(&format!(
+                    "state.write_i32({}::Enum::value(self))",
+                    protobuf_crate_path(&self.customize.for_elem)
+                ));
+            });
+        });
+    }
+
+    fn write_impl_default(&self, w: &mut CodeWriter) {
+        let first_value = &self.enum_with_scope.values()[0];
+        if first_value.proto.proto().number() != 0 {
+            // This warning is emitted only for proto2
+            // (because in proto3 first enum variant number is always 0).
+            // `Default` implemented unconditionally to simplify certain
+            // generic operations, e. g. reading a map.
+            // Also, note that even in proto2 some operations fallback to
+            // first enum value, e. g. `get_xxx` for unset field,
+            // so this implementation is not completely unreasonable.
+            w.comment("Note, `Default` is implemented although default value is not 0");
+        }
+        w.impl_for_block(
+            "::std::default::Default",
+            &format!("{}", self.type_name),
+            |w| {
+                w.def_fn("default() -> Self", |w| {
+                    w.write_line(&format!(
+                        "{}::{}",
+                        &self.type_name,
+                        &first_value.rust_name()
+                    ))
+                });
+            },
+        );
+    }
+}
diff --git a/src/gen/extensions.rs b/src/gen/extensions.rs
new file mode 100644
index 0000000..bfd4267
--- /dev/null
+++ b/src/gen/extensions.rs
@@ -0,0 +1,133 @@
+use protobuf::descriptor::*;
+use protobuf::reflect::FileDescriptor;
+use protobuf_parse::ProtobufAbsPath;
+
+use crate::customize::ctx::CustomizeElemCtx;
+use crate::customize::Customize;
+use crate::gen::code_writer::CodeWriter;
+use crate::gen::field::rust_field_name_for_protobuf_field_name;
+use crate::gen::file_and_mod::FileAndMod;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::message::RustTypeMessage;
+use crate::gen::rust::ident_with_path::RustIdentWithPath;
+use crate::gen::rust::rel_path::RustRelativePath;
+use crate::gen::rust_types_values::*;
+use crate::gen::scope::RootScope;
+
+struct ExtGen<'a> {
+    file: &'a FileDescriptor,
+    root_scope: &'a RootScope<'a>,
+    field: &'a FieldDescriptorProto,
+    customize: Customize,
+}
+
+impl<'a> ExtGen<'a> {
+    fn extendee_rust_name(&self) -> RustIdentWithPath {
+        type_name_to_rust_relative(
+            &ProtobufAbsPath::from(self.field.extendee()),
+            &FileAndMod {
+                file: self.file.proto().name().to_owned(),
+                relative_mod: RustRelativePath::from("exts"),
+                customize: self.customize.clone(),
+            },
+            self.root_scope,
+        )
+    }
+
+    fn repeated(&self) -> bool {
+        match self.field.label() {
+            field_descriptor_proto::Label::LABEL_REPEATED => true,
+            field_descriptor_proto::Label::LABEL_OPTIONAL => false,
+            field_descriptor_proto::Label::LABEL_REQUIRED => {
+                panic!("required ext field: {}", self.field.name())
+            }
+        }
+    }
+
+    fn return_type_gen(&self) -> ProtobufTypeGen {
+        if self.field.has_type_name() {
+            let rust_name_relative = type_name_to_rust_relative(
+                &ProtobufAbsPath::from(self.field.type_name()),
+                &FileAndMod {
+                    file: self.file.proto().name().to_owned(),
+                    relative_mod: RustRelativePath::from("exts"),
+                    customize: self.customize.clone(),
+                },
+                self.root_scope,
+            );
+            match self.field.type_() {
+                field_descriptor_proto::Type::TYPE_MESSAGE => {
+                    ProtobufTypeGen::Message(RustTypeMessage(rust_name_relative))
+                }
+                field_descriptor_proto::Type::TYPE_ENUM => {
+                    ProtobufTypeGen::EnumOrUnknown(rust_name_relative)
+                }
+                t => panic!("unknown type: {:?}", t),
+            }
+        } else {
+            ProtobufTypeGen::Primitive(self.field.type_(), PrimitiveTypeVariant::Default)
+        }
+    }
+
+    fn write(&self, w: &mut CodeWriter) {
+        let suffix = if self.repeated() {
+            "ExtFieldRepeated"
+        } else {
+            "ExtFieldOptional"
+        };
+        let field_type = format!(
+            "{protobuf_crate}::ext::{suffix}",
+            protobuf_crate = protobuf_crate_path(&self.customize)
+        );
+        w.pub_const(
+            &rust_field_name_for_protobuf_field_name(self.field.name()).to_string(),
+            &format!(
+                "{field_type}<{extendee}, {rust_type}>",
+                extendee=self.extendee_rust_name(),
+                rust_type=self.return_type_gen().protobuf_value(&self.customize),
+            ),
+            &format!(
+                "{field_type}::new({field_number}, {protobuf_crate}::descriptor::field_descriptor_proto::Type::{t:?})",
+                field_number=self.field.number(),
+                protobuf_crate = protobuf_crate_path(&self.customize),
+                t=self.field.type_(),
+            ),
+        );
+    }
+}
+
+pub(crate) fn write_extensions(
+    file: &FileDescriptor,
+    root_scope: &RootScope,
+    w: &mut CodeWriter,
+    customize: &CustomizeElemCtx,
+) {
+    if file.proto().extension.is_empty() {
+        return;
+    }
+
+    if customize.for_elem.lite_runtime.unwrap_or(false) {
+        w.write_line("");
+        w.comment("Extension generation with lite runtime is not supported");
+        return;
+    }
+
+    w.write_line("");
+    w.write_line("/// Extension fields");
+    w.pub_mod("exts", |w| {
+        for field in &file.proto().extension {
+            if field.type_() == field_descriptor_proto::Type::TYPE_GROUP {
+                continue;
+            }
+
+            w.write_line("");
+            ExtGen {
+                file,
+                root_scope,
+                field,
+                customize: customize.for_elem.clone(),
+            }
+            .write(w);
+        }
+    });
+}
diff --git a/src/gen/field/accessor.rs b/src/gen/field/accessor.rs
new file mode 100644
index 0000000..26f0ef4
--- /dev/null
+++ b/src/gen/field/accessor.rs
@@ -0,0 +1,241 @@
+use crate::gen::code_writer::CodeWriter;
+use crate::gen::field::elem::FieldElem;
+use crate::gen::field::elem::FieldElemEnum;
+use crate::gen::field::option_kind::OptionKind;
+use crate::gen::field::repeated::RepeatedField;
+use crate::gen::field::repeated::RepeatedFieldKind;
+use crate::gen::field::singular::SingularField;
+use crate::gen::field::singular::SingularFieldFlag;
+use crate::gen::field::FieldGen;
+use crate::gen::field::FieldKind;
+use crate::gen::field::MapField;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::oneof::OneofField;
+use crate::gen::rust_types_values::RustType;
+use crate::gen::scope::WithScope;
+
+struct AccessorFn {
+    name: String,
+    // function type params after first underscore
+    type_params: Vec<String>,
+    callback_params: Vec<String>,
+}
+
+impl AccessorFn {
+    fn sig(&self) -> String {
+        let mut s = self.name.clone();
+        s.push_str("::<_");
+        for p in &self.type_params {
+            s.push_str(", ");
+            s.push_str(&p);
+        }
+        s.push_str(">");
+        s
+    }
+}
+
+impl FieldGen<'_> {
+    fn make_accessor_fns_lambda(&self) -> Vec<String> {
+        let message = self.proto_field.message.rust_name();
+        vec![
+            format!("|m: &{}| {{ &m.{} }}", message, self.rust_name),
+            format!("|m: &mut {}| {{ &mut m.{} }}", message, self.rust_name),
+        ]
+    }
+
+    fn make_accessor_fns_has_get_set(&self) -> Vec<String> {
+        let message = self.proto_field.message.rust_name();
+        vec![
+            format!("{}::{}", message, self.has_name()),
+            format!("{}::{}", message, self.rust_name),
+            format!("{}::{}", message, self.set_name()),
+        ]
+    }
+
+    fn make_accessor_fns_has_get_mut_set(&self) -> Vec<String> {
+        let message = self.proto_field.message.rust_name();
+        vec![
+            format!("{}::{}", message, self.has_name()),
+            format!("{}::{}", message, self.rust_name),
+            format!("{}::{}", message, self.mut_name()),
+            format!("{}::{}", message, self.set_name()),
+        ]
+    }
+
+    fn accessor_fn_map(&self, map_field: &MapField) -> AccessorFn {
+        let MapField { .. } = map_field;
+        AccessorFn {
+            name: "make_map_simpler_accessor".to_owned(),
+            type_params: vec![format!("_"), format!("_")],
+            callback_params: self.make_accessor_fns_lambda(),
+        }
+    }
+
+    fn accessor_fn_repeated(&self, repeated_field: &RepeatedField) -> AccessorFn {
+        let RepeatedField { .. } = repeated_field;
+        let name = match repeated_field.kind() {
+            RepeatedFieldKind::Vec => "make_vec_simpler_accessor",
+        };
+        AccessorFn {
+            name: name.to_owned(),
+            type_params: vec![format!("_")],
+            callback_params: self.make_accessor_fns_lambda(),
+        }
+    }
+
+    fn accessor_fn_oneof_enum(&self, oneof: &OneofField, en: &FieldElemEnum) -> AccessorFn {
+        let message = self.proto_field.message.rust_name();
+
+        let variant_path = oneof.variant_path(&self.proto_field.message.scope.rust_path_to_file());
+
+        let getter = CodeWriter::with_no_error(|w| {
+            w.expr_block(
+                &format!(
+                    "|message: &{}| match &message.{}",
+                    message, oneof.oneof_field_name
+                ),
+                |w| {
+                    w.case_expr(
+                        &format!("::std::option::Option::Some({}(e))", variant_path),
+                        "::std::option::Option::Some(*e)",
+                    );
+                    w.case_expr("_", "::std::option::Option::None");
+                },
+            );
+        });
+
+        let setter = CodeWriter::with_no_error(|w| {
+            w.expr_block(
+                &format!(
+                    "|message: &mut {}, e: {}::EnumOrUnknown<{}>|",
+                    message,
+                    protobuf_crate_path(&self.customize),
+                    en.enum_rust_type(&self.file_and_mod())
+                        .to_code(&self.customize)
+                ),
+                |w| {
+                    w.write_line(&format!(
+                        "message.{} = ::std::option::Option::Some({}(e));",
+                        oneof.oneof_field_name, variant_path
+                    ));
+                },
+            )
+        });
+
+        let default = self.xxx_default_value_rust();
+
+        AccessorFn {
+            name: "make_oneof_enum_accessors".to_owned(),
+            type_params: vec![format!("_")],
+            callback_params: vec![getter, setter, default],
+        }
+    }
+
+    fn accessor_fn_singular_without_flag(&self, _elem: &FieldElem) -> AccessorFn {
+        AccessorFn {
+            name: "make_simpler_field_accessor".to_owned(),
+            type_params: vec![format!("_")],
+            callback_params: self.make_accessor_fns_lambda(),
+        }
+    }
+
+    fn accessor_fn_singular_with_flag(
+        &self,
+        elem: &FieldElem,
+        _option_kind: OptionKind,
+    ) -> AccessorFn {
+        match elem {
+            FieldElem::Message(m) => AccessorFn {
+                name: "make_message_field_accessor".to_owned(),
+                type_params: vec![format!("{}", m.rust_name_relative(&self.file_and_mod()))],
+                callback_params: self.make_accessor_fns_lambda(),
+            },
+            FieldElem::Primitive(..) | FieldElem::Enum(..) => AccessorFn {
+                name: "make_option_accessor".to_owned(),
+                type_params: vec!["_".to_owned()],
+                callback_params: self.make_accessor_fns_lambda(),
+            },
+            FieldElem::Group => {
+                unreachable!("no accessor for group field");
+            }
+        }
+    }
+
+    fn accessor_fn_oneof(&self, oneof: &OneofField) -> AccessorFn {
+        let OneofField { ref elem, .. } = oneof;
+
+        let reference = self
+            .proto_field
+            .message
+            .scope
+            .file_and_mod(self.customize.clone());
+
+        if let FieldElem::Enum(en) = &oneof.elem {
+            return self.accessor_fn_oneof_enum(oneof, en);
+        }
+
+        if elem.is_copy() {
+            return AccessorFn {
+                name: "make_oneof_copy_has_get_set_simpler_accessors".to_owned(),
+                type_params: vec![format!("_")],
+                callback_params: self.make_accessor_fns_has_get_set(),
+            };
+        }
+
+        if let RustType::Message(name) = elem.rust_storage_elem_type(&reference) {
+            return AccessorFn {
+                name: "make_oneof_message_has_get_mut_set_accessor".to_owned(),
+                type_params: vec![format!("{}", name)],
+                callback_params: self.make_accessor_fns_has_get_mut_set(),
+            };
+        }
+
+        // string or bytes
+        AccessorFn {
+            name: "make_oneof_deref_has_get_set_simpler_accessor".to_owned(),
+            type_params: vec![format!("_")],
+            callback_params: self.make_accessor_fns_has_get_set(),
+        }
+    }
+
+    fn accessor_fn(&self) -> AccessorFn {
+        match self.kind {
+            FieldKind::Repeated(ref repeated_field) => self.accessor_fn_repeated(repeated_field),
+            FieldKind::Map(ref map_field) => self.accessor_fn_map(map_field),
+            FieldKind::Singular(SingularField {
+                ref elem,
+                flag: SingularFieldFlag::WithoutFlag,
+            }) => self.accessor_fn_singular_without_flag(elem),
+            FieldKind::Singular(SingularField {
+                ref elem,
+                flag: SingularFieldFlag::WithFlag { option_kind, .. },
+            }) => self.accessor_fn_singular_with_flag(elem, option_kind),
+            FieldKind::Oneof(ref oneof) => self.accessor_fn_oneof(oneof),
+        }
+    }
+
+    pub fn write_push_accessor(&self, fields_var: &str, w: &mut CodeWriter) {
+        let accessor_fn = self.accessor_fn();
+        w.write_line(&format!(
+            "{}.push({}::reflect::rt::v2::{}(",
+            fields_var,
+            protobuf_crate_path(&self.customize),
+            accessor_fn.sig()
+        ));
+        w.indented(|w| {
+            w.write_line(&format!("\"{}\",", self.proto_field.name()));
+            for callback in &accessor_fn.callback_params {
+                let callback_lines: Vec<&str> = callback.lines().collect();
+                for (i, callback_line) in callback_lines.iter().enumerate() {
+                    let comma = if i == callback_lines.len() - 1 {
+                        ","
+                    } else {
+                        ""
+                    };
+                    w.write_line(&format!("{}{}", callback_line, comma));
+                }
+            }
+        });
+        w.write_line("));");
+    }
+}
diff --git a/src/gen/field/elem.rs b/src/gen/field/elem.rs
new file mode 100644
index 0000000..fd06b4c
--- /dev/null
+++ b/src/gen/field/elem.rs
@@ -0,0 +1,319 @@
+use protobuf::descriptor::field_descriptor_proto::Type;
+use protobuf::reflect::RuntimeFieldType;
+use protobuf::rt::tag_size;
+use protobuf_parse::ProtobufAbsPath;
+
+use crate::gen::code_writer::CodeWriter;
+use crate::gen::field::type_ext::TypeExt;
+use crate::gen::file_and_mod::FileAndMod;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::message::RustTypeMessage;
+use crate::gen::rust::ident_with_path::RustIdentWithPath;
+use crate::gen::rust_types_values::message_or_enum_to_rust_relative;
+use crate::gen::rust_types_values::PrimitiveTypeVariant;
+use crate::gen::rust_types_values::RustType;
+use crate::gen::rust_types_values::RustValueTyped;
+use crate::gen::scope::EnumValueWithContext;
+use crate::gen::scope::FieldWithContext;
+use crate::gen::scope::MessageOrEnumWithScope;
+use crate::gen::scope::MessageWithScope;
+use crate::gen::scope::RootScope;
+use crate::Customize;
+
+#[derive(Clone, Debug)]
+pub(crate) struct FieldElemEnum<'a> {
+    /// Enum default value variant, either from proto or from enum definition
+    default_value: EnumValueWithContext<'a>,
+}
+
+impl<'a> FieldElemEnum<'a> {
+    fn rust_name_relative(&self, reference: &FileAndMod) -> RustIdentWithPath {
+        message_or_enum_to_rust_relative(&self.default_value.en, reference)
+    }
+
+    pub(crate) fn enum_rust_type(&self, reference: &FileAndMod) -> RustType {
+        RustType::Enum(
+            self.rust_name_relative(reference),
+            self.default_value.rust_name(),
+            self.default_value.proto.proto().number(),
+        )
+    }
+
+    fn enum_or_unknown_rust_type(&self, reference: &FileAndMod) -> RustType {
+        RustType::EnumOrUnknown(
+            self.rust_name_relative(reference),
+            self.default_value.rust_name(),
+            self.default_value.proto.proto().number(),
+        )
+    }
+
+    pub(crate) fn default_value_rust_expr(&self, reference: &FileAndMod) -> RustIdentWithPath {
+        self.rust_name_relative(reference)
+            .to_path()
+            .with_ident(self.default_value.rust_name())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct FieldElemMessage<'a> {
+    pub message: MessageWithScope<'a>,
+}
+
+impl<'a> FieldElemMessage<'a> {
+    pub(crate) fn rust_name_relative(&self, reference: &FileAndMod) -> RustTypeMessage {
+        RustTypeMessage(message_or_enum_to_rust_relative(&self.message, reference))
+    }
+
+    fn rust_type(&self, reference: &FileAndMod) -> RustType {
+        RustType::Message(self.rust_name_relative(reference))
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) enum FieldElem<'a> {
+    Primitive(Type, PrimitiveTypeVariant),
+    Message(FieldElemMessage<'a>),
+    Enum(FieldElemEnum<'a>),
+    Group,
+}
+
+pub(crate) enum HowToGetMessageSize {
+    Compute,
+    GetCached,
+}
+
+impl<'a> FieldElem<'a> {
+    pub(crate) fn proto_type(&self) -> Type {
+        match *self {
+            FieldElem::Primitive(t, ..) => t,
+            FieldElem::Group => Type::TYPE_GROUP,
+            FieldElem::Message(..) => Type::TYPE_MESSAGE,
+            FieldElem::Enum(..) => Type::TYPE_ENUM,
+        }
+    }
+
+    pub(crate) fn is_copy(&self) -> bool {
+        self.proto_type().is_copy()
+    }
+
+    pub(crate) fn rust_storage_elem_type(&self, reference: &FileAndMod) -> RustType {
+        match *self {
+            FieldElem::Primitive(t, PrimitiveTypeVariant::Default) => t.rust_type(),
+            FieldElem::Primitive(Type::TYPE_STRING, PrimitiveTypeVariant::TokioBytes) => {
+                RustType::Chars
+            }
+            FieldElem::Primitive(Type::TYPE_BYTES, PrimitiveTypeVariant::TokioBytes) => {
+                RustType::Bytes
+            }
+            FieldElem::Primitive(.., PrimitiveTypeVariant::TokioBytes) => unreachable!(),
+            FieldElem::Group => RustType::Group,
+            FieldElem::Message(ref m) => m.rust_type(reference),
+            FieldElem::Enum(ref en) => en.enum_or_unknown_rust_type(reference),
+        }
+    }
+
+    // Type of set_xxx function parameter type for singular fields
+    pub(crate) fn rust_set_xxx_param_type(&self, reference: &FileAndMod) -> RustType {
+        if let FieldElem::Enum(ref en) = *self {
+            en.enum_rust_type(reference)
+        } else {
+            self.rust_storage_elem_type(reference)
+        }
+    }
+
+    pub(crate) fn primitive_type_variant(&self) -> PrimitiveTypeVariant {
+        match self {
+            &FieldElem::Primitive(_, v) => v,
+            _ => PrimitiveTypeVariant::Default,
+        }
+    }
+
+    pub(crate) fn singular_field_size(
+        &self,
+        field_number: u32,
+        var: &RustValueTyped,
+        customize: &Customize,
+    ) -> String {
+        let tag_size = tag_size(field_number);
+        match self.proto_type().encoded_size() {
+            Some(data_size) => format!("{tag_size} + {data_size}"),
+            None => match self.proto_type() {
+                Type::TYPE_MESSAGE => panic!("not a single-liner"),
+                // We are not inlining `bytes_size` here,
+                // assuming the compiler is smart enough to do it for us.
+                // https://rust.godbolt.org/z/GrKa5zxq6
+                Type::TYPE_BYTES => format!(
+                    "{}::rt::bytes_size({}, &{})",
+                    protobuf_crate_path(customize),
+                    field_number,
+                    var.value
+                ),
+                Type::TYPE_STRING => format!(
+                    "{}::rt::string_size({}, &{})",
+                    protobuf_crate_path(customize),
+                    field_number,
+                    var.value
+                ),
+                Type::TYPE_ENUM => {
+                    format!(
+                        "{}::rt::int32_size({}, {}.value())",
+                        protobuf_crate_path(customize),
+                        field_number,
+                        var.value,
+                    )
+                }
+                _ => {
+                    let param_type = match &var.rust_type {
+                        RustType::Ref(t) => (**t).clone(),
+                        t => t.clone(),
+                    };
+                    let f = match self.proto_type() {
+                        Type::TYPE_SINT32 => "sint32_size",
+                        Type::TYPE_SINT64 => "sint64_size",
+                        Type::TYPE_INT32 => "int32_size",
+                        Type::TYPE_INT64 => "int64_size",
+                        Type::TYPE_UINT32 => "uint32_size",
+                        Type::TYPE_UINT64 => "uint64_size",
+                        t => unreachable!("unexpected type: {:?}", t),
+                    };
+                    format!(
+                        "{}::rt::{f}({}, {})",
+                        protobuf_crate_path(customize),
+                        field_number,
+                        var.into_type(param_type, customize).value
+                    )
+                }
+            },
+        }
+    }
+
+    pub(crate) fn write_element_size(
+        &self,
+        field_number: u32,
+        item_var: &RustValueTyped,
+        how_to_get_message_size: HowToGetMessageSize,
+        sum_var: &str,
+        customize: &Customize,
+        w: &mut CodeWriter,
+    ) {
+        let tag_size = tag_size(field_number);
+        match self.proto_type() {
+            Type::TYPE_MESSAGE => {
+                match how_to_get_message_size {
+                    HowToGetMessageSize::Compute => {
+                        w.write_line(&format!("let len = {}.compute_size();", item_var.value))
+                    }
+                    HowToGetMessageSize::GetCached => w.write_line(&format!(
+                        "let len = {}.cached_size() as u64;",
+                        item_var.value
+                    )),
+                }
+                w.write_line(&format!(
+                    "{sum_var} += {tag_size} + {}::rt::compute_raw_varint64_size(len) + len;",
+                    protobuf_crate_path(customize),
+                ));
+            }
+            _ => {
+                w.write_line(&format!(
+                    "{sum_var} += {};",
+                    self.singular_field_size(field_number, item_var, customize)
+                ));
+            }
+        }
+    }
+
+    pub(crate) fn write_write_element(
+        &self,
+        field_number: u32,
+        v: &RustValueTyped,
+        file_and_mod: &FileAndMod,
+        customize: &Customize,
+        os: &str,
+        w: &mut CodeWriter,
+    ) {
+        match self.proto_type() {
+            Type::TYPE_MESSAGE => {
+                let param_type = RustType::Ref(Box::new(self.rust_storage_elem_type(file_and_mod)));
+
+                w.write_line(&format!(
+                    "{}::rt::write_message_field_with_cached_size({}, {}, {})?;",
+                    protobuf_crate_path(customize),
+                    field_number,
+                    v.into_type(param_type, customize).value,
+                    os
+                ));
+            }
+            _ => {
+                let param_type = self.proto_type().os_write_fn_param_type();
+                let os_write_fn_suffix = self.proto_type().protobuf_name();
+                w.write_line(&format!(
+                    "{}.write_{}({}, {})?;",
+                    os,
+                    os_write_fn_suffix,
+                    field_number,
+                    v.into_type(param_type, customize).value
+                ));
+            }
+        }
+    }
+
+    pub(crate) fn read_one_liner(&self) -> String {
+        format!(
+            "{}?",
+            self.proto_type().read("is", self.primitive_type_variant())
+        )
+    }
+}
+
+pub(crate) fn field_elem<'a>(
+    field: &FieldWithContext,
+    root_scope: &'a RootScope<'a>,
+    customize: &Customize,
+) -> FieldElem<'a> {
+    if let RuntimeFieldType::Map(..) = field.field.runtime_field_type() {
+        unreachable!();
+    }
+
+    if field.field.proto().type_() == Type::TYPE_GROUP {
+        FieldElem::Group
+    } else if field.field.proto().has_type_name() {
+        let message_or_enum = root_scope
+            .find_message_or_enum(&ProtobufAbsPath::from(field.field.proto().type_name()));
+        match (field.field.proto().type_(), message_or_enum) {
+            (Type::TYPE_MESSAGE, MessageOrEnumWithScope::Message(message)) => {
+                FieldElem::Message(FieldElemMessage {
+                    message: message.clone(),
+                })
+            }
+            (Type::TYPE_ENUM, MessageOrEnumWithScope::Enum(enum_with_scope)) => {
+                let default_value = if field.field.proto().has_default_value() {
+                    enum_with_scope.value_by_name(field.field.proto().default_value())
+                } else {
+                    enum_with_scope.values()[0].clone()
+                };
+                FieldElem::Enum(FieldElemEnum { default_value })
+            }
+            _ => panic!("unknown named type: {:?}", field.field.proto().type_()),
+        }
+    } else if field.field.proto().has_type() {
+        let tokio_for_bytes = customize.tokio_bytes.unwrap_or(false);
+        let tokio_for_string = customize.tokio_bytes_for_string.unwrap_or(false);
+
+        let elem = match field.field.proto().type_() {
+            Type::TYPE_STRING if tokio_for_string => {
+                FieldElem::Primitive(Type::TYPE_STRING, PrimitiveTypeVariant::TokioBytes)
+            }
+            Type::TYPE_BYTES if tokio_for_bytes => {
+                FieldElem::Primitive(Type::TYPE_BYTES, PrimitiveTypeVariant::TokioBytes)
+            }
+            t => FieldElem::Primitive(t, PrimitiveTypeVariant::Default),
+        };
+
+        elem
+    } else {
+        panic!(
+            "neither type_name, nor field_type specified for field: {}",
+            field.field.name()
+        );
+    }
+}
diff --git a/src/gen/field/mod.rs b/src/gen/field/mod.rs
new file mode 100644
index 0000000..d6a5e44
--- /dev/null
+++ b/src/gen/field/mod.rs
@@ -0,0 +1,1850 @@
+mod accessor;
+pub(crate) mod elem;
+mod option_kind;
+mod repeated;
+mod singular;
+mod tag;
+pub(crate) mod type_ext;
+
+use protobuf::descriptor::field_descriptor_proto::Type;
+use protobuf::descriptor::*;
+use protobuf::reflect::ReflectValueRef;
+use protobuf::reflect::RuntimeFieldType;
+use protobuf::reflect::Syntax;
+use protobuf::rt;
+use protobuf::rt::WireType;
+use protobuf_parse::camel_case;
+use protobuf_parse::ProtobufAbsPath;
+
+use crate::customize::ctx::CustomizeElemCtx;
+use crate::customize::rustproto_proto::customize_from_rustproto_for_field;
+use crate::customize::Customize;
+use crate::gen::code_writer::CodeWriter;
+use crate::gen::code_writer::Visibility;
+use crate::gen::field::elem::field_elem;
+use crate::gen::field::elem::FieldElem;
+use crate::gen::field::elem::FieldElemEnum;
+use crate::gen::field::elem::HowToGetMessageSize;
+use crate::gen::field::option_kind::OptionKind;
+use crate::gen::field::repeated::RepeatedField;
+use crate::gen::field::singular::SingularField;
+use crate::gen::field::singular::SingularFieldFlag;
+use crate::gen::field::tag::make_tag;
+use crate::gen::field::type_ext::TypeExt;
+use crate::gen::file_and_mod::FileAndMod;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::map::map_entry;
+use crate::gen::oneof::OneofField;
+use crate::gen::protoc_insertion_point::write_protoc_insertion_point_for_field;
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::quote::quote_escape_bytes;
+use crate::gen::rust::quote::quote_escape_str;
+use crate::gen::rust::snippets::EXPR_NONE;
+use crate::gen::rust_types_values::PrimitiveTypeVariant;
+use crate::gen::rust_types_values::RustType;
+use crate::gen::rust_types_values::RustValueTyped;
+use crate::gen::scope::FieldWithContext;
+use crate::gen::scope::MessageWithScope;
+use crate::gen::scope::RootScope;
+
+fn field_type_protobuf_name<'a>(field: &'a FieldDescriptorProto) -> &'a str {
+    if field.has_type_name() {
+        field.type_name()
+    } else {
+        field.type_().protobuf_name()
+    }
+}
+
+#[derive(Clone)]
+pub struct MapField<'a> {
+    _message: MessageWithScope<'a>,
+    key: FieldElem<'a>,
+    value: FieldElem<'a>,
+}
+
+#[derive(Clone)]
+pub(crate) enum FieldKind<'a> {
+    // optional or required
+    Singular(SingularField<'a>),
+    // repeated except map
+    Repeated(RepeatedField<'a>),
+    // map
+    Map(MapField<'a>),
+    // part of oneof
+    Oneof(OneofField<'a>),
+}
+
+impl<'a> FieldKind<'a> {
+    pub(crate) fn default(
+        &self,
+        customize: &Customize,
+        reference: &FileAndMod,
+        const_expr: bool,
+    ) -> String {
+        match self {
+            FieldKind::Singular(s) => s.default_value(customize, reference, const_expr),
+            FieldKind::Repeated(r) => r.default(),
+            FieldKind::Oneof(..) => EXPR_NONE.to_owned(),
+            FieldKind::Map(..) => panic!("map fields cannot have field value"),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) enum SingularOrOneofField<'a> {
+    Singular(SingularField<'a>),
+    Oneof(OneofField<'a>),
+}
+
+impl<'a> SingularOrOneofField<'a> {
+    fn elem(&self) -> &FieldElem {
+        match self {
+            SingularOrOneofField::Singular(SingularField { ref elem, .. }) => elem,
+            SingularOrOneofField::Oneof(OneofField { ref elem, .. }) => elem,
+        }
+    }
+
+    // Type of `xxx` function for singular type.
+    pub(crate) fn getter_return_type(&self, reference: &FileAndMod) -> RustType {
+        let elem = self.elem();
+        if let FieldElem::Enum(ref en) = elem {
+            en.enum_rust_type(reference)
+        } else if elem.is_copy() {
+            elem.rust_storage_elem_type(reference)
+        } else {
+            elem.rust_storage_elem_type(reference).ref_type()
+        }
+    }
+}
+
+// Representation of map entry: key type and value type
+#[derive(Clone, Debug)]
+pub struct EntryKeyValue<'a>(FieldElem<'a>, FieldElem<'a>);
+
+#[derive(Clone)]
+pub(crate) struct FieldGen<'a> {
+    syntax: Syntax,
+    pub proto_field: FieldWithContext<'a>,
+    // field name in generated code
+    pub rust_name: RustIdent,
+    pub proto_type: Type,
+    wire_type: WireType,
+    pub kind: FieldKind<'a>,
+    pub generate_accessors: bool,
+    pub generate_getter: bool,
+    customize: Customize,
+    path: Vec<i32>,
+    info: Option<&'a SourceCodeInfo>,
+}
+
+impl<'a> FieldGen<'a> {
+    pub(crate) fn parse(
+        field: FieldWithContext<'a>,
+        root_scope: &'a RootScope<'a>,
+        parent_customize: &CustomizeElemCtx<'a>,
+        path: Vec<i32>,
+        info: Option<&'a SourceCodeInfo>,
+    ) -> anyhow::Result<FieldGen<'a>> {
+        let customize = parent_customize
+            .child(
+                &customize_from_rustproto_for_field(field.field.proto().options.get_or_default()),
+                &field.field,
+            )
+            .for_elem;
+
+        let syntax = field.message.scope.file_scope.syntax();
+
+        let field_may_have_custom_default_value = syntax == Syntax::Proto2
+            && field.field.proto().label() != field_descriptor_proto::Label::LABEL_REPEATED
+            && field.field.proto().type_() != Type::TYPE_MESSAGE;
+
+        let generate_accessors = customize
+            .generate_accessors
+            .unwrap_or(field_may_have_custom_default_value)
+            || field.is_oneof();
+
+        let default_generate_getter = generate_accessors || field_may_have_custom_default_value;
+        let generate_getter =
+            customize.generate_getter.unwrap_or(default_generate_getter) || field.is_oneof();
+
+        let kind = match field.field.runtime_field_type() {
+            RuntimeFieldType::Map(..) => {
+                let message = root_scope
+                    .find_message(&ProtobufAbsPath::from(field.field.proto().type_name()));
+
+                let (key, value) = map_entry(&message).unwrap();
+
+                let key = field_elem(&key, root_scope, &customize);
+                let value = field_elem(&value, root_scope, &customize);
+
+                FieldKind::Map(MapField {
+                    _message: message,
+                    key,
+                    value,
+                })
+            }
+            RuntimeFieldType::Repeated(..) => {
+                let elem = field_elem(&field, root_scope, &customize);
+
+                FieldKind::Repeated(RepeatedField {
+                    elem,
+                    packed: field.field.proto().options.get_or_default().packed(),
+                })
+            }
+            RuntimeFieldType::Singular(..) => {
+                let elem = field_elem(&field, root_scope, &customize);
+
+                if let Some(oneof) = field.oneof() {
+                    FieldKind::Oneof(OneofField::parse(&oneof, &field.field, elem, root_scope))
+                } else {
+                    let flag = if field.message.scope.file_scope.syntax() == Syntax::Proto3
+                        && field.field.proto().type_() != field_descriptor_proto::Type::TYPE_MESSAGE
+                        && !field.field.proto().proto3_optional()
+                    {
+                        SingularFieldFlag::WithoutFlag
+                    } else {
+                        let required = field.field.proto().label()
+                            == field_descriptor_proto::Label::LABEL_REQUIRED;
+                        let option_kind = match field.field.proto().type_() {
+                            field_descriptor_proto::Type::TYPE_MESSAGE => OptionKind::MessageField,
+                            _ => OptionKind::Option,
+                        };
+
+                        SingularFieldFlag::WithFlag {
+                            required,
+                            option_kind,
+                        }
+                    };
+                    FieldKind::Singular(SingularField { elem, flag })
+                }
+            }
+        };
+
+        Ok(FieldGen {
+            syntax: field.message.message.file_descriptor().syntax(),
+            rust_name: rust_field_name_for_protobuf_field_name(&field.field.name()),
+            proto_type: field.field.proto().type_(),
+            wire_type: WireType::for_type(field.field.proto().type_()),
+            proto_field: field,
+            kind,
+            generate_accessors,
+            generate_getter,
+            customize,
+            path,
+            info,
+        })
+    }
+
+    // for message level
+    fn file_and_mod(&self) -> FileAndMod {
+        self.proto_field
+            .message
+            .scope
+            .file_and_mod(self.customize.clone())
+    }
+
+    fn tag_size(&self) -> u32 {
+        rt::tag_size(self.proto_field.number() as u32) as u32
+    }
+
+    fn is_singular(&self) -> bool {
+        match self.kind {
+            FieldKind::Singular(..) => true,
+            _ => false,
+        }
+    }
+
+    fn is_repeated_packed(&self) -> bool {
+        match self.kind {
+            FieldKind::Repeated(RepeatedField { packed: true, .. }) => true,
+            _ => false,
+        }
+    }
+
+    pub(crate) fn elem(&self) -> &FieldElem {
+        match self.kind {
+            FieldKind::Singular(SingularField { ref elem, .. }) => &elem,
+            FieldKind::Repeated(RepeatedField { ref elem, .. }) => &elem,
+            FieldKind::Oneof(OneofField { ref elem, .. }) => &elem,
+            FieldKind::Map(..) => unreachable!(),
+        }
+    }
+
+    // type of field in struct
+    pub(crate) fn full_storage_type(&self, reference: &FileAndMod) -> RustType {
+        match self.kind {
+            FieldKind::Repeated(ref repeated) => repeated.rust_type(reference),
+            FieldKind::Map(MapField {
+                ref key, ref value, ..
+            }) => RustType::HashMap(
+                Box::new(key.rust_storage_elem_type(reference)),
+                Box::new(value.rust_storage_elem_type(reference)),
+            ),
+            FieldKind::Singular(ref singular) => singular.rust_storage_type(reference),
+            FieldKind::Oneof(..) => unreachable!(),
+        }
+    }
+
+    // type of `v` in `for v in field`
+    fn full_storage_iter_elem_type(&self, reference: &FileAndMod) -> RustType {
+        if let FieldKind::Oneof(ref oneof) = self.kind {
+            oneof.elem.rust_storage_elem_type(reference)
+        } else {
+            self.full_storage_type(reference).iter_elem_type()
+        }
+    }
+
+    // suffix `xxx` as in `os.write_xxx_no_tag(..)`
+    fn os_write_fn_suffix(&self) -> &str {
+        self.proto_type.protobuf_name()
+    }
+
+    fn os_write_fn_suffix_with_unknown_for_enum(&self) -> &str {
+        if self.proto_type == field_descriptor_proto::Type::TYPE_ENUM {
+            "enum_or_unknown"
+        } else {
+            self.os_write_fn_suffix()
+        }
+    }
+
+    // for field `foo`, type of param of `fn set_foo(..)`
+    fn set_xxx_param_type(&self, reference: &FileAndMod) -> RustType {
+        match self.kind {
+            FieldKind::Singular(SingularField { ref elem, .. })
+            | FieldKind::Oneof(OneofField { ref elem, .. }) => {
+                elem.rust_set_xxx_param_type(reference)
+            }
+            FieldKind::Repeated(..) | FieldKind::Map(..) => self.full_storage_type(reference),
+        }
+    }
+
+    // for field `foo`, return type if `fn take_foo(..)`
+    fn take_xxx_return_type(&self, reference: &FileAndMod) -> RustType {
+        self.set_xxx_param_type(reference)
+    }
+
+    // for field `foo`, return type of `fn mut_foo(..)`
+    fn mut_xxx_return_type(&self, reference: &FileAndMod) -> RustType {
+        RustType::Ref(Box::new(match self.kind {
+            FieldKind::Singular(SingularField { ref elem, .. })
+            | FieldKind::Oneof(OneofField { ref elem, .. }) => {
+                elem.rust_storage_elem_type(reference)
+            }
+            FieldKind::Repeated(..) | FieldKind::Map(..) => self.full_storage_type(reference),
+        }))
+    }
+
+    // for field `foo`, return type of `fn foo(..)`
+    fn getter_return_type(&self) -> RustType {
+        let reference = self
+            .proto_field
+            .message
+            .scope
+            .file_and_mod(self.customize.clone());
+        match &self.kind {
+            FieldKind::Singular(s) => {
+                SingularOrOneofField::Singular(s.clone()).getter_return_type(&reference)
+            }
+            FieldKind::Oneof(o) => {
+                SingularOrOneofField::Oneof(o.clone()).getter_return_type(&reference)
+            }
+            FieldKind::Repeated(RepeatedField { ref elem, .. }) => RustType::Ref(Box::new(
+                RustType::Slice(Box::new(elem.rust_storage_elem_type(&reference))),
+            )),
+            FieldKind::Map(..) => RustType::Ref(Box::new(self.full_storage_type(&reference))),
+        }
+    }
+
+    // elem data is not stored in heap
+    pub(crate) fn elem_type_is_copy(&self) -> bool {
+        self.proto_type.is_copy()
+    }
+
+    fn defaut_value_from_proto_float(f: f64, type_name: &str) -> String {
+        if f.is_nan() {
+            format!("::std::{}::NAN", type_name)
+        } else if f.is_infinite() {
+            if f > 0.0 {
+                format!("::std::{}::INFINITY", type_name)
+            } else {
+                format!("::std::{}::NEG_INFINITY", type_name)
+            }
+        } else {
+            format!("{:?}{}", f, type_name)
+        }
+    }
+
+    fn singular_or_oneof_default_value_from_proto(&self, elem: &FieldElem) -> Option<String> {
+        if !self.proto_field.field.proto().has_default_value() {
+            return None;
+        }
+
+        let default_value = self.proto_field.field.singular_default_value();
+        Some(match default_value {
+            ReflectValueRef::Bool(b) => format!("{}", b),
+            ReflectValueRef::I32(v) => format!("{}i32", v),
+            ReflectValueRef::I64(v) => format!("{}i64", v),
+            ReflectValueRef::U32(v) => format!("{}u32", v),
+            ReflectValueRef::U64(v) => format!("{}u64", v),
+            ReflectValueRef::String(v) => quote_escape_str(v),
+            ReflectValueRef::Bytes(v) => quote_escape_bytes(v),
+            ReflectValueRef::F32(v) => Self::defaut_value_from_proto_float(v as f64, "f32"),
+            ReflectValueRef::F64(v) => Self::defaut_value_from_proto_float(v as f64, "f64"),
+            ReflectValueRef::Enum(_e, _v) => {
+                if let &FieldElem::Enum(ref e) = elem {
+                    format!("{}", e.default_value_rust_expr(&self.file_and_mod()))
+                } else {
+                    unreachable!()
+                }
+            }
+            t => panic!("default value is not implemented for type: {:?}", t),
+        })
+    }
+
+    fn default_value_from_proto(&self) -> Option<String> {
+        match self.kind {
+            FieldKind::Oneof(OneofField { ref elem, .. })
+            | FieldKind::Singular(SingularField { ref elem, .. }) => {
+                self.singular_or_oneof_default_value_from_proto(elem)
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn default_value_from_proto_typed(&self) -> Option<RustValueTyped> {
+        self.default_value_from_proto().map(|v| {
+            let default_value_type = match self.proto_type {
+                field_descriptor_proto::Type::TYPE_STRING => RustType::Ref(Box::new(RustType::Str)),
+                field_descriptor_proto::Type::TYPE_BYTES => {
+                    RustType::Ref(Box::new(RustType::Slice(Box::new(RustType::u8()))))
+                }
+                _ => self.full_storage_iter_elem_type(
+                    &self
+                        .proto_field
+                        .message
+                        .scope
+                        .file_and_mod(self.customize.clone()),
+                ),
+            };
+
+            RustValueTyped {
+                value: v,
+                rust_type: default_value_type,
+            }
+        })
+    }
+
+    // default value to be returned from `fn xxx` for field `xxx`.
+    fn xxx_default_value_rust(&self) -> String {
+        match self.kind {
+            FieldKind::Singular(..) | FieldKind::Oneof(..) => {
+                self.default_value_from_proto().unwrap_or_else(|| {
+                    self.getter_return_type()
+                        .default_value(&self.customize, false)
+                })
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    // default to be assigned to field
+    fn element_default_value_rust(&self) -> RustValueTyped {
+        match self.kind {
+            FieldKind::Singular(..) | FieldKind::Oneof(..) => {
+                self.default_value_from_proto_typed().unwrap_or_else(|| {
+                    self.elem()
+                        .rust_storage_elem_type(
+                            &self
+                                .proto_field
+                                .message
+                                .scope
+                                .file_and_mod(self.customize.clone()),
+                        )
+                        .default_value_typed(&self.customize, false)
+                })
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    pub(crate) fn reconstruct_def(&self) -> String {
+        let prefix = match (self.proto_field.field.proto().label(), self.syntax) {
+            (field_descriptor_proto::Label::LABEL_REPEATED, _) => "repeated ",
+            (_, Syntax::Proto3) => "",
+            (field_descriptor_proto::Label::LABEL_OPTIONAL, _) => "optional ",
+            (field_descriptor_proto::Label::LABEL_REQUIRED, _) => "required ",
+        };
+        format!(
+            "{}{} {} = {}",
+            prefix,
+            field_type_protobuf_name(self.proto_field.field.proto()),
+            self.proto_field.name(),
+            self.proto_field.number()
+        )
+    }
+
+    pub(crate) fn write_clear(&self, w: &mut CodeWriter) {
+        match self.kind {
+            FieldKind::Oneof(ref o) => {
+                w.write_line(&format!(
+                    "self.{} = ::std::option::Option::None;",
+                    o.oneof_field_name
+                ));
+            }
+            _ => {
+                let clear_expr = self
+                    .full_storage_type(
+                        &self
+                            .proto_field
+                            .message
+                            .scope
+                            .file_and_mod(self.customize.clone()),
+                    )
+                    .clear(&self.self_field(), &self.customize);
+                w.write_line(&format!("{};", clear_expr));
+            }
+        }
+    }
+
+    // output code that writes single element to stream
+    pub(crate) fn write_write_element(
+        &self,
+        elem: &FieldElem,
+        w: &mut CodeWriter,
+        os: &str,
+        v: &RustValueTyped,
+    ) {
+        assert!(!self.is_repeated_packed());
+
+        elem.write_write_element(
+            self.proto_field.number() as u32,
+            v,
+            &self.file_and_mod(),
+            &self.customize,
+            os,
+            w,
+        );
+    }
+
+    fn self_field(&self) -> String {
+        format!("self.{}", self.rust_name)
+    }
+
+    fn self_field_is_some(&self) -> String {
+        assert!(self.is_singular());
+        format!("{}.is_some()", self.self_field())
+    }
+
+    fn self_field_is_none(&self) -> String {
+        assert!(self.is_singular());
+        format!("{}.is_none()", self.self_field())
+    }
+
+    // field data viewed as Option
+    fn self_field_as_option(&self, elem: &FieldElem, option_kind: OptionKind) -> RustValueTyped {
+        match self.full_storage_type(
+            &self
+                .proto_field
+                .message
+                .scope
+                .file_and_mod(self.customize.clone()),
+        ) {
+            RustType::Option(ref e) if e.is_copy() => {
+                return RustType::Option(e.clone()).value(self.self_field());
+            }
+            _ => {}
+        };
+
+        let as_option_type = option_kind.as_ref_type(
+            elem.rust_storage_elem_type(
+                &self
+                    .proto_field
+                    .message
+                    .scope
+                    .file_and_mod(self.customize.clone()),
+            ),
+        );
+
+        as_option_type.value(format!("{}.as_ref()", self.self_field()))
+    }
+
+    pub(crate) fn write_struct_field(&self, w: &mut CodeWriter) {
+        if self.proto_type == field_descriptor_proto::Type::TYPE_GROUP {
+            w.comment(&format!("{}: <group>", &self.rust_name));
+        } else {
+            w.all_documentation(self.info, &self.path);
+
+            write_protoc_insertion_point_for_field(w, &self.customize, &self.proto_field.field);
+            w.field_decl_vis(
+                Visibility::Public,
+                &self.rust_name.to_string(),
+                &self
+                    .full_storage_type(
+                        &self
+                            .proto_field
+                            .message
+                            .scope
+                            .file_and_mod(self.customize.clone()),
+                    )
+                    .to_code(&self.customize),
+            );
+        }
+    }
+
+    fn write_if_let_self_field_is_some<F>(&self, s: &SingularField, w: &mut CodeWriter, cb: F)
+    where
+        F: Fn(&RustValueTyped, &mut CodeWriter),
+    {
+        match s {
+            SingularField {
+                flag: SingularFieldFlag::WithFlag { option_kind, .. },
+                ref elem,
+            } => {
+                let var = "v";
+                let ref_prefix = match elem
+                    .rust_storage_elem_type(
+                        &self
+                            .proto_field
+                            .message
+                            .scope
+                            .file_and_mod(self.customize.clone()),
+                    )
+                    .is_copy()
+                {
+                    true => "",
+                    false => "",
+                };
+                let as_option = self.self_field_as_option(elem, *option_kind);
+                w.if_let_stmt(
+                    &format!("Some({}{})", ref_prefix, var),
+                    &as_option.value,
+                    |w| {
+                        let v = RustValueTyped {
+                            value: var.to_owned(),
+                            rust_type: as_option.rust_type.elem_type(),
+                        };
+                        cb(&v, w);
+                    },
+                );
+            }
+            SingularField {
+                flag: SingularFieldFlag::WithoutFlag,
+                ref elem,
+            } => match *elem {
+                FieldElem::Primitive(field_descriptor_proto::Type::TYPE_STRING, ..)
+                | FieldElem::Primitive(field_descriptor_proto::Type::TYPE_BYTES, ..) => {
+                    w.if_stmt(format!("!{}.is_empty()", self.self_field()), |w| {
+                        let v = RustValueTyped {
+                            value: self.self_field(),
+                            rust_type: self.full_storage_type(
+                                &self
+                                    .proto_field
+                                    .message
+                                    .scope
+                                    .file_and_mod(self.customize.clone()),
+                            ),
+                        };
+                        cb(&v, w);
+                    });
+                }
+                _ => {
+                    w.if_stmt(
+                        format!(
+                            "{} != {}",
+                            self.self_field(),
+                            self.full_storage_type(
+                                &self
+                                    .proto_field
+                                    .message
+                                    .scope
+                                    .file_and_mod(self.customize.clone())
+                            )
+                            .default_value(&self.customize, false)
+                        ),
+                        |w| {
+                            let v = RustValueTyped {
+                                value: self.self_field(),
+                                rust_type: self.full_storage_type(
+                                    &self
+                                        .proto_field
+                                        .message
+                                        .scope
+                                        .file_and_mod(self.customize.clone()),
+                                ),
+                            };
+                            cb(&v, w);
+                        },
+                    );
+                }
+            },
+        }
+    }
+
+    pub(crate) fn write_if_self_field_is_none<F>(&self, w: &mut CodeWriter, cb: F)
+    where
+        F: Fn(&mut CodeWriter),
+    {
+        let self_field_is_none = self.self_field_is_none();
+        w.if_stmt(self_field_is_none, cb)
+    }
+
+    // repeated or singular
+    pub(crate) fn write_for_self_field<F>(&self, w: &mut CodeWriter, varn: &str, cb: F)
+    where
+        F: Fn(&mut CodeWriter, &RustType),
+    {
+        let file_and_mod = self
+            .proto_field
+            .message
+            .scope
+            .file_and_mod(self.customize.clone());
+
+        match &self.kind {
+            FieldKind::Oneof(oneof_field) => {
+                let cond = format!(
+                    "Some({}(ref {}))",
+                    oneof_field.variant_path(&file_and_mod.relative_mod),
+                    varn
+                );
+                w.if_let_stmt(
+                    &cond,
+                    &format!("self.{}", oneof_field.oneof_field_name),
+                    |w| cb(w, &oneof_field.elem.rust_storage_elem_type(&file_and_mod)),
+                )
+            }
+            _ => {
+                let v_type = self.full_storage_iter_elem_type(&file_and_mod);
+                let self_field = self.self_field();
+                w.for_stmt(&format!("&{}", self_field), varn, |w| cb(w, &v_type));
+            }
+        }
+    }
+
+    fn write_self_field_assign(&self, w: &mut CodeWriter, value: &str) {
+        let self_field = self.self_field();
+        w.write_line(&format!("{} = {};", self_field, value));
+    }
+
+    fn write_self_field_assign_some(&self, w: &mut CodeWriter, s: &SingularField, value: &str) {
+        match s {
+            &SingularField {
+                flag: SingularFieldFlag::WithFlag { option_kind, .. },
+                ..
+            } => {
+                self.write_self_field_assign(w, &option_kind.wrap_value(value, &self.customize));
+            }
+            &SingularField {
+                flag: SingularFieldFlag::WithoutFlag,
+                ..
+            } => {
+                self.write_self_field_assign(w, value);
+            }
+        }
+    }
+
+    fn write_self_field_assign_value_singular(
+        &self,
+        w: &mut CodeWriter,
+        s: &SingularField,
+        value: &RustValueTyped,
+    ) {
+        let SingularField { ref elem, ref flag } = s;
+        let converted = value.into_type(
+            elem.rust_storage_elem_type(
+                &self
+                    .proto_field
+                    .message
+                    .scope
+                    .file_and_mod(self.customize.clone()),
+            )
+            .clone(),
+            &self.customize,
+        );
+        let wrapped = match flag {
+            SingularFieldFlag::WithoutFlag => converted.value,
+            SingularFieldFlag::WithFlag { option_kind, .. } => {
+                option_kind.wrap_value(&converted.value, &self.customize)
+            }
+        };
+        self.write_self_field_assign(w, &wrapped);
+    }
+
+    fn write_self_field_assign_value(&self, w: &mut CodeWriter, value: &RustValueTyped) {
+        match self.kind {
+            FieldKind::Repeated(..) | FieldKind::Map(..) => {
+                let converted = value.into_type(
+                    self.full_storage_type(
+                        &self
+                            .proto_field
+                            .message
+                            .scope
+                            .file_and_mod(self.customize.clone()),
+                    ),
+                    &self.customize,
+                );
+                self.write_self_field_assign(w, &converted.value);
+            }
+            FieldKind::Singular(ref s) => {
+                self.write_self_field_assign_value_singular(w, s, value);
+            }
+            FieldKind::Oneof(..) => unreachable!(),
+        }
+    }
+
+    fn write_self_field_assign_default(
+        &self,
+        field_kind: &SingularOrOneofField,
+        w: &mut CodeWriter,
+    ) {
+        match field_kind {
+            SingularOrOneofField::Oneof(oneof) => {
+                w.write_line(format!(
+                    "self.{} = ::std::option::Option::Some({}({}))",
+                    oneof.oneof_field_name,
+                    oneof.variant_path(&self.proto_field.message.scope.rust_path_to_file()),
+                    // TODO: default from .proto is not needed here (?)
+                    self.element_default_value_rust()
+                        .into_type(
+                            self.full_storage_iter_elem_type(
+                                &self
+                                    .proto_field
+                                    .message
+                                    .scope
+                                    .file_and_mod(self.customize.clone())
+                            ),
+                            &self.customize
+                        )
+                        .value
+                ));
+            }
+            SingularOrOneofField::Singular(singular) => {
+                // Note it is different from C++ protobuf, where field is initialized
+                // with default value
+                match singular.flag {
+                    SingularFieldFlag::WithFlag { option_kind, .. } => match option_kind {
+                        OptionKind::MessageField => {
+                            let self_field = self.self_field();
+                            w.write_line(&format!("{}.set_default();", self_field));
+                        }
+                        _ => {
+                            self.write_self_field_assign_some(
+                                w,
+                                singular,
+                                &self
+                                    .elem()
+                                    .rust_storage_elem_type(
+                                        &self
+                                            .proto_field
+                                            .message
+                                            .scope
+                                            .file_and_mod(self.customize.clone()),
+                                    )
+                                    .default_value_typed(&self.customize, false)
+                                    .into_type(
+                                        singular.elem.rust_storage_elem_type(
+                                            &self
+                                                .proto_field
+                                                .message
+                                                .scope
+                                                .file_and_mod(self.customize.clone()),
+                                        ),
+                                        &self.customize,
+                                    )
+                                    .value,
+                            );
+                        }
+                    },
+                    SingularFieldFlag::WithoutFlag => unimplemented!(),
+                }
+            }
+        }
+    }
+
+    fn self_field_vec_packed_size(&self) -> String {
+        let fn_name = match self.proto_type {
+            Type::TYPE_ENUM => "vec_packed_enum_or_unknown_size",
+            Type::TYPE_SINT32 => "vec_packed_sint32_size",
+            Type::TYPE_SINT64 => "vec_packed_sint64_size",
+            Type::TYPE_INT32 => "vec_packed_int32_size",
+            Type::TYPE_INT64 => "vec_packed_int64_size",
+            Type::TYPE_UINT32 => "vec_packed_uint32_size",
+            Type::TYPE_UINT64 => "vec_packed_uint64_size",
+            Type::TYPE_BOOL => "vec_packed_bool_size",
+            Type::TYPE_FIXED32 => "vec_packed_fixed32_size",
+            Type::TYPE_FIXED64 => "vec_packed_fixed64_size",
+            Type::TYPE_SFIXED32 => "vec_packed_sfixed32_size",
+            Type::TYPE_SFIXED64 => "vec_packed_sfixed64_size",
+            Type::TYPE_FLOAT => "vec_packed_float_size",
+            Type::TYPE_DOUBLE => "vec_packed_double_size",
+            t => unreachable!("{:?}", t),
+        };
+        format!(
+            "{}::rt::{fn_name}({}, &{})",
+            protobuf_crate_path(&self.customize),
+            self.proto_field.number(),
+            self.self_field()
+        )
+    }
+
+    pub(crate) fn clear_field_func(&self) -> String {
+        format!("clear_{}", self.rust_name)
+    }
+
+    fn write_merge_from_field_message_string_bytes_repeated(
+        &self,
+        r: &RepeatedField,
+        w: &mut CodeWriter,
+    ) {
+        let read_fn = match &r.elem {
+            FieldElem::Message(..) => "read_message",
+            FieldElem::Primitive(Type::TYPE_STRING, PrimitiveTypeVariant::Default) => "read_string",
+            FieldElem::Primitive(Type::TYPE_STRING, PrimitiveTypeVariant::TokioBytes) => {
+                "read_tokio_chars"
+            }
+            FieldElem::Primitive(Type::TYPE_BYTES, PrimitiveTypeVariant::Default) => "read_bytes",
+            FieldElem::Primitive(Type::TYPE_BYTES, PrimitiveTypeVariant::TokioBytes) => {
+                "read_tokio_bytes"
+            }
+            _ => unreachable!("for field {}", self.proto_field.field),
+        };
+        w.write_line(&format!("self.{}.push(is.{}()?);", self.rust_name, read_fn,));
+    }
+
+    fn tag_with_wire_type(&self, wire_type: WireType) -> u32 {
+        make_tag(self.proto_field.number() as u32, wire_type)
+    }
+
+    fn tag(&self) -> u32 {
+        self.tag_with_wire_type(self.wire_type)
+    }
+
+    // Write `merge_from` part for this oneof field
+    fn write_merge_from_oneof_case_block(&self, o: &OneofField, w: &mut CodeWriter) {
+        w.case_block(&format!("{}", self.tag()), |w| {
+            let typed = RustValueTyped {
+                value: format!(
+                    "{}?",
+                    self.proto_type.read("is", o.elem.primitive_type_variant())
+                ),
+                rust_type: self.full_storage_iter_elem_type(
+                    &self
+                        .proto_field
+                        .message
+                        .scope
+                        .file_and_mod(self.customize.clone()),
+                ),
+            };
+
+            let maybe_boxed = if o.boxed {
+                typed.boxed(&self.customize)
+            } else {
+                typed
+            };
+
+            w.write_line(&format!(
+                "self.{} = ::std::option::Option::Some({}({}));",
+                o.oneof_field_name,
+                o.variant_path(&self.proto_field.message.scope.rust_path_to_file()),
+                maybe_boxed.value
+            ));
+        })
+    }
+
+    // Write `merge_from` part for this map field
+    fn write_merge_from_map_case_block(&self, map: &MapField, w: &mut CodeWriter) {
+        let MapField { key, value, .. } = map;
+        w.case_block(&format!("{}", self.tag()), |w| {
+            w.write_line(&format!("let len = is.read_raw_varint32()?;",));
+            w.write_line(&format!("let old_limit = is.push_limit(len as u64)?;"));
+            w.write_line(&format!(
+                "let mut key = ::std::default::Default::default();"
+            ));
+            w.write_line(&format!(
+                "let mut value = ::std::default::Default::default();"
+            ));
+            w.while_block("let Some(tag) = is.read_raw_tag_or_eof()?", |w| {
+                w.match_block("tag", |w| {
+                    let key_tag = make_tag(1, WireType::for_type(key.proto_type()));
+                    let value_tag = make_tag(2, WireType::for_type(value.proto_type()));
+                    w.case_expr(
+                        &format!("{key_tag}"),
+                        &format!("key = {read}", read = key.read_one_liner()),
+                    );
+                    w.case_expr(
+                        &format!("{value_tag}"),
+                        &format!("value = {read}", read = value.read_one_liner()),
+                    );
+                    w.case_expr(
+                        "_",
+                        &format!(
+                            "{protobuf_crate}::rt::skip_field_for_tag(tag, is)?",
+                            protobuf_crate = protobuf_crate_path(&self.customize)
+                        ),
+                    );
+                });
+            });
+            w.write_line(&format!("is.pop_limit(old_limit);"));
+            w.write_line(&format!(
+                "{field}.insert(key, value);",
+                field = self.self_field()
+            ));
+        });
+    }
+
+    // Write `merge_from` part for this singular field
+    fn write_merge_from_singular_case_block(&self, s: &SingularField, w: &mut CodeWriter) {
+        w.case_block(&format!("{}", self.tag()), |w| match s.elem {
+            FieldElem::Message(..) => {
+                w.write_line(&format!(
+                    "{}::rt::read_singular_message_into_field(is, &mut self.{})?;",
+                    protobuf_crate_path(&self.customize),
+                    self.rust_name,
+                ));
+            }
+            _ => {
+                let read_proc = s.elem.read_one_liner();
+                self.write_self_field_assign_some(w, s, &read_proc);
+            }
+        })
+    }
+
+    // Write `merge_from` part for this repeated field
+    fn write_merge_from_repeated_case_block(&self, w: &mut CodeWriter) {
+        let field = match self.kind {
+            FieldKind::Repeated(ref field) => field,
+            _ => panic!(),
+        };
+
+        match field.elem {
+            FieldElem::Message(..)
+            | FieldElem::Primitive(field_descriptor_proto::Type::TYPE_STRING, ..)
+            | FieldElem::Primitive(field_descriptor_proto::Type::TYPE_BYTES, ..) => {
+                w.case_block(&format!("{}", self.tag()), |w| {
+                    self.write_merge_from_field_message_string_bytes_repeated(field, w);
+                })
+            }
+            FieldElem::Enum(..) => {
+                w.case_block(
+                    &format!("{}", self.tag_with_wire_type(WireType::Varint)),
+                    |w| {
+                        w.write_line(&format!(
+                            "self.{}.push(is.read_enum_or_unknown()?);",
+                            self.rust_name,
+                        ));
+                    },
+                );
+                w.case_block(
+                    &format!("{}", self.tag_with_wire_type(WireType::LengthDelimited)),
+                    |w| {
+                        w.write_line(&format!(
+                            "{}::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.{})?",
+                            protobuf_crate_path(&self.customize),
+                            self.rust_name,
+                        ));
+                    },
+                );
+            }
+            _ => {
+                assert_ne!(self.wire_type, WireType::LengthDelimited);
+                w.case_block(
+                    &format!("{}", self.tag_with_wire_type(WireType::LengthDelimited)),
+                    |w| {
+                        w.write_line(&format!(
+                            "is.read_repeated_packed_{}_into(&mut self.{})?;",
+                            self.proto_type.protobuf_name(),
+                            self.rust_name
+                        ));
+                    },
+                );
+                w.case_block(&format!("{}", self.tag()), |w| {
+                    w.write_line(&format!(
+                        "self.{}.push(is.read_{}()?);",
+                        self.rust_name,
+                        self.proto_type.protobuf_name(),
+                    ));
+                });
+            }
+        }
+    }
+
+    /// Write `merge_from` part for this field
+    pub(crate) fn write_merge_from_field_case_block(&self, w: &mut CodeWriter) {
+        match &self.kind {
+            FieldKind::Oneof(oneof) => self.write_merge_from_oneof_case_block(oneof, w),
+            FieldKind::Map(map) => self.write_merge_from_map_case_block(map, w),
+            FieldKind::Singular(ref s) => self.write_merge_from_singular_case_block(s, w),
+            FieldKind::Repeated(..) => self.write_merge_from_repeated_case_block(w),
+        }
+    }
+
+    pub(crate) fn write_element_size(
+        &self,
+        elem: &FieldElem,
+        w: &mut CodeWriter,
+        item_var: &RustValueTyped,
+        sum_var: &str,
+    ) {
+        assert!(!self.is_repeated_packed());
+
+        elem.write_element_size(
+            self.proto_field.number() as u32,
+            item_var,
+            HowToGetMessageSize::Compute,
+            sum_var,
+            &self.customize,
+            w,
+        );
+    }
+
+    fn write_write_map_field(
+        &self,
+        key: &FieldElem,
+        value: &FieldElem,
+        os: &str,
+        w: &mut CodeWriter,
+    ) {
+        self.for_each_map_entry(key, value, w, |k, v, w| {
+            w.write_line("let mut entry_size = 0;");
+            key.write_element_size(
+                1,
+                k,
+                HowToGetMessageSize::GetCached,
+                "entry_size",
+                &self.customize,
+                w,
+            );
+            value.write_element_size(
+                2,
+                v,
+                HowToGetMessageSize::GetCached,
+                "entry_size",
+                &self.customize,
+                w,
+            );
+            w.write_line(&format!(
+                "{os}.write_raw_varint32({tag})?; // Tag.",
+                tag = make_tag(self.proto_field.number() as u32, WireType::LengthDelimited),
+            ));
+            w.write_line(&format!("{os}.write_raw_varint32(entry_size as u32)?;",));
+            key.write_write_element(1, k, &self.file_and_mod(), &self.customize, os, w);
+            value.write_write_element(2, v, &self.file_and_mod(), &self.customize, os, w);
+        });
+    }
+
+    pub(crate) fn write_message_write_field(&self, os: &str, w: &mut CodeWriter) {
+        match &self.kind {
+            FieldKind::Singular(s @ SingularField { elem, .. }) => {
+                self.write_if_let_self_field_is_some(s, w, |v, w| {
+                    self.write_write_element(&elem, w, os, &v);
+                });
+            }
+            FieldKind::Repeated(RepeatedField {
+                packed: false,
+                elem,
+                ..
+            }) => {
+                self.write_for_self_field(w, "v", |w, v_type| {
+                    let v = RustValueTyped {
+                        value: "v".to_owned(),
+                        rust_type: v_type.clone(),
+                    };
+                    self.write_write_element(elem, w, "os", &v);
+                });
+            }
+            FieldKind::Repeated(RepeatedField { packed: true, .. }) => {
+                w.write_line(&format!(
+                    "os.write_repeated_packed_{}({}, &{})?;",
+                    self.os_write_fn_suffix_with_unknown_for_enum(),
+                    self.proto_field.number(),
+                    self.self_field()
+                ));
+            }
+            FieldKind::Map(MapField { key, value, .. }) => {
+                self.write_write_map_field(key, value, os, w)
+            }
+            FieldKind::Oneof(..) => unreachable!(),
+        };
+    }
+
+    fn for_each_map_entry(
+        &self,
+        key: &FieldElem,
+        value: &FieldElem,
+        w: &mut CodeWriter,
+        cb: impl FnOnce(&RustValueTyped, &RustValueTyped, &mut CodeWriter),
+    ) {
+        w.for_stmt(&format!("&{}", self.self_field()), "(k, v)", move |w| {
+            let k = RustValueTyped {
+                value: "k".to_owned(),
+                rust_type: key.rust_storage_elem_type(&self.file_and_mod()).wrap_ref(),
+            };
+            let v = RustValueTyped {
+                value: "v".to_owned(),
+                rust_type: value
+                    .rust_storage_elem_type(&self.file_and_mod())
+                    .wrap_ref(),
+            };
+            cb(&k, &v, w)
+        });
+    }
+
+    fn write_compute_map_field_size(
+        &self,
+        sum_var: &str,
+        key: &FieldElem<'a>,
+        value: &FieldElem<'a>,
+        w: &mut CodeWriter,
+    ) {
+        self.for_each_map_entry(key, value, w, |k, v, w| {
+                w.write_line("let mut entry_size = 0;");
+                key.write_element_size(1, k, HowToGetMessageSize::Compute, "entry_size", &self.customize, w);
+                value.write_element_size(2, v, HowToGetMessageSize::Compute, "entry_size", &self.customize, w);
+                w.write_line(&format!("{sum_var} += {tag_size} + {protobuf_crate}::rt::compute_raw_varint64_size(entry_size) + entry_size",
+                    tag_size = self.tag_size(),
+                    protobuf_crate = protobuf_crate_path(&self.customize),
+                ));
+        });
+    }
+
+    pub(crate) fn write_message_compute_field_size(&self, sum_var: &str, w: &mut CodeWriter) {
+        match &self.kind {
+            FieldKind::Singular(s @ SingularField { elem, .. }) => {
+                self.write_if_let_self_field_is_some(s, w, |v, w| {
+                    self.write_element_size(&elem, w, v, sum_var)
+                });
+            }
+            FieldKind::Repeated(RepeatedField {
+                packed: false,
+                elem,
+                ..
+            }) => {
+                match elem.proto_type().encoded_size() {
+                    Some(s) => {
+                        let tag_size = self.tag_size();
+                        let self_field = self.self_field();
+                        w.write_line(&format!(
+                            "{} += {} * {}.len() as u64;",
+                            sum_var,
+                            (s + tag_size) as isize,
+                            self_field
+                        ));
+                    }
+                    None => {
+                        self.write_for_self_field(w, "value", |w, value_type| {
+                            self.write_element_size(
+                                elem,
+                                w,
+                                &RustValueTyped {
+                                    value: "value".to_owned(),
+                                    rust_type: value_type.clone(),
+                                },
+                                sum_var,
+                            );
+                        });
+                    }
+                };
+            }
+            FieldKind::Repeated(RepeatedField { packed: true, .. }) => {
+                let size_expr = self.self_field_vec_packed_size();
+                w.write_line(&format!("{} += {};", sum_var, size_expr));
+            }
+            FieldKind::Map(MapField { key, value, .. }) => {
+                self.write_compute_map_field_size(sum_var, key, value, w)
+            }
+            FieldKind::Oneof(..) => unreachable!(),
+        }
+    }
+
+    fn write_message_field_get_singular_message(&self, s: &SingularField, w: &mut CodeWriter) {
+        match s.flag {
+            SingularFieldFlag::WithoutFlag => unimplemented!(),
+            SingularFieldFlag::WithFlag { option_kind, .. } => {
+                let self_field = self.self_field();
+                let ref field_type_name = self.elem().rust_storage_elem_type(
+                    &self
+                        .proto_field
+                        .message
+                        .scope
+                        .file_and_mod(self.customize.clone()),
+                );
+                w.write_line(option_kind.unwrap_ref_or_else(
+                    &format!("{}.as_ref()", self_field),
+                    &format!(
+                        "<{} as {}::Message>::default_instance()",
+                        field_type_name.to_code(&self.customize),
+                        protobuf_crate_path(&self.customize),
+                    ),
+                ));
+            }
+        }
+    }
+
+    fn write_message_field_get_singular_enum(
+        &self,
+        flag: SingularFieldFlag,
+        _elem: &FieldElemEnum,
+        w: &mut CodeWriter,
+    ) {
+        match flag {
+            SingularFieldFlag::WithoutFlag => {
+                w.write_line(&format!("self.{}.enum_value_or_default()", self.rust_name));
+            }
+            SingularFieldFlag::WithFlag { .. } => {
+                w.match_expr(&self.self_field(), |w| {
+                    let default_value = self.xxx_default_value_rust();
+                    w.case_expr("Some(e)", &format!("e.enum_value_or({})", default_value));
+                    w.case_expr("None", &format!("{}", default_value));
+                });
+            }
+        }
+    }
+
+    fn write_message_field_get_singular(&self, singular: &SingularField, w: &mut CodeWriter) {
+        let get_xxx_return_type = self.getter_return_type();
+
+        match singular.elem {
+            FieldElem::Message(..) => self.write_message_field_get_singular_message(singular, w),
+            FieldElem::Enum(ref en) => {
+                self.write_message_field_get_singular_enum(singular.flag, en, w)
+            }
+            _ => {
+                let get_xxx_default_value_rust = self.xxx_default_value_rust();
+                let self_field = self.self_field();
+                match singular {
+                    &SingularField {
+                        ref elem,
+                        flag: SingularFieldFlag::WithFlag { option_kind, .. },
+                        ..
+                    } => {
+                        if get_xxx_return_type.is_ref().is_some() {
+                            let as_option = self.self_field_as_option(elem, option_kind);
+                            w.match_expr(&as_option.value, |w| {
+                                let v_type = as_option.rust_type.elem_type();
+                                let r_type = self.getter_return_type();
+                                w.case_expr(
+                                    "Some(v)",
+                                    v_type.into_target(&r_type, "v", &self.customize),
+                                );
+                                let get_xxx_default_value_rust = self.xxx_default_value_rust();
+                                w.case_expr("None", get_xxx_default_value_rust);
+                            });
+                        } else {
+                            w.write_line(&format!(
+                                "{}.unwrap_or({})",
+                                self_field, get_xxx_default_value_rust
+                            ));
+                        }
+                    }
+                    &SingularField {
+                        flag: SingularFieldFlag::WithoutFlag,
+                        ..
+                    } => {
+                        w.write_line(
+                            self.full_storage_type(
+                                &self
+                                    .proto_field
+                                    .message
+                                    .scope
+                                    .file_and_mod(self.customize.clone()),
+                            )
+                            .into_target(
+                                &get_xxx_return_type,
+                                &self_field,
+                                &self.customize,
+                            ),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    fn write_message_field_get_oneof(&self, o: &OneofField, w: &mut CodeWriter) {
+        let get_xxx_return_type = SingularOrOneofField::Oneof(o.clone()).getter_return_type(
+            &self
+                .proto_field
+                .message
+                .scope
+                .file_and_mod(self.customize.clone()),
+        );
+        let OneofField { ref elem, .. } = o;
+        w.match_expr(&format!("self.{}", o.oneof_field_name), |w| {
+            let (refv, vtype) = if !elem.is_copy() {
+                (
+                    "ref v",
+                    elem.rust_storage_elem_type(
+                        &self
+                            .proto_field
+                            .message
+                            .scope
+                            .file_and_mod(self.customize.clone()),
+                    )
+                    .ref_type(),
+                )
+            } else {
+                (
+                    "v",
+                    elem.rust_storage_elem_type(
+                        &self
+                            .proto_field
+                            .message
+                            .scope
+                            .file_and_mod(self.customize.clone()),
+                    ),
+                )
+            };
+            w.case_expr(
+                format!(
+                    "::std::option::Option::Some({}({}))",
+                    o.variant_path(&self.proto_field.message.scope.rust_path_to_file()),
+                    refv
+                ),
+                vtype.into_target(&get_xxx_return_type, "v", &self.customize),
+            );
+            w.case_expr("_", self.xxx_default_value_rust());
+        });
+    }
+
+    fn write_message_field_get(&self, w: &mut CodeWriter) {
+        let get_xxx_return_type = self.getter_return_type();
+        let fn_def = format!(
+            "{}(&self) -> {}",
+            self.rust_name,
+            get_xxx_return_type.to_code(&self.customize)
+        );
+
+        w.pub_fn(&fn_def, |w| match self.kind {
+            FieldKind::Oneof(ref o) => {
+                self.write_message_field_get_oneof(o, w);
+            }
+            FieldKind::Singular(ref s) => {
+                self.write_message_field_get_singular(s, w);
+            }
+            FieldKind::Repeated(..) | FieldKind::Map(..) => {
+                let self_field = self.self_field();
+                w.write_line(&format!("&{}", self_field));
+            }
+        });
+    }
+
+    fn has_has(&self) -> bool {
+        match self.kind {
+            FieldKind::Repeated(..) | FieldKind::Map(..) => false,
+            FieldKind::Singular(SingularField {
+                flag: SingularFieldFlag::WithFlag { .. },
+                ..
+            }) => true,
+            FieldKind::Singular(SingularField {
+                flag: SingularFieldFlag::WithoutFlag,
+                ..
+            }) => false,
+            FieldKind::Oneof(..) => true,
+        }
+    }
+
+    fn has_mut(&self) -> bool {
+        match self.kind {
+            FieldKind::Repeated(..) | FieldKind::Map(..) => true,
+            // TODO: string should be public, and mut is not needed
+            FieldKind::Singular(..) | FieldKind::Oneof(..) => !self.elem_type_is_copy(),
+        }
+    }
+
+    fn has_take(&self) -> bool {
+        match self.kind {
+            FieldKind::Repeated(..) | FieldKind::Map(..) => true,
+            // TODO: string should be public, and mut is not needed
+            FieldKind::Singular(..) | FieldKind::Oneof(..) => !self.elem_type_is_copy(),
+        }
+    }
+
+    fn has_name(&self) -> RustIdent {
+        RustIdent::new(&format!("has_{}", self.rust_name.get()))
+    }
+
+    fn set_name(&self) -> RustIdent {
+        RustIdent::new(&format!("set_{}", self.rust_name.get()))
+    }
+
+    fn mut_name(&self) -> RustIdent {
+        RustIdent::new(&format!("mut_{}", self.rust_name.get()))
+    }
+
+    fn write_message_field_has(&self, w: &mut CodeWriter) {
+        w.pub_fn(
+            &format!("{}(&self) -> bool", self.has_name()),
+            |w| match self.kind {
+                FieldKind::Oneof(ref oneof) => {
+                    w.match_expr(&format!("self.{}", oneof.oneof_field_name), |w| {
+                        w.case_expr(
+                            format!(
+                                "::std::option::Option::Some({}(..))",
+                                oneof.variant_path(
+                                    &self.proto_field.message.scope.rust_path_to_file()
+                                )
+                            ),
+                            "true",
+                        );
+                        w.case_expr("_", "false");
+                    });
+                }
+                _ => {
+                    let self_field_is_some = self.self_field_is_some();
+                    w.write_line(self_field_is_some);
+                }
+            },
+        );
+    }
+
+    fn write_message_field_set(&self, w: &mut CodeWriter) {
+        let set_xxx_param_type = self.set_xxx_param_type(
+            &self
+                .proto_field
+                .message
+                .scope
+                .file_and_mod(self.customize.clone()),
+        );
+        w.comment("Param is passed by value, moved");
+        w.pub_fn(
+            &format!(
+                "{}(&mut self, v: {})",
+                self.set_name(),
+                set_xxx_param_type.to_code(&self.customize)
+            ),
+            |w| {
+                let value_typed = RustValueTyped {
+                    value: "v".to_owned(),
+                    rust_type: set_xxx_param_type.clone(),
+                };
+                match self.kind {
+                    FieldKind::Oneof(ref oneof) => {
+                        let v = set_xxx_param_type.into_target(
+                            &oneof.rust_type(
+                                &self
+                                    .proto_field
+                                    .message
+                                    .scope
+                                    .file_and_mod(self.customize.clone()),
+                            ),
+                            "v",
+                            &self.customize,
+                        );
+                        w.write_line(&format!(
+                            "self.{} = ::std::option::Option::Some({}({}))",
+                            oneof.oneof_field_name,
+                            oneof.variant_path(&self.proto_field.message.scope.rust_path_to_file()),
+                            v
+                        ));
+                    }
+                    _ => {
+                        self.write_self_field_assign_value(w, &value_typed);
+                    }
+                }
+            },
+        );
+    }
+
+    fn write_message_field_mut_singular_with_flag(
+        &self,
+        s: &SingularField,
+        option_kind: OptionKind,
+        w: &mut CodeWriter,
+    ) {
+        let self_field = self.self_field();
+        match option_kind {
+            OptionKind::MessageField => {
+                w.write_line(&format!("{}.mut_or_insert_default()", self_field))
+            }
+            OptionKind::Option => {
+                self.write_if_self_field_is_none(w, |w| {
+                    self.write_self_field_assign_default(
+                        &SingularOrOneofField::Singular(s.clone()),
+                        w,
+                    );
+                });
+                w.write_line(&format!("{}.as_mut().unwrap()", self_field));
+            }
+        }
+    }
+
+    fn write_message_field_mut_singular(&self, s: &SingularField, w: &mut CodeWriter) {
+        match s {
+            s @ SingularField {
+                flag: SingularFieldFlag::WithFlag { option_kind, .. },
+                ..
+            } => self.write_message_field_mut_singular_with_flag(s, *option_kind, w),
+            SingularField {
+                flag: SingularFieldFlag::WithoutFlag,
+                ..
+            } => w.write_line(&format!("&mut {}", self.self_field())),
+        }
+    }
+
+    fn write_message_field_mut(&self, w: &mut CodeWriter) {
+        let mut_xxx_return_type = self.mut_xxx_return_type(
+            &self
+                .proto_field
+                .message
+                .scope
+                .file_and_mod(self.customize.clone()),
+        );
+        w.comment("Mutable pointer to the field.");
+        if self.is_singular() {
+            w.comment("If field is not initialized, it is initialized with default value first.");
+        }
+        let fn_def = match mut_xxx_return_type {
+            RustType::Ref(ref param) => format!(
+                "{}(&mut self) -> &mut {}",
+                self.mut_name(),
+                param.to_code(&self.customize)
+            ),
+            _ => panic!(
+                "not a ref: {}",
+                mut_xxx_return_type.to_code(&self.customize)
+            ),
+        };
+        w.pub_fn(&fn_def, |w| {
+            match self.kind {
+                FieldKind::Repeated(..) | FieldKind::Map(..) => {
+                    let self_field = self.self_field();
+                    w.write_line(&format!("&mut {}", self_field));
+                }
+                FieldKind::Singular(ref s) => {
+                    self.write_message_field_mut_singular(s, w);
+                }
+                FieldKind::Oneof(ref o) => {
+                    let self_field_oneof = format!("self.{}", o.oneof_field_name);
+
+                    // if oneof does not contain current field
+                    w.if_let_else_stmt(
+                        &format!(
+                            "::std::option::Option::Some({}(_))",
+                            o.variant_path(&self.proto_field.message.scope.rust_path_to_file())
+                        )[..],
+                        &self_field_oneof[..],
+                        |w| {
+                            // initialize it with default value
+                            w.write_line(&format!(
+                                "{} = ::std::option::Option::Some({}({}));",
+                                self_field_oneof,
+                                o.variant_path(&self.proto_field.message.scope.rust_path_to_file()),
+                                self.element_default_value_rust()
+                                    .into_type(
+                                        o.rust_type(
+                                            &self
+                                                .proto_field
+                                                .message
+                                                .scope
+                                                .file_and_mod(self.customize.clone())
+                                        ),
+                                        &self.customize
+                                    )
+                                    .value
+                            ));
+                        },
+                    );
+
+                    // extract field
+                    w.match_expr(self_field_oneof, |w| {
+                        w.case_expr(
+                            format!(
+                                "::std::option::Option::Some({}(ref mut v))",
+                                o.variant_path(&self.proto_field.message.scope.rust_path_to_file())
+                            ),
+                            "v",
+                        );
+                        w.case_expr("_", "panic!()");
+                    });
+                }
+            }
+        });
+    }
+
+    fn write_message_field_take_oneof(&self, o: &OneofField, w: &mut CodeWriter) {
+        let take_xxx_return_type = self.take_xxx_return_type(
+            &self
+                .proto_field
+                .message
+                .scope
+                .file_and_mod(self.customize.clone()),
+        );
+
+        // TODO: replace with if let
+        w.write_line(&format!("if self.{}() {{", self.has_name()));
+        w.indented(|w| {
+            let self_field_oneof = format!("self.{}", o.oneof_field_name);
+            w.match_expr(format!("{}.take()", self_field_oneof), |w| {
+                let value_in_some = o
+                    .rust_type(
+                        &self
+                            .proto_field
+                            .message
+                            .scope
+                            .file_and_mod(self.customize.clone()),
+                    )
+                    .value("v".to_owned());
+                let converted = value_in_some.into_type(
+                    self.take_xxx_return_type(
+                        &self
+                            .proto_field
+                            .message
+                            .scope
+                            .file_and_mod(self.customize.clone()),
+                    ),
+                    &self.customize,
+                );
+                w.case_expr(
+                    format!(
+                        "::std::option::Option::Some({}(v))",
+                        o.variant_path(&self.proto_field.message.scope.rust_path_to_file())
+                    ),
+                    &converted.value,
+                );
+                w.case_expr("_", "panic!()");
+            });
+        });
+        w.write_line("} else {");
+        w.indented(|w| {
+            w.write_line(
+                self.elem()
+                    .rust_storage_elem_type(
+                        &self
+                            .proto_field
+                            .message
+                            .scope
+                            .file_and_mod(self.customize.clone()),
+                    )
+                    .default_value_typed(&self.customize, false)
+                    .into_type(take_xxx_return_type.clone(), &self.customize)
+                    .value,
+            );
+        });
+        w.write_line("}");
+    }
+
+    fn write_message_field_take_singular(&self, s: &SingularField, w: &mut CodeWriter) {
+        match s {
+            SingularField {
+                ref elem,
+                flag: SingularFieldFlag::WithFlag { option_kind, .. },
+            } => {
+                if !elem.is_copy() {
+                    w.write_line(
+                        &option_kind.unwrap_or_else(
+                            &format!("{}.take()", self.self_field()),
+                            &elem
+                                .rust_storage_elem_type(
+                                    &self
+                                        .proto_field
+                                        .message
+                                        .scope
+                                        .file_and_mod(self.customize.clone()),
+                                )
+                                .default_value(&self.customize, false),
+                        ),
+                    );
+                } else {
+                    w.write_line(&format!(
+                        "{}.take().unwrap_or({})",
+                        self.self_field(),
+                        self.element_default_value_rust().value
+                    ));
+                }
+            }
+            SingularField {
+                flag: SingularFieldFlag::WithoutFlag,
+                ..
+            } => w.write_line(&format!(
+                "::std::mem::replace(&mut {}, {})",
+                self.self_field(),
+                self.full_storage_type(
+                    &self
+                        .proto_field
+                        .message
+                        .scope
+                        .file_and_mod(self.customize.clone())
+                )
+                .default_value(&self.customize, false)
+            )),
+        }
+    }
+
+    fn write_message_field_take(&self, w: &mut CodeWriter) {
+        let take_xxx_return_type = self.take_xxx_return_type(
+            &self
+                .proto_field
+                .message
+                .scope
+                .file_and_mod(self.customize.clone()),
+        );
+        w.comment("Take field");
+        w.pub_fn(
+            &format!(
+                "take_{}(&mut self) -> {}",
+                self.rust_name,
+                take_xxx_return_type.to_code(&self.customize)
+            ),
+            |w| match self.kind {
+                FieldKind::Singular(ref s) => self.write_message_field_take_singular(&s, w),
+                FieldKind::Oneof(ref o) => self.write_message_field_take_oneof(o, w),
+                FieldKind::Repeated(..) | FieldKind::Map(..) => {
+                    w.write_line(&format!(
+                        "::std::mem::replace(&mut self.{}, {})",
+                        self.rust_name,
+                        take_xxx_return_type.default_value(&self.customize, false)
+                    ));
+                }
+            },
+        );
+    }
+
+    pub(crate) fn write_message_single_field_accessors(&self, w: &mut CodeWriter) {
+        if self.generate_accessors || self.generate_getter {
+            w.write_line("");
+            let reconstruct_def = self.reconstruct_def();
+            w.comment(&(reconstruct_def + ";"));
+        }
+
+        if self.generate_getter {
+            w.write_line("");
+            self.write_message_field_get(w);
+        }
+
+        if !self.generate_accessors {
+            return;
+        }
+
+        w.write_line("");
+        let clear_field_func = self.clear_field_func();
+        w.pub_fn(&format!("{}(&mut self)", clear_field_func), |w| {
+            self.write_clear(w);
+        });
+
+        if self.has_has() {
+            w.write_line("");
+            self.write_message_field_has(w);
+        }
+
+        w.write_line("");
+        self.write_message_field_set(w);
+
+        if self.has_mut() {
+            w.write_line("");
+            self.write_message_field_mut(w);
+        }
+
+        if self.has_take() {
+            w.write_line("");
+            self.write_message_field_take(w);
+        }
+    }
+}
+
+pub(crate) fn rust_field_name_for_protobuf_field_name(name: &str) -> RustIdent {
+    RustIdent::new(name)
+}
+
+pub(crate) fn rust_variant_name_for_protobuf_oneof_field_name(name: &str) -> RustIdent {
+    let name = camel_case(name);
+    RustIdent::new(&name)
+}
diff --git a/src/gen/field/option_kind.rs b/src/gen/field/option_kind.rs
new file mode 100644
index 0000000..0fde11a
--- /dev/null
+++ b/src/gen/field/option_kind.rs
@@ -0,0 +1,59 @@
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::rust_types_values::RustType;
+use crate::Customize;
+
+/// Optional fields can be stored are `Option<T>` or `SingularPtrField<T>`.
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum OptionKind {
+    /// Field is `Option<T>`
+    Option,
+    /// Field is `SingularPtrField<T>`
+    MessageField,
+}
+
+impl OptionKind {
+    pub(crate) fn wrap_element(&self, element_type: RustType) -> RustType {
+        let element_type = Box::new(element_type);
+        match self {
+            OptionKind::Option => RustType::Option(element_type),
+            OptionKind::MessageField => RustType::MessageField(element_type),
+        }
+    }
+
+    // Type of `as_ref()` operation
+    pub(crate) fn as_ref_type(&self, element_type: RustType) -> RustType {
+        match self {
+            OptionKind::Option => RustType::Option(Box::new(element_type.ref_type())),
+            OptionKind::MessageField => RustType::MessageField(Box::new(element_type.ref_type())),
+        }
+    }
+
+    fn _as_option_ref(&self, v: &str) -> String {
+        match self {
+            OptionKind::Option | OptionKind::MessageField => format!("{}.as_ref()", v),
+        }
+    }
+
+    pub(crate) fn unwrap_or_else(&self, what: &str, default_value: &str) -> String {
+        match self {
+            _ => format!("{}.unwrap_or_else(|| {})", what, default_value),
+        }
+    }
+
+    pub(crate) fn unwrap_ref_or_else(&self, what: &str, default_value: &str) -> String {
+        match self {
+            _ => format!("{}.unwrap_or_else(|| {})", what, default_value),
+        }
+    }
+
+    pub(crate) fn wrap_value(&self, value: &str, customize: &Customize) -> String {
+        match self {
+            OptionKind::Option => format!("::std::option::Option::Some({})", value),
+            OptionKind::MessageField => format!(
+                "{}::MessageField::some({})",
+                protobuf_crate_path(customize),
+                value
+            ),
+        }
+    }
+}
diff --git a/src/gen/field/repeated.rs b/src/gen/field/repeated.rs
new file mode 100644
index 0000000..56e0d0b
--- /dev/null
+++ b/src/gen/field/repeated.rs
@@ -0,0 +1,46 @@
+use crate::gen::field::elem::FieldElem;
+use crate::gen::file_and_mod::FileAndMod;
+use crate::gen::rust::snippets::EXPR_VEC_NEW;
+use crate::gen::rust_types_values::RustType;
+
+/// Repeated field can be `Vec<T>` or `RepeatedField<T>`.
+#[derive(Eq, PartialEq, Copy, Clone)]
+pub enum RepeatedFieldKind {
+    Vec,
+}
+
+impl RepeatedFieldKind {
+    fn wrap_element(&self, element_type: RustType) -> RustType {
+        let element_type = Box::new(element_type);
+        match self {
+            RepeatedFieldKind::Vec => RustType::Vec(element_type),
+        }
+    }
+
+    fn default(&self) -> String {
+        match self {
+            RepeatedFieldKind::Vec => EXPR_VEC_NEW.to_owned(),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct RepeatedField<'a> {
+    pub elem: FieldElem<'a>,
+    pub packed: bool,
+}
+
+impl<'a> RepeatedField<'a> {
+    pub(crate) fn kind(&self) -> RepeatedFieldKind {
+        RepeatedFieldKind::Vec
+    }
+
+    pub(crate) fn rust_type(&self, reference: &FileAndMod) -> RustType {
+        self.kind()
+            .wrap_element(self.elem.rust_storage_elem_type(reference))
+    }
+
+    pub(crate) fn default(&self) -> String {
+        self.kind().default()
+    }
+}
diff --git a/src/gen/field/singular.rs b/src/gen/field/singular.rs
new file mode 100644
index 0000000..3bd223f
--- /dev/null
+++ b/src/gen/field/singular.rs
@@ -0,0 +1,52 @@
+use crate::gen::field::elem::FieldElem;
+use crate::gen::field::option_kind::OptionKind;
+use crate::gen::file_and_mod::FileAndMod;
+use crate::gen::rust_types_values::RustType;
+use crate::Customize;
+
+#[derive(Clone, PartialEq, Eq, Copy)]
+pub enum SingularFieldFlag {
+    // proto2 or proto3 message
+    WithFlag {
+        required: bool,
+        option_kind: OptionKind,
+    },
+    // proto3
+    WithoutFlag,
+}
+
+impl SingularFieldFlag {
+    pub fn is_required(&self) -> bool {
+        match *self {
+            SingularFieldFlag::WithFlag { required, .. } => required,
+            SingularFieldFlag::WithoutFlag => false,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct SingularField<'a> {
+    pub flag: SingularFieldFlag,
+    pub elem: FieldElem<'a>,
+}
+
+impl<'a> SingularField<'a> {
+    pub(crate) fn rust_storage_type(&self, reference: &FileAndMod) -> RustType {
+        match self.flag {
+            SingularFieldFlag::WithFlag { option_kind, .. } => {
+                option_kind.wrap_element(self.elem.rust_storage_elem_type(reference))
+            }
+            SingularFieldFlag::WithoutFlag => self.elem.rust_storage_elem_type(reference),
+        }
+    }
+
+    pub(crate) fn default_value(
+        &self,
+        customize: &Customize,
+        reference: &FileAndMod,
+        const_expr: bool,
+    ) -> String {
+        self.rust_storage_type(reference)
+            .default_value(customize, const_expr)
+    }
+}
diff --git a/src/gen/field/tag.rs b/src/gen/field/tag.rs
new file mode 100644
index 0000000..401a140
--- /dev/null
+++ b/src/gen/field/tag.rs
@@ -0,0 +1,5 @@
+use protobuf::rt::WireType;
+
+pub(crate) fn make_tag(field_number: u32, wire_type: WireType) -> u32 {
+    (field_number << 3) | (wire_type as u32)
+}
diff --git a/src/gen/field/type_ext.rs b/src/gen/field/type_ext.rs
new file mode 100644
index 0000000..334168f
--- /dev/null
+++ b/src/gen/field/type_ext.rs
@@ -0,0 +1,115 @@
+use protobuf::descriptor::field_descriptor_proto::Type;
+
+use crate::gen::rust_types_values::PrimitiveTypeVariant;
+use crate::gen::rust_types_values::RustType;
+
+pub(crate) trait TypeExt {
+    fn read(&self, is: &str, primitive_type_variant: PrimitiveTypeVariant) -> String;
+    fn is_s_varint(&self) -> bool;
+    fn is_copy(&self) -> bool;
+    fn protobuf_name(&self) -> &'static str;
+    fn rust_type(&self) -> RustType;
+    fn os_write_fn_param_type(&self) -> RustType;
+    fn encoded_size(&self) -> Option<u32>;
+}
+
+impl TypeExt for Type {
+    fn read(&self, is: &str, primitive_type_variant: PrimitiveTypeVariant) -> String {
+        match (self, primitive_type_variant) {
+            (Type::TYPE_ENUM, _) => format!("{}.read_enum_or_unknown()", is),
+            (Type::TYPE_BYTES, PrimitiveTypeVariant::TokioBytes) => {
+                format!("{}.read_tokio_bytes()", is)
+            }
+            (Type::TYPE_STRING, PrimitiveTypeVariant::TokioBytes) => {
+                format!("{}.read_tokio_chars()", is)
+            }
+            _ => format!("{}.read_{}()", is, self.protobuf_name()),
+        }
+    }
+
+    /// True if self is signed integer with zigzag encoding
+    fn is_s_varint(&self) -> bool {
+        match *self {
+            Type::TYPE_SINT32 | Type::TYPE_SINT64 => true,
+            _ => false,
+        }
+    }
+
+    fn is_copy(&self) -> bool {
+        match self {
+            Type::TYPE_MESSAGE | Type::TYPE_STRING | Type::TYPE_BYTES => false,
+            _ => true,
+        }
+    }
+
+    fn protobuf_name(&self) -> &'static str {
+        match self {
+            Type::TYPE_DOUBLE => "double",
+            Type::TYPE_FLOAT => "float",
+            Type::TYPE_INT32 => "int32",
+            Type::TYPE_INT64 => "int64",
+            Type::TYPE_UINT32 => "uint32",
+            Type::TYPE_UINT64 => "uint64",
+            Type::TYPE_SINT32 => "sint32",
+            Type::TYPE_SINT64 => "sint64",
+            Type::TYPE_FIXED32 => "fixed32",
+            Type::TYPE_FIXED64 => "fixed64",
+            Type::TYPE_SFIXED32 => "sfixed32",
+            Type::TYPE_SFIXED64 => "sfixed64",
+            Type::TYPE_BOOL => "bool",
+            Type::TYPE_STRING => "string",
+            Type::TYPE_BYTES => "bytes",
+            Type::TYPE_ENUM => "enum",
+            Type::TYPE_MESSAGE => "message",
+            Type::TYPE_GROUP => "group",
+        }
+    }
+
+    /// Rust type for protobuf base type.
+    fn rust_type(&self) -> RustType {
+        match self {
+            Type::TYPE_DOUBLE => RustType::Float(64),
+            Type::TYPE_FLOAT => RustType::Float(32),
+            Type::TYPE_INT32 => RustType::Int(true, 32),
+            Type::TYPE_INT64 => RustType::Int(true, 64),
+            Type::TYPE_UINT32 => RustType::Int(false, 32),
+            Type::TYPE_UINT64 => RustType::Int(false, 64),
+            Type::TYPE_SINT32 => RustType::Int(true, 32),
+            Type::TYPE_SINT64 => RustType::Int(true, 64),
+            Type::TYPE_FIXED32 => RustType::Int(false, 32),
+            Type::TYPE_FIXED64 => RustType::Int(false, 64),
+            Type::TYPE_SFIXED32 => RustType::Int(true, 32),
+            Type::TYPE_SFIXED64 => RustType::Int(true, 64),
+            Type::TYPE_BOOL => RustType::Bool,
+            Type::TYPE_STRING => RustType::String,
+            Type::TYPE_BYTES => RustType::Vec(Box::new(RustType::u8())),
+            Type::TYPE_ENUM | Type::TYPE_GROUP | Type::TYPE_MESSAGE => {
+                panic!("there is no rust name for {:?}", self)
+            }
+        }
+    }
+
+    // type of `v` in `os.write_xxx_no_tag(v)`
+    fn os_write_fn_param_type(&self) -> RustType {
+        match self {
+            Type::TYPE_STRING => RustType::amp_str(),
+            Type::TYPE_BYTES => RustType::amp_slice_of_u8(),
+            Type::TYPE_ENUM => RustType::i32(),
+            t => t.rust_type(),
+        }
+    }
+
+    /// Size of value for type, None if variable.
+    fn encoded_size(&self) -> Option<u32> {
+        match self {
+            Type::TYPE_BOOL => Some(1),
+            Type::TYPE_FIXED32 => Some(4),
+            Type::TYPE_FIXED64 => Some(8),
+            Type::TYPE_SFIXED32 => Some(4),
+            Type::TYPE_SFIXED64 => Some(8),
+            Type::TYPE_FLOAT => Some(4),
+            Type::TYPE_DOUBLE => Some(8),
+            _ => None,
+        }
+    }
+}
diff --git a/src/gen/file.rs b/src/gen/file.rs
new file mode 100644
index 0000000..411b069
--- /dev/null
+++ b/src/gen/file.rs
@@ -0,0 +1,149 @@
+use std::collections::HashMap;
+
+use protobuf::descriptor::file_options;
+use protobuf::descriptor::FileDescriptorProto;
+use protobuf::reflect::FileDescriptor;
+use protobuf_parse::ProtoPath;
+
+use crate::compiler_plugin;
+use crate::customize::ctx::CustomizeElemCtx;
+use crate::customize::rustproto_proto::customize_from_rustproto_for_file;
+use crate::gen::code_writer::CodeWriter;
+use crate::gen::enums::EnumGen;
+use crate::gen::extensions::write_extensions;
+use crate::gen::file_descriptor::write_file_descriptor_data;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::message::MessageGen;
+use crate::gen::paths::proto_path_to_rust_mod;
+use crate::gen::scope::FileScope;
+use crate::gen::scope::RootScope;
+use crate::proto_name_to_rs;
+
+pub(crate) struct GenFileResult {
+    pub(crate) compiler_plugin_result: compiler_plugin::GenResult,
+    pub(crate) mod_name: String,
+}
+
+pub(crate) fn gen_file(
+    file_descriptor: &FileDescriptor,
+    _files_map: &HashMap<&ProtoPath, &FileDescriptor>,
+    root_scope: &RootScope,
+    parent_customize: &CustomizeElemCtx,
+    parser: &str,
+) -> anyhow::Result<GenFileResult> {
+    let lite_runtime_from_builtin_option = file_descriptor
+        .proto()
+        .options
+        .get_or_default()
+        .optimize_for()
+        == file_options::OptimizeMode::LITE_RUNTIME;
+
+    let mut customize_from_proto =
+        customize_from_rustproto_for_file(file_descriptor.proto().options.get_or_default());
+    if customize_from_proto.lite_runtime.is_none()
+        && parent_customize.for_elem.lite_runtime.is_none()
+    {
+        customize_from_proto.lite_runtime = Some(lite_runtime_from_builtin_option);
+    }
+
+    let customize = parent_customize.child(&customize_from_proto, file_descriptor);
+
+    let file_scope = FileScope { file_descriptor };
+    let scope = file_scope.to_scope();
+
+    let lite_runtime = customize.for_elem.lite_runtime.unwrap_or(false);
+
+    let v = CodeWriter::with(|w| {
+        w.write_generated_by("rust-protobuf", "3.2.0", parser);
+
+        w.write_line("");
+        w.write_line(&format!(
+            "//! Generated file from `{}`",
+            file_descriptor.proto().name()
+        ));
+
+        if customize.for_elem.lite_runtime.unwrap_or(false) {
+            w.comment("Generated for lite runtime");
+        }
+
+        if customize.for_elem.inside_protobuf != Some(true) {
+            w.write_line("");
+            w.write_line("/// Generated files are compatible only with the same version");
+            w.write_line("/// of protobuf runtime.");
+            w.write_line(&format!(
+                "const _PROTOBUF_VERSION_CHECK: () = {}::{};",
+                protobuf_crate_path(&customize.for_elem),
+                protobuf::VERSION_IDENT
+            ));
+        }
+
+        static NESTED_TYPE_NUMBER: protobuf::rt::Lazy<i32> = protobuf::rt::Lazy::new();
+        let message_type_number = *NESTED_TYPE_NUMBER.get(|| {
+            protobuf::reflect::MessageDescriptor::for_type::<FileDescriptorProto>()
+                .field_by_name("message_type")
+                .expect("`message_type` must exist")
+                .proto()
+                .number()
+        });
+
+        let mut path = vec![message_type_number, 0];
+        for (id, message) in scope.messages().iter().enumerate() {
+            // ignore map entries, because they are not used in map fields
+            if !message.is_map() {
+                path[1] = id as i32;
+
+                w.write_line("");
+                MessageGen::new(
+                    file_descriptor,
+                    message,
+                    &root_scope,
+                    &customize,
+                    &path,
+                    file_descriptor.proto().source_code_info.as_ref(),
+                )?
+                .write(w)?;
+            }
+        }
+
+        static ENUM_TYPE_NUMBER: protobuf::rt::Lazy<i32> = protobuf::rt::Lazy::new();
+        let enum_type_number = *ENUM_TYPE_NUMBER.get(|| {
+            protobuf::reflect::MessageDescriptor::for_type::<FileDescriptorProto>()
+                .field_by_name("enum_type")
+                .expect("`enum_type` must exist")
+                .proto()
+                .number()
+        });
+
+        let mut path = vec![enum_type_number, 0];
+        for (id, enum_type) in scope.enums().iter().enumerate() {
+            path[1] = id as i32;
+
+            w.write_line("");
+            EnumGen::new(
+                enum_type,
+                &customize,
+                root_scope,
+                &path,
+                file_descriptor.proto().source_code_info.as_ref(),
+            )
+            .write(w);
+        }
+
+        write_extensions(file_descriptor, &root_scope, w, &customize);
+
+        if !lite_runtime {
+            w.write_line("");
+            write_file_descriptor_data(file_descriptor, &customize.for_elem, w);
+        }
+
+        Ok(())
+    })?;
+
+    Ok(GenFileResult {
+        compiler_plugin_result: compiler_plugin::GenResult {
+            name: proto_name_to_rs(file_descriptor.proto().name()),
+            content: v.into_bytes(),
+        },
+        mod_name: proto_path_to_rust_mod(file_descriptor.proto().name()).into_string(),
+    })
+}
diff --git a/src/file_and_mod.rs b/src/gen/file_and_mod.rs
similarity index 60%
rename from src/file_and_mod.rs
rename to src/gen/file_and_mod.rs
index 4f4e8c6..8862c53 100644
--- a/src/file_and_mod.rs
+++ b/src/gen/file_and_mod.rs
@@ -1,7 +1,6 @@
-use rust_name::RustRelativePath;
-use Customize;
+use crate::customize::Customize;
+use crate::gen::rust::rel_path::RustRelativePath;
 
-#[allow(dead_code)]
 pub(crate) struct FileAndMod {
     pub file: String,
     pub relative_mod: RustRelativePath,
diff --git a/src/gen/file_descriptor.rs b/src/gen/file_descriptor.rs
new file mode 100644
index 0000000..2c8249c
--- /dev/null
+++ b/src/gen/file_descriptor.rs
@@ -0,0 +1,208 @@
+use std::fmt::Write as _;
+
+use protobuf::reflect::FileDescriptor;
+use protobuf::Message;
+
+use crate::gen::code_writer::CodeWriter;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::paths::proto_path_to_fn_file_descriptor;
+use crate::gen::rust::snippets::expr_vec_with_capacity_const;
+use crate::gen::scope::FileScope;
+use crate::gen::scope::Scope;
+use crate::gen::scope::WithScope;
+use crate::Customize;
+
+fn escape_byte(s: &mut String, b: u8) {
+    if b == b'\n' {
+        write!(s, "\\n").unwrap();
+    } else if b == b'\r' {
+        write!(s, "\\r").unwrap();
+    } else if b == b'\t' {
+        write!(s, "\\t").unwrap();
+    } else if b == b'\\' || b == b'"' {
+        write!(s, "\\{}", b as char).unwrap();
+    } else if b == b'\0' {
+        write!(s, "\\0").unwrap();
+    // ASCII printable except space
+    } else if b > 0x20 && b < 0x7f {
+        write!(s, "{}", b as char).unwrap();
+    } else {
+        write!(s, "\\x{:02x}", b).unwrap();
+    }
+}
+
+fn write_generate_file_descriptor(
+    file_descriptor: &FileDescriptor,
+    customize: &Customize,
+    w: &mut CodeWriter,
+) {
+    let deps = &file_descriptor.proto().dependency;
+    w.write_line(&format!(
+        "let mut deps = {vec_with_capacity};",
+        vec_with_capacity = expr_vec_with_capacity_const(deps.len())
+    ));
+    for f in deps {
+        w.write_line(&format!(
+            "deps.push({}().clone());",
+            proto_path_to_fn_file_descriptor(f, customize)
+        ));
+    }
+
+    let scope = FileScope { file_descriptor };
+
+    let messages = scope.find_messages_except_map();
+    w.write_line(&format!(
+        "let mut messages = {vec_with_capacity};",
+        vec_with_capacity = expr_vec_with_capacity_const(messages.len())
+    ));
+    for m in &messages {
+        w.write_line(&format!(
+            "messages.push({}::generated_message_descriptor_data());",
+            m.rust_name_to_file(),
+        ));
+    }
+
+    let enums = scope.find_enums();
+    w.write_line(&format!(
+        "let mut enums = {};",
+        expr_vec_with_capacity_const(enums.len())
+    ));
+    for e in &enums {
+        w.write_line(&format!(
+            "enums.push({}::generated_enum_descriptor_data());",
+            e.rust_name_to_file(),
+        ));
+    }
+
+    w.write_line(&format!(
+        "{}::reflect::GeneratedFileDescriptor::new_generated(",
+        protobuf_crate_path(&customize),
+    ));
+    w.indented(|w| {
+        w.write_line(&format!("file_descriptor_proto(),"));
+        w.write_line(&format!("deps,"));
+        w.write_line(&format!("messages,"));
+        w.write_line(&format!("enums,"));
+    });
+    w.write_line(")");
+}
+
+fn write_file_descriptor(
+    file_descriptor: &FileDescriptor,
+    customize: &Customize,
+    w: &mut CodeWriter,
+) {
+    w.write_line("/// `FileDescriptor` object which allows dynamic access to files");
+    w.pub_fn(
+        &format!(
+            "file_descriptor() -> &'static {protobuf_crate}::reflect::FileDescriptor",
+            protobuf_crate = protobuf_crate_path(customize)
+        ),
+        |w| {
+            w.lazy_static(
+                "generated_file_descriptor_lazy",
+                &format!(
+                    "{protobuf_crate}::reflect::GeneratedFileDescriptor",
+                    protobuf_crate = protobuf_crate_path(customize)
+                ),
+                &format!("{}", protobuf_crate_path(customize)),
+            );
+            w.lazy_static_decl_get(
+                "file_descriptor",
+                &format!(
+                    "{protobuf_crate}::reflect::FileDescriptor",
+                    protobuf_crate = protobuf_crate_path(customize)
+                ),
+                &format!("{}", protobuf_crate_path(customize)),
+                |w| {
+                    w.block(
+                        "let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {",
+                        "});",
+                        |w| write_generate_file_descriptor(file_descriptor, customize, w),
+                    );
+                    w.write_line(&format!(
+                        "{protobuf_crate}::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)",
+                        protobuf_crate=protobuf_crate_path(&customize),
+                    ));
+                }
+            );
+        },
+    );
+}
+
+pub(crate) fn write_file_descriptor_data(
+    file: &FileDescriptor,
+    customize: &Customize,
+    w: &mut CodeWriter,
+) {
+    let fdp_bytes = file.proto().write_to_bytes().unwrap();
+    w.write_line("static file_descriptor_proto_data: &'static [u8] = b\"\\");
+    w.indented(|w| {
+        const MAX_LINE_LEN: usize = 72;
+
+        let mut s = String::new();
+        for &b in &fdp_bytes {
+            let prev_len = s.len();
+            escape_byte(&mut s, b);
+            let truncate = s.len() > MAX_LINE_LEN;
+            if truncate {
+                s.truncate(prev_len);
+            }
+            if truncate || s.len() == MAX_LINE_LEN {
+                write!(s, "\\").unwrap();
+                w.write_line(&s);
+                s.clear();
+            }
+            if truncate {
+                escape_byte(&mut s, b);
+            }
+        }
+        if !s.is_empty() {
+            write!(s, "\\").unwrap();
+            w.write_line(&s);
+            s.clear();
+        }
+    });
+    w.write_line("\";");
+    w.write_line("");
+    write_file_descriptor_proto(&customize, w);
+    w.write_line("");
+    write_file_descriptor(file, &customize, w);
+}
+
+fn write_file_descriptor_proto(customize: &Customize, w: &mut CodeWriter) {
+    w.write_line("/// `FileDescriptorProto` object which was a source for this generated file");
+    w.def_fn(
+        &format!(
+            "file_descriptor_proto() -> &'static {protobuf_crate}::descriptor::FileDescriptorProto",
+            protobuf_crate=protobuf_crate_path(customize)
+        ),
+        |w| {
+            w.lazy_static_decl_get(
+                "file_descriptor_proto_lazy",
+                &format!(
+                    "{protobuf_crate}::descriptor::FileDescriptorProto",
+                    protobuf_crate=protobuf_crate_path(customize)
+                ),
+                &format!("{}", protobuf_crate_path(customize)),
+                |w| {
+                    w.write_line(&format!(
+                        "{protobuf_crate}::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()",
+                        protobuf_crate=protobuf_crate_path(customize)
+                    ));
+                },
+            );
+        },
+    );
+}
+
+/// Code to generate call `module::file_descriptor()`.
+pub(crate) fn file_descriptor_call_expr(scope: &Scope) -> String {
+    format!(
+        "{}()",
+        scope
+            .rust_path_to_file()
+            .to_reverse()
+            .append_ident("file_descriptor".into())
+    )
+}
diff --git a/src/gen/inside.rs b/src/gen/inside.rs
new file mode 100644
index 0000000..d416031
--- /dev/null
+++ b/src/gen/inside.rs
@@ -0,0 +1,11 @@
+use crate::customize::Customize;
+use crate::gen::rust::path::RustPath;
+
+/// Path to `protobuf` crate, different when `.proto` file is
+/// used inside or outside of protobuf crate.
+pub(crate) fn protobuf_crate_path(customize: &Customize) -> RustPath {
+    match customize.inside_protobuf {
+        Some(true) => RustPath::from("crate"),
+        _ => RustPath::from("::protobuf"),
+    }
+}
diff --git a/src/gen/map.rs b/src/gen/map.rs
new file mode 100644
index 0000000..ba50eeb
--- /dev/null
+++ b/src/gen/map.rs
@@ -0,0 +1,16 @@
+use crate::gen::scope::FieldWithContext;
+use crate::gen::scope::MessageWithScope;
+
+/// Pair of (key, value) if this message is map entry
+pub(crate) fn map_entry<'a>(
+    d: &'a MessageWithScope,
+) -> Option<(FieldWithContext<'a>, FieldWithContext<'a>)> {
+    if d.message.is_map_entry() {
+        // `MessageDescriptor` validated the fields.
+        let key = d.fields()[0].clone();
+        let value = d.fields()[1].clone();
+        Some((key, value))
+    } else {
+        None
+    }
+}
diff --git a/src/gen/message.rs b/src/gen/message.rs
new file mode 100644
index 0000000..3471f87
--- /dev/null
+++ b/src/gen/message.rs
@@ -0,0 +1,786 @@
+use std::fmt;
+
+use protobuf::descriptor::*;
+use protobuf::reflect::FileDescriptor;
+use protobuf::reflect::MessageDescriptor;
+use protobuf_parse::snake_case;
+
+use crate::customize::ctx::CustomizeElemCtx;
+use crate::customize::ctx::SpecialFieldPseudoDescriptor;
+use crate::customize::rustproto_proto::customize_from_rustproto_for_message;
+use crate::gen::code_writer::*;
+use crate::gen::descriptor::write_fn_descriptor;
+use crate::gen::enums::*;
+use crate::gen::field::FieldGen;
+use crate::gen::field::FieldKind;
+use crate::gen::file_and_mod::FileAndMod;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::oneof::OneofGen;
+use crate::gen::oneof::OneofVariantGen;
+use crate::gen::protoc_insertion_point::write_protoc_insertion_point_for_message;
+use crate::gen::protoc_insertion_point::write_protoc_insertion_point_for_special_field;
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::ident_with_path::RustIdentWithPath;
+use crate::gen::rust::rel_path::RustRelativePath;
+use crate::gen::rust::snippets::expr_vec_with_capacity_const;
+use crate::gen::rust::snippets::EXPR_NONE;
+use crate::gen::rust_types_values::*;
+use crate::gen::scope::MessageWithScope;
+use crate::gen::scope::RootScope;
+use crate::gen::scope::WithScope;
+use crate::Customize;
+
+/// Protobuf message Rust type name
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RustTypeMessage(pub RustIdentWithPath);
+
+impl fmt::Display for RustTypeMessage {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl<S: Into<RustIdentWithPath>> From<S> for RustTypeMessage {
+    fn from(s: S) -> Self {
+        RustTypeMessage(s.into())
+    }
+}
+
+impl RustTypeMessage {
+    /// Code which emits default instance.
+    pub fn default_instance(&self, customize: &Customize) -> String {
+        format!(
+            "<{} as {}::Message>::default_instance()",
+            self.0,
+            protobuf_crate_path(customize)
+        )
+    }
+}
+
+/// Message info for codegen
+pub(crate) struct MessageGen<'a> {
+    file_descriptor: &'a FileDescriptor,
+    message_descriptor: MessageDescriptor,
+    pub message: &'a MessageWithScope<'a>,
+    pub root_scope: &'a RootScope<'a>,
+    pub fields: Vec<FieldGen<'a>>,
+    pub lite_runtime: bool,
+    customize: CustomizeElemCtx<'a>,
+    path: &'a [i32],
+    info: Option<&'a SourceCodeInfo>,
+}
+
+impl<'a> MessageGen<'a> {
+    pub fn new(
+        file_descriptor: &'a FileDescriptor,
+        message: &'a MessageWithScope<'a>,
+        root_scope: &'a RootScope<'a>,
+        parent_customize: &CustomizeElemCtx<'a>,
+        path: &'a [i32],
+        info: Option<&'a SourceCodeInfo>,
+    ) -> anyhow::Result<MessageGen<'a>> {
+        let message_descriptor = file_descriptor
+            .message_by_package_relative_name(&format!("{}", message.protobuf_name_to_package()))
+            .unwrap();
+
+        let customize = parent_customize.child(
+            &customize_from_rustproto_for_message(message.message.proto().options.get_or_default()),
+            &message.message,
+        );
+
+        static FIELD_NUMBER: protobuf::rt::Lazy<i32> = protobuf::rt::Lazy::new();
+        let field_number = *FIELD_NUMBER.get(|| {
+            protobuf::reflect::MessageDescriptor::for_type::<DescriptorProto>()
+                .field_by_name("field")
+                .expect("`field` must exist")
+                .proto()
+                .number()
+        });
+
+        let fields: Vec<_> = message
+            .fields()
+            .into_iter()
+            .enumerate()
+            .map(|(id, field)| {
+                let mut path = path.to_vec();
+                path.extend_from_slice(&[field_number, id as i32]);
+                FieldGen::parse(field, root_scope, &customize, path, info)
+            })
+            .collect::<anyhow::Result<Vec<_>>>()?;
+        let lite_runtime = customize.for_elem.lite_runtime.unwrap_or_else(|| {
+            message.file_descriptor().proto().options.optimize_for()
+                == file_options::OptimizeMode::LITE_RUNTIME
+        });
+        Ok(MessageGen {
+            message_descriptor,
+            file_descriptor,
+            message,
+            root_scope,
+            fields,
+            lite_runtime,
+            customize,
+            path,
+            info,
+        })
+    }
+
+    fn rust_name(&self) -> RustIdent {
+        self.message.rust_name()
+    }
+
+    fn mod_name(&self) -> RustRelativePath {
+        self.message.scope.rust_path_to_file()
+    }
+
+    pub fn file_and_mod(&self) -> FileAndMod {
+        self.message
+            .scope
+            .file_and_mod(self.customize.for_elem.clone())
+    }
+
+    fn oneofs(&'a self) -> Vec<OneofGen<'a>> {
+        self.message
+            .oneofs()
+            .into_iter()
+            .map(|oneof| OneofGen::parse(self, oneof, &self.customize))
+            .collect()
+    }
+
+    fn required_fields(&'a self) -> Vec<&'a FieldGen> {
+        self.fields
+            .iter()
+            .filter(|f| match f.kind {
+                FieldKind::Singular(ref singular) => singular.flag.is_required(),
+                _ => false,
+            })
+            .collect()
+    }
+
+    fn message_fields(&'a self) -> Vec<&'a FieldGen> {
+        self.fields
+            .iter()
+            .filter(|f| f.proto_type == field_descriptor_proto::Type::TYPE_MESSAGE)
+            .collect()
+    }
+
+    fn fields_except_oneof(&'a self) -> Vec<&'a FieldGen> {
+        self.fields
+            .iter()
+            .filter(|f| match f.kind {
+                FieldKind::Oneof(..) => false,
+                _ => true,
+            })
+            .collect()
+    }
+
+    fn fields_except_group(&'a self) -> Vec<&'a FieldGen> {
+        self.fields
+            .iter()
+            .filter(|f| f.proto_type != field_descriptor_proto::Type::TYPE_GROUP)
+            .collect()
+    }
+
+    fn fields_except_oneof_and_group(&'a self) -> Vec<&'a FieldGen> {
+        self.fields
+            .iter()
+            .filter(|f| match f.kind {
+                FieldKind::Oneof(..) => false,
+                _ => f.proto_type != field_descriptor_proto::Type::TYPE_GROUP,
+            })
+            .collect()
+    }
+
+    fn write_match_each_oneof_variant<F>(&self, w: &mut CodeWriter, cb: F)
+    where
+        F: Fn(&mut CodeWriter, &OneofVariantGen, &RustValueTyped),
+    {
+        for oneof in self.oneofs() {
+            let variants = oneof.variants_except_group();
+            if variants.is_empty() {
+                // Special case because
+                // https://github.com/rust-lang/rust/issues/50642
+                continue;
+            }
+            w.if_let_stmt(
+                "::std::option::Option::Some(ref v)",
+                &format!("self.{}", oneof.oneof.field_name())[..],
+                |w| {
+                    w.match_block("v", |w| {
+                        for variant in variants {
+                            let ref field = variant.field;
+
+                            let (refv, vtype) = if field.elem_type_is_copy() {
+                                ("v", variant.rust_type(&self.file_and_mod()))
+                            } else {
+                                ("ref v", variant.rust_type(&self.file_and_mod()).ref_type())
+                            };
+                            w.case_block(
+                                format!("&{}({})", variant.path(&self.file_and_mod()), refv),
+                                |w| {
+                                    cb(
+                                        w,
+                                        &variant,
+                                        &RustValueTyped {
+                                            value: "v".to_owned(),
+                                            rust_type: vtype.clone(),
+                                        },
+                                    );
+                                },
+                            );
+                        }
+                    });
+                },
+            );
+        }
+    }
+
+    fn write_write_to_with_cached_sizes(&self, w: &mut CodeWriter) {
+        let sig = format!(
+            "write_to_with_cached_sizes(&self, os: &mut {protobuf_crate}::CodedOutputStream<'_>) -> {protobuf_crate}::Result<()>",
+            protobuf_crate=protobuf_crate_path(&self.customize.for_elem),
+        );
+        w.def_fn(&sig, |w| {
+            // To have access to its methods but not polute the name space.
+            for f in self.fields_except_oneof_and_group() {
+                f.write_message_write_field("os", w);
+            }
+            self.write_match_each_oneof_variant(w, |w, variant, v| {
+                variant
+                    .field
+                    .write_write_element(variant.elem(), w, "os", v);
+            });
+            w.write_line("os.write_unknown_fields(self.special_fields.unknown_fields())?;");
+            w.write_line("::std::result::Result::Ok(())");
+        });
+    }
+
+    fn write_default_instance_lazy(&self, w: &mut CodeWriter) {
+        w.lazy_static_decl_get_simple(
+            "instance",
+            &format!("{}", self.rust_name()),
+            &format!("{}::new", self.rust_name()),
+            &format!("{}", protobuf_crate_path(&self.customize.for_elem)),
+        );
+    }
+
+    fn write_default_instance_static(&self, w: &mut CodeWriter) {
+        w.stmt_block(
+            &format!(
+                "static instance: {} = {}",
+                self.rust_name(),
+                self.rust_name()
+            ),
+            |w| {
+                for f in &self.fields_except_oneof_and_group() {
+                    w.field_entry(
+                        &f.rust_name.to_string(),
+                        &f.kind
+                            .default(&self.customize.for_elem, &self.file_and_mod(), true),
+                    );
+                }
+                for o in &self.oneofs() {
+                    w.field_entry(&o.oneof.field_name().to_string(), EXPR_NONE);
+                }
+                w.field_entry(
+                    "special_fields",
+                    &format!(
+                        "{}::SpecialFields::new()",
+                        protobuf_crate_path(&self.customize.for_elem)
+                    ),
+                );
+            },
+        );
+        w.write_line("&instance");
+    }
+
+    fn write_default_instance(&self, w: &mut CodeWriter) {
+        w.def_fn(
+            &format!("default_instance() -> &'static {}", self.rust_name()),
+            |w| {
+                let has_map_field = self.fields.iter().any(|f| match f.kind {
+                    FieldKind::Map(..) => true,
+                    _ => false,
+                });
+                if has_map_field {
+                    self.write_default_instance_lazy(w)
+                } else {
+                    self.write_default_instance_static(w)
+                }
+            },
+        );
+    }
+
+    fn write_compute_size(&self, w: &mut CodeWriter) {
+        // Append sizes of messages in the tree to the specified vector.
+        // First appended element is size of self, and then nested message sizes.
+        // in serialization order are appended recursively.");
+        w.comment("Compute sizes of nested messages");
+        // there are unused variables in oneof
+        w.allow(&["unused_variables"]);
+        w.def_fn("compute_size(&self) -> u64", |w| {
+            // To have access to its methods but not polute the name space.
+            w.write_line("let mut my_size = 0;");
+            for field in self.fields_except_oneof_and_group() {
+                field.write_message_compute_field_size("my_size", w);
+            }
+            self.write_match_each_oneof_variant(w, |w, variant, v| {
+                variant
+                    .field
+                    .write_element_size(variant.elem(), w, v, "my_size");
+            });
+            w.write_line(&format!(
+                "my_size += {}::rt::unknown_fields_size(self.special_fields.unknown_fields());",
+                protobuf_crate_path(&self.customize.for_elem)
+            ));
+            w.write_line("self.special_fields.cached_size().set(my_size as u32);");
+            w.write_line("my_size");
+        });
+    }
+
+    fn write_field_accessors(&self, w: &mut CodeWriter) {
+        for f in self.fields_except_group() {
+            f.write_message_single_field_accessors(w);
+        }
+    }
+
+    fn write_impl_self(&self, w: &mut CodeWriter) {
+        w.impl_self_block(&format!("{}", self.rust_name()), |w| {
+            w.pub_fn(&format!("new() -> {}", self.rust_name()), |w| {
+                w.write_line("::std::default::Default::default()");
+            });
+
+            self.write_field_accessors(w);
+
+            if !self.lite_runtime {
+                w.write_line("");
+                self.write_generated_message_descriptor_data(w);
+            }
+        });
+    }
+
+    fn write_unknown_fields(&self, w: &mut CodeWriter) {
+        let sig = format!(
+            "special_fields(&self) -> &{}::SpecialFields",
+            protobuf_crate_path(&self.customize.for_elem)
+        );
+        w.def_fn(&sig, |w| {
+            w.write_line("&self.special_fields");
+        });
+        w.write_line("");
+        let sig = format!(
+            "mut_special_fields(&mut self) -> &mut {}::SpecialFields",
+            protobuf_crate_path(&self.customize.for_elem)
+        );
+        w.def_fn(&sig, |w| {
+            w.write_line("&mut self.special_fields");
+        });
+    }
+
+    fn write_merge_from(&self, w: &mut CodeWriter) {
+        let sig = format!(
+            "merge_from(&mut self, is: &mut {}::CodedInputStream<'_>) -> {}::Result<()>",
+            protobuf_crate_path(&self.customize.for_elem),
+            protobuf_crate_path(&self.customize.for_elem),
+        );
+        w.def_fn(&sig, |w| {
+            w.while_block("let Some(tag) = is.read_raw_tag_or_eof()?", |w| {
+                w.match_block("tag", |w| {
+                    for f in &self.fields_except_group() {
+                        f.write_merge_from_field_case_block(w);
+                    }
+                    w.case_block("tag", |w| {
+                        w.write_line(&format!("{}::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;", protobuf_crate_path(&self.customize.for_elem)));
+                    });
+                });
+            });
+            w.write_line("::std::result::Result::Ok(())");
+        });
+    }
+
+    fn write_impl_message_full_fn_descriptor(&self, w: &mut CodeWriter) {
+        write_fn_descriptor(
+            &self.message.message,
+            self.message.scope(),
+            &self.customize.for_elem,
+            w,
+        );
+    }
+
+    fn write_generated_message_descriptor_data(&self, w: &mut CodeWriter) {
+        let sig = format!(
+            "generated_message_descriptor_data() -> {}::reflect::GeneratedMessageDescriptorData",
+            protobuf_crate_path(&self.customize.for_elem)
+        );
+        w.fn_block(
+            Visibility::Path(self.message.scope().rust_path_to_file().to_reverse()),
+            &sig,
+            |w| {
+                let fields = self.fields_except_group();
+                let oneofs = self.oneofs();
+                w.write_line(&format!(
+                    "let mut fields = {};",
+                    expr_vec_with_capacity_const(fields.len())
+                ));
+                w.write_line(&format!(
+                    "let mut oneofs = {};",
+                    expr_vec_with_capacity_const(oneofs.len())
+                ));
+                for field in fields {
+                    field.write_push_accessor("fields", w);
+                }
+                for oneof in oneofs {
+                    w.write_line(&format!(
+                        "oneofs.push({}::generated_oneof_descriptor_data());",
+                        oneof.type_name_relative(&self.mod_name())
+                    ));
+                }
+                w.write_line(&format!(
+                    "{}::reflect::GeneratedMessageDescriptorData::new_2::<{}>(",
+                    protobuf_crate_path(&self.customize.for_elem),
+                    self.rust_name(),
+                ));
+                w.indented(|w| {
+                    w.write_line(&format!("\"{}\",", self.message.name_to_package()));
+                    w.write_line("fields,");
+                    w.write_line("oneofs,");
+                });
+                w.write_line(")");
+            },
+        );
+    }
+
+    fn write_is_initialized(&self, w: &mut CodeWriter) {
+        w.def_fn(&format!("is_initialized(&self) -> bool"), |w| {
+            if !self.message.message.is_initialized_is_always_true() {
+                // TODO: use single loop
+
+                for f in self.required_fields() {
+                    f.write_if_self_field_is_none(w, |w| {
+                        w.write_line("return false;");
+                    });
+                }
+
+                for f in self.message_fields() {
+                    if let FieldKind::Map(..) = f.kind {
+                        // TODO
+                        w.comment("TODO: check map values are initialized");
+                        continue;
+                    }
+
+                    f.write_for_self_field(w, "v", |w, _t| {
+                        w.if_stmt("!v.is_initialized()", |w| {
+                            w.write_line("return false;");
+                        });
+                    });
+                }
+            }
+            w.write_line("true");
+        });
+    }
+
+    fn write_impl_message(&self, w: &mut CodeWriter) {
+        w.impl_for_block(
+            &format!("{}::Message", protobuf_crate_path(&self.customize.for_elem),),
+            &format!("{}", self.rust_name()),
+            |w| {
+                w.write_line(&format!(
+                    "const NAME: &'static str = \"{}\";",
+                    self.message.message.name()
+                ));
+                w.write_line("");
+                self.write_is_initialized(w);
+                w.write_line("");
+                self.write_merge_from(w);
+                w.write_line("");
+                self.write_compute_size(w);
+                w.write_line("");
+                self.write_write_to_with_cached_sizes(w);
+                w.write_line("");
+                self.write_unknown_fields(w);
+                w.write_line("");
+                w.def_fn(&format!("new() -> {}", self.rust_name()), |w| {
+                    w.write_line(&format!("{}::new()", self.rust_name()));
+                });
+                w.write_line("");
+                w.def_fn("clear(&mut self)", |w| {
+                    for f in self.fields_except_group() {
+                        f.write_clear(w);
+                    }
+                    w.write_line("self.special_fields.clear();");
+                });
+                w.write_line("");
+                self.write_default_instance(w);
+            },
+        );
+    }
+
+    fn write_impl_message_full(&self, w: &mut CodeWriter) {
+        w.impl_for_block(
+            &format!(
+                "{}::MessageFull",
+                protobuf_crate_path(&self.customize.for_elem),
+            ),
+            &format!("{}", self.rust_name()),
+            |w| {
+                self.write_impl_message_full_fn_descriptor(w);
+            },
+        );
+    }
+
+    fn write_impl_value(&self, w: &mut CodeWriter) {
+        w.impl_for_block(
+            &format!(
+                "{}::reflect::ProtobufValue",
+                protobuf_crate_path(&self.customize.for_elem)
+            ),
+            &format!("{}", self.rust_name()),
+            |w| {
+                w.write_line(&format!(
+                    "type RuntimeType = {}::reflect::rt::RuntimeTypeMessage<Self>;",
+                    protobuf_crate_path(&self.customize.for_elem)
+                ));
+            },
+        )
+    }
+
+    fn write_impl_display(&self, w: &mut CodeWriter) {
+        w.impl_for_block(
+            "::std::fmt::Display",
+            &format!("{}", self.rust_name()),
+            |w| {
+                w.def_fn(
+                    "fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result",
+                    |w| {
+                        w.write_line(&format!(
+                            "{}::text_format::fmt(self, f)",
+                            protobuf_crate_path(&self.customize.for_elem)
+                        ));
+                    },
+                );
+            },
+        );
+    }
+
+    fn supports_derive_partial_eq(&self) -> bool {
+        // There's stack overflow in the compiler when struct has too many fields
+        // https://github.com/rust-lang/rust/issues/40119
+        self.fields.len() <= 500
+    }
+
+    fn write_struct(&self, w: &mut CodeWriter) {
+        let mut derive = Vec::new();
+        if self.supports_derive_partial_eq() {
+            derive.push("PartialEq");
+        }
+        derive.extend(&["Clone", "Default", "Debug"]);
+        w.derive(&derive);
+        write_protoc_insertion_point_for_message(
+            w,
+            &self.customize.for_elem,
+            &self.message_descriptor,
+        );
+        w.pub_struct(&format!("{}", self.rust_name()), |w| {
+            if !self.fields_except_oneof().is_empty() {
+                w.comment("message fields");
+                for field in self.fields_except_oneof() {
+                    field.write_struct_field(w);
+                }
+            }
+            if !self.oneofs().is_empty() {
+                w.comment("message oneof groups");
+                for oneof in self.oneofs() {
+                    w.field_decl_vis(
+                        Visibility::Public,
+                        &oneof.oneof.field_name().to_string(),
+                        &oneof.full_storage_type().to_code(&self.customize.for_elem),
+                    );
+                }
+            }
+            w.comment("special fields");
+
+            let customize_special_fields = self
+                .customize
+                .child(
+                    &Customize::default(),
+                    &SpecialFieldPseudoDescriptor {
+                        message: &self.message.message,
+                        field: "special_fields",
+                    },
+                )
+                .for_elem;
+
+            write_protoc_insertion_point_for_special_field(
+                w,
+                &customize_special_fields,
+                &self.message_descriptor,
+                "special_fields",
+            );
+            w.pub_field_decl(
+                "special_fields",
+                &format!(
+                    "{}::SpecialFields",
+                    protobuf_crate_path(&self.customize.for_elem)
+                ),
+            );
+        });
+    }
+
+    fn write_impl_default_for_amp(&self, w: &mut CodeWriter) {
+        w.impl_args_for_block(
+            &["'a"],
+            "::std::default::Default",
+            &format!("&'a {}", self.rust_name()),
+            |w| {
+                w.def_fn(&format!("default() -> &'a {}", self.rust_name()), |w| {
+                    w.write_line(&format!(
+                        "<{} as {}::Message>::default_instance()",
+                        self.rust_name(),
+                        protobuf_crate_path(&self.customize.for_elem),
+                    ));
+                });
+            },
+        );
+    }
+
+    fn write_dummy_impl_partial_eq(&self, w: &mut CodeWriter) {
+        w.impl_for_block(
+            "::std::cmp::PartialEq",
+            &format!("{}", self.rust_name()),
+            |w| {
+                w.def_fn("eq(&self, _: &Self) -> bool", |w| {
+                    w.comment("https://github.com/rust-lang/rust/issues/40119");
+                    w.unimplemented();
+                });
+            },
+        );
+    }
+
+    pub fn write(&self, w: &mut CodeWriter) -> anyhow::Result<()> {
+        w.all_documentation(self.info, self.path);
+        self.write_struct(w);
+
+        w.write_line("");
+        self.write_impl_default_for_amp(w);
+
+        if !self.supports_derive_partial_eq() {
+            w.write_line("");
+            self.write_dummy_impl_partial_eq(w);
+        }
+
+        w.write_line("");
+        self.write_impl_self(w);
+        w.write_line("");
+        self.write_impl_message(w);
+        if !self.lite_runtime {
+            w.write_line("");
+            self.write_impl_message_full(w);
+        }
+        if !self.lite_runtime {
+            w.write_line("");
+            self.write_impl_display(w);
+
+            w.write_line("");
+            self.write_impl_value(w);
+        }
+
+        let mod_name = message_name_to_nested_mod_name(&self.message.message.name());
+
+        let oneofs = self.oneofs();
+        let nested_messages: Vec<_> = self
+            .message
+            .to_scope()
+            .messages()
+            .into_iter()
+            .filter(|nested| {
+                // ignore map entries, because they are not used in map fields
+                !nested.is_map()
+            })
+            .collect();
+        let nested_enums = self.message.to_scope().enums();
+
+        if !oneofs.is_empty() || !nested_messages.is_empty() || !nested_enums.is_empty() {
+            w.write_line("");
+            w.write_line(&format!(
+                "/// Nested message and enums of message `{}`",
+                self.message.message.name()
+            ));
+            w.pub_mod(&mod_name.to_string(), |w| {
+                let mut first = true;
+
+                for oneof in &oneofs {
+                    w.write_line("");
+                    oneof.write(w);
+                }
+
+                static NESTED_TYPE_NUMBER: protobuf::rt::Lazy<i32> = protobuf::rt::Lazy::new();
+                let nested_type_number = *NESTED_TYPE_NUMBER.get(|| {
+                    MessageDescriptor::for_type::<DescriptorProto>()
+                        .field_by_name("nested_type")
+                        .expect("`nested_type` must exist")
+                        .proto()
+                        .number()
+                });
+
+                let mut path = self.path.to_vec();
+                path.extend(&[nested_type_number, 0]);
+                for (id, nested) in nested_messages.iter().enumerate() {
+                    let len = path.len() - 1;
+                    path[len] = id as i32;
+
+                    if !first {
+                        w.write_line("");
+                    }
+                    first = false;
+                    MessageGen::new(
+                        &self.file_descriptor,
+                        nested,
+                        self.root_scope,
+                        &self.customize,
+                        &path,
+                        self.info,
+                    )
+                    // TODO: do not unwrap.
+                    .unwrap()
+                    .write(w)
+                    // TODO: do not unwrap.
+                    .unwrap();
+                }
+
+                static ENUM_TYPE_NUMBER: protobuf::rt::Lazy<i32> = protobuf::rt::Lazy::new();
+                let enum_type_number = *ENUM_TYPE_NUMBER.get(|| {
+                    MessageDescriptor::for_type::<DescriptorProto>()
+                        .field_by_name("enum_type")
+                        .expect("`enum_type` must exist")
+                        .proto()
+                        .number()
+                });
+
+                let len = path.len() - 2;
+                path[len] = enum_type_number;
+                for (id, enum_type) in self.message.to_scope().enums().iter().enumerate() {
+                    let len = path.len() - 1;
+                    path[len] = id as i32;
+
+                    if !first {
+                        w.write_line("");
+                    }
+                    first = false;
+                    EnumGen::new(
+                        enum_type,
+                        &self.customize,
+                        self.root_scope,
+                        &path,
+                        self.info,
+                    )
+                    .write(w);
+                }
+            });
+        }
+        Ok(())
+    }
+}
+
+pub(crate) fn message_name_to_nested_mod_name(message_name: &str) -> RustIdent {
+    let mod_name = snake_case(message_name);
+    RustIdent::new(&mod_name)
+}
diff --git a/src/gen/mod.rs b/src/gen/mod.rs
new file mode 100644
index 0000000..6d0435c
--- /dev/null
+++ b/src/gen/mod.rs
@@ -0,0 +1,21 @@
+pub(crate) mod all;
+pub(crate) mod code_writer;
+pub(crate) mod descriptor;
+pub(crate) mod enums;
+pub(crate) mod extensions;
+pub(crate) mod field;
+pub(crate) mod file;
+pub(crate) mod file_and_mod;
+pub(crate) mod file_descriptor;
+pub(crate) mod inside;
+mod map;
+pub(crate) mod message;
+pub(crate) mod mod_rs;
+pub(crate) mod oneof;
+pub(crate) mod paths;
+pub(crate) mod protoc_insertion_point;
+pub(crate) mod rust;
+pub(crate) mod rust_types_values;
+pub(crate) mod scope;
+pub(crate) mod strx;
+pub(crate) mod well_known_types;
diff --git a/src/gen/mod_rs.rs b/src/gen/mod_rs.rs
new file mode 100644
index 0000000..a149319
--- /dev/null
+++ b/src/gen/mod_rs.rs
@@ -0,0 +1,18 @@
+use crate::compiler_plugin;
+use crate::gen::code_writer::CodeWriter;
+
+pub(crate) fn gen_mod_rs(mods: &[String]) -> compiler_plugin::GenResult {
+    let v = CodeWriter::with_no_error(|w| {
+        w.comment(&format!("{}generated", "@"));
+        w.write_line("");
+        let mut mods: Vec<&String> = mods.into_iter().collect();
+        mods.sort();
+        for m in mods {
+            w.write_line(&format!("pub mod {};", m));
+        }
+    });
+    compiler_plugin::GenResult {
+        name: "mod.rs".to_owned(),
+        content: v.into_bytes(),
+    }
+}
diff --git a/src/gen/oneof.rs b/src/gen/oneof.rs
new file mode 100644
index 0000000..3f34cdc
--- /dev/null
+++ b/src/gen/oneof.rs
@@ -0,0 +1,373 @@
+//! Oneof-related codegen functions.
+
+use std::collections::HashSet;
+
+use protobuf::descriptor::field_descriptor_proto;
+use protobuf::descriptor::file_options;
+use protobuf::reflect::FieldDescriptor;
+use protobuf_parse::ProtobufAbsPath;
+
+use crate::customize::ctx::CustomizeElemCtx;
+use crate::customize::Customize;
+use crate::gen::code_writer::CodeWriter;
+use crate::gen::code_writer::Visibility;
+use crate::gen::field::elem::FieldElem;
+use crate::gen::field::rust_variant_name_for_protobuf_oneof_field_name;
+use crate::gen::field::FieldGen;
+use crate::gen::file_and_mod::FileAndMod;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::message::MessageGen;
+use crate::gen::protoc_insertion_point::write_protoc_insertion_point_for_oneof;
+use crate::gen::protoc_insertion_point::write_protoc_insertion_point_for_oneof_field;
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::ident_with_path::RustIdentWithPath;
+use crate::gen::rust::path::RustPath;
+use crate::gen::rust::rel_path::RustRelativePath;
+use crate::gen::rust_types_values::make_path;
+use crate::gen::rust_types_values::RustType;
+use crate::gen::scope::OneofVariantWithContext;
+use crate::gen::scope::OneofWithContext;
+use crate::gen::scope::RootScope;
+use crate::gen::scope::WithScope;
+
+// oneof one { ... }
+#[derive(Clone)]
+pub(crate) struct OneofField<'a> {
+    pub elem: FieldElem<'a>,
+    pub oneof_variant_rust_name: RustIdent,
+    pub oneof_field_name: RustIdent,
+    pub type_name: RustIdentWithPath,
+    pub boxed: bool,
+}
+
+impl<'a> OneofField<'a> {
+    // Detecting recursion: if oneof fields contains a self-reference
+    // or another message which has a reference to self,
+    // put oneof variant into a box.
+    fn need_boxed(
+        field: &FieldDescriptor,
+        root_scope: &RootScope,
+        owner_name: &ProtobufAbsPath,
+    ) -> bool {
+        let mut visited_messages = HashSet::new();
+        let mut fields = vec![field.clone()];
+        while let Some(field) = fields.pop() {
+            if field.proto().type_() == field_descriptor_proto::Type::TYPE_MESSAGE {
+                let message_name = ProtobufAbsPath::from(field.proto().type_name());
+                if !visited_messages.insert(message_name.clone()) {
+                    continue;
+                }
+                if message_name == *owner_name {
+                    return true;
+                }
+                let message = root_scope.find_message(&message_name);
+                fields.extend(
+                    message
+                        .message
+                        .fields()
+                        .into_iter()
+                        .filter(|f| f.containing_oneof().is_some()),
+                );
+            }
+        }
+        false
+    }
+
+    pub fn parse(
+        oneof: &OneofWithContext<'a>,
+        field: &FieldDescriptor,
+        elem: FieldElem<'a>,
+        root_scope: &RootScope,
+    ) -> OneofField<'a> {
+        let boxed = OneofField::need_boxed(field, root_scope, &oneof.message.name_absolute());
+
+        OneofField {
+            elem,
+            type_name: oneof.rust_name(),
+            boxed,
+            oneof_variant_rust_name: rust_variant_name_for_protobuf_oneof_field_name(field.name()),
+            oneof_field_name: oneof.field_name(),
+        }
+    }
+
+    pub fn rust_type(&self, reference: &FileAndMod) -> RustType {
+        let t = self.elem.rust_storage_elem_type(reference);
+
+        if self.boxed {
+            RustType::Uniq(Box::new(t))
+        } else {
+            t
+        }
+    }
+
+    pub fn variant_path(&self, reference: &RustRelativePath) -> RustIdentWithPath {
+        make_path(
+            reference,
+            &self
+                .type_name
+                .to_path()
+                .with_ident(self.oneof_variant_rust_name.clone()),
+        )
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct OneofVariantGen<'a> {
+    oneof: &'a OneofGen<'a>,
+    _variant: OneofVariantWithContext<'a>,
+    oneof_field: OneofField<'a>,
+    pub field: FieldGen<'a>,
+    _path: String,
+}
+
+impl<'a> OneofVariantGen<'a> {
+    fn parse(
+        oneof: &'a OneofGen<'a>,
+        variant: OneofVariantWithContext<'a>,
+        field: &'a FieldGen,
+        _root_scope: &RootScope,
+    ) -> OneofVariantGen<'a> {
+        OneofVariantGen {
+            oneof,
+            _variant: variant.clone(),
+            field: field.clone(),
+            _path: format!(
+                "{}::{}",
+                oneof.type_name_relative(&oneof.oneof.message.scope.rust_path_to_file()),
+                field.rust_name
+            ),
+            oneof_field: OneofField::parse(
+                variant.oneof,
+                &field.proto_field.field,
+                field.elem().clone(),
+                oneof.message.root_scope,
+            ),
+        }
+    }
+
+    pub fn rust_type(&self, reference: &FileAndMod) -> RustType {
+        self.oneof_field.rust_type(reference)
+    }
+
+    pub fn path(&self, reference: &FileAndMod) -> RustPath {
+        RustPath::from(format!(
+            "{}::{}",
+            self.oneof.type_name_relative(&reference.relative_mod),
+            self.oneof_field.oneof_variant_rust_name,
+        ))
+    }
+
+    pub(crate) fn elem(&self) -> &FieldElem<'_> {
+        self.field.elem()
+    }
+}
+
+pub(crate) struct OneofGen<'a> {
+    // Message containing this oneof
+    message: &'a MessageGen<'a>,
+    pub oneof: OneofWithContext<'a>,
+    customize: CustomizeElemCtx<'a>,
+    lite_runtime: bool,
+}
+
+impl<'a> OneofGen<'a> {
+    pub fn parse(
+        message: &'a MessageGen,
+        oneof: OneofWithContext<'a>,
+        parent_customize: &CustomizeElemCtx<'a>,
+    ) -> OneofGen<'a> {
+        let customize = parent_customize.child(&Customize::default(), &oneof.oneof);
+        let lite_runtime = customize.for_elem.lite_runtime.unwrap_or_else(|| {
+            oneof
+                .message
+                .file_descriptor()
+                .proto()
+                .options
+                .optimize_for()
+                == file_options::OptimizeMode::LITE_RUNTIME
+        });
+        OneofGen {
+            message,
+            oneof,
+            customize,
+            lite_runtime,
+        }
+    }
+
+    pub fn type_name_relative(&self, source: &RustRelativePath) -> RustIdentWithPath {
+        make_path(source, &self.oneof.rust_name())
+    }
+
+    pub fn variants_except_group(&'a self) -> Vec<OneofVariantGen<'a>> {
+        self.oneof
+            .variants()
+            .into_iter()
+            .filter_map(|v| {
+                let field = self
+                    .message
+                    .fields
+                    .iter()
+                    .filter(|f| f.proto_field.name() == v.field.name())
+                    .next()
+                    .expect(&format!("field not found by name: {}", v.field.name()));
+                match field.proto_type {
+                    field_descriptor_proto::Type::TYPE_GROUP => None,
+                    _ => Some(OneofVariantGen::parse(
+                        self,
+                        v,
+                        field,
+                        self.message.root_scope,
+                    )),
+                }
+            })
+            .collect()
+    }
+
+    pub fn full_storage_type(&self) -> RustType {
+        RustType::Option(Box::new(RustType::Oneof(
+            self.type_name_relative(
+                &self
+                    .oneof
+                    .message
+                    .scope
+                    .file_and_mod(self.customize.for_elem.clone())
+                    .relative_mod,
+            )
+            .clone(),
+        )))
+    }
+
+    fn file_and_mod(&self) -> FileAndMod {
+        let mut file_and_mod = self
+            .message
+            .message
+            .scope
+            .file_and_mod(self.customize.for_elem.clone());
+        file_and_mod
+            .relative_mod
+            .push_ident(self.message.message.mod_name());
+        file_and_mod
+    }
+
+    fn write_enum(&self, w: &mut CodeWriter) {
+        let derive = vec!["Clone", "PartialEq", "Debug"];
+        w.derive(&derive);
+        w.write_line("#[non_exhaustive]");
+        write_protoc_insertion_point_for_oneof(w, &self.customize.for_elem, &self.oneof.oneof);
+        w.pub_enum(&self.oneof.rust_name().ident.to_string(), |w| {
+            for variant in self.variants_except_group() {
+                write_protoc_insertion_point_for_oneof_field(
+                    w,
+                    &self.customize.for_children,
+                    &variant.field.proto_field.field,
+                );
+                w.write_line(&format!(
+                    "{}({}),",
+                    variant.oneof_field.oneof_variant_rust_name,
+                    &variant
+                        .rust_type(&self.file_and_mod())
+                        .to_code(&self.customize.for_elem)
+                ));
+            }
+        });
+    }
+
+    fn write_impl_oneof(&self, w: &mut CodeWriter) {
+        w.impl_for_block(
+            &format!("{}::Oneof", protobuf_crate_path(&self.customize.for_elem)),
+            self.oneof.rust_name().ident.to_string(),
+            |_w| {
+                // nothing here yet
+            },
+        );
+    }
+
+    fn write_impl_oneof_full_fn_descriptor(&self, w: &mut CodeWriter) {
+        let sig = format!(
+            "descriptor() -> {}::reflect::OneofDescriptor",
+            protobuf_crate_path(&self.customize.for_elem),
+        );
+        w.def_fn(&sig, |w| {
+            w.lazy_static(
+                "descriptor",
+                &format!(
+                    "{}::reflect::OneofDescriptor",
+                    protobuf_crate_path(&self.customize.for_elem),
+                ),
+                &protobuf_crate_path(&self.customize.for_elem).to_string(),
+            );
+            let message_type = make_path(
+                &self
+                    .oneof
+                    .message
+                    .scope()
+                    .rust_path_to_file()
+                    .append(self.oneof.message.mod_name().into_rel_path()),
+                &self.oneof.message.rust_name_to_file(),
+            );
+            let expr = format!(
+                "<{} as {}::MessageFull>::descriptor().oneof_by_name(\"{}\").unwrap()",
+                message_type,
+                protobuf_crate_path(&self.customize.for_elem),
+                self.oneof.oneof.name()
+            );
+            w.write_line(&format!("descriptor.get(|| {}).clone()", expr));
+        });
+    }
+
+    fn write_impl_oneof_full(&self, w: &mut CodeWriter) {
+        w.impl_for_block(
+            &format!(
+                "{}::OneofFull",
+                protobuf_crate_path(&self.customize.for_elem)
+            ),
+            self.oneof.rust_name().ident.to_string(),
+            |w| self.write_impl_oneof_full_fn_descriptor(w),
+        )
+    }
+
+    fn write_generated_oneof_descriptor_data(&self, w: &mut CodeWriter) {
+        let sig = format!(
+            "generated_oneof_descriptor_data() -> {}::reflect::GeneratedOneofDescriptorData",
+            protobuf_crate_path(&self.customize.for_elem)
+        );
+        w.fn_block(
+            Visibility::Path(
+                self.oneof
+                    .rust_name()
+                    .path
+                    .into_relative_or_panic()
+                    .to_reverse(),
+            ),
+            &sig,
+            |w| {
+                w.write_line(&format!(
+                    "{}::reflect::GeneratedOneofDescriptorData::new::<{}>(\"{}\")",
+                    protobuf_crate_path(&self.customize.for_elem),
+                    &self.oneof.rust_name().ident,
+                    self.oneof.oneof.name(),
+                ));
+            },
+        );
+    }
+
+    fn write_impl_self(&self, w: &mut CodeWriter) {
+        w.impl_self_block(&format!("{}", &self.oneof.rust_name().ident), |w| {
+            if !self.lite_runtime {
+                self.write_generated_oneof_descriptor_data(w);
+            }
+        });
+    }
+
+    pub fn write(&self, w: &mut CodeWriter) {
+        self.write_enum(w);
+        w.write_line("");
+        self.write_impl_oneof(w);
+        if !self.lite_runtime {
+            w.write_line("");
+            self.write_impl_oneof_full(w);
+        }
+        w.write_line("");
+        self.write_impl_self(w);
+    }
+}
diff --git a/src/gen/paths.rs b/src/gen/paths.rs
new file mode 100644
index 0000000..2bc958d
--- /dev/null
+++ b/src/gen/paths.rs
@@ -0,0 +1,109 @@
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::path::RustPath;
+use crate::gen::strx;
+use crate::gen::well_known_types::WELL_KNOWN_TYPES_PROTO_FILE_FULL_NAMES;
+use crate::Customize;
+
+// Copy-pasted from libsyntax.
+fn ident_start(c: char) -> bool {
+    (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'
+}
+
+// Copy-pasted from libsyntax.
+fn ident_continue(c: char) -> bool {
+    (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_'
+}
+
+pub(crate) fn proto_path_to_rust_mod(path: &str) -> RustIdent {
+    let without_dir = strx::remove_to(path, std::path::is_separator);
+    let without_suffix = strx::remove_suffix(without_dir, ".proto");
+
+    let name = without_suffix
+        .chars()
+        .enumerate()
+        .map(|(i, c)| {
+            let valid = if i == 0 {
+                ident_start(c)
+            } else {
+                ident_continue(c)
+            };
+            if valid {
+                c
+            } else {
+                '_'
+            }
+        })
+        .collect::<String>();
+
+    RustIdent::new(&name)
+}
+
+/// Used in protobuf-codegen-identical-test
+pub fn proto_name_to_rs(proto_file_path: &str) -> String {
+    format!("{}.rs", proto_path_to_rust_mod(proto_file_path))
+}
+
+pub(crate) fn proto_path_to_fn_file_descriptor(
+    proto_path: &str,
+    customize: &Customize,
+) -> RustPath {
+    let protobuf_crate = protobuf_crate_path(customize);
+    match proto_path {
+        "rustproto.proto" => protobuf_crate.append("rustproto::file_descriptor".into()),
+        "google/protobuf/descriptor.proto" => {
+            protobuf_crate.append("descriptor::file_descriptor".into())
+        }
+        s if WELL_KNOWN_TYPES_PROTO_FILE_FULL_NAMES.contains(&s) => protobuf_crate
+            .append_ident("well_known_types".into())
+            .append_ident(proto_path_to_rust_mod(s))
+            .append_ident("file_descriptor".into()),
+        s => RustPath::super_path()
+            .append_ident(proto_path_to_rust_mod(s))
+            .append_ident("file_descriptor".into()),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::proto_path_to_rust_mod;
+    use crate::gen::rust::ident::RustIdent;
+
+    #[test]
+    fn test_mod_path_proto_ext() {
+        assert_eq!(
+            RustIdent::from("proto"),
+            proto_path_to_rust_mod("proto.proto")
+        );
+    }
+
+    #[test]
+    fn test_mod_path_unknown_ext() {
+        assert_eq!(
+            RustIdent::from("proto_proto3"),
+            proto_path_to_rust_mod("proto.proto3")
+        );
+    }
+
+    #[test]
+    fn test_mod_path_empty_ext() {
+        assert_eq!(RustIdent::from("proto"), proto_path_to_rust_mod("proto"));
+    }
+
+    #[test]
+    fn test_mod_path_dir() {
+        assert_eq!(
+            RustIdent::from("baz"),
+            proto_path_to_rust_mod("foo/bar/baz.proto"),
+        )
+    }
+
+    #[cfg(target_os = "windows")]
+    #[test]
+    fn test_mod_path_dir_backslashes() {
+        assert_eq!(
+            RustIdent::from("baz"),
+            proto_path_to_rust_mod("foo\\bar\\baz.proto"),
+        )
+    }
+}
diff --git a/src/gen/protoc_insertion_point.rs b/src/gen/protoc_insertion_point.rs
new file mode 100644
index 0000000..0083215
--- /dev/null
+++ b/src/gen/protoc_insertion_point.rs
@@ -0,0 +1,80 @@
+use protobuf::reflect::EnumDescriptor;
+use protobuf::reflect::EnumValueDescriptor;
+use protobuf::reflect::FieldDescriptor;
+use protobuf::reflect::MessageDescriptor;
+use protobuf::reflect::OneofDescriptor;
+
+use crate::gen::code_writer::CodeWriter;
+use crate::Customize;
+
+/// Write `// @protoc_insertion_point(...)` before the element.
+///
+/// This is similar to what `protoc` codegen does for C++ or Java.
+/// This can be used to modify the generated code.
+fn write_protoc_insertion_point(w: &mut CodeWriter, customize: &Customize, arg: &str) {
+    for line in customize.before.iter().flat_map(|s| s.lines()) {
+        w.write_line(line);
+    }
+    w.comment(&format!("@@protoc_insertion_point({})", arg));
+}
+
+pub(crate) fn write_protoc_insertion_point_for_message(
+    w: &mut CodeWriter,
+    customize: &Customize,
+    message: &MessageDescriptor,
+) {
+    write_protoc_insertion_point(w, customize, &format!("message:{}", message.full_name()));
+}
+
+pub(crate) fn write_protoc_insertion_point_for_field(
+    w: &mut CodeWriter,
+    customize: &Customize,
+    field: &FieldDescriptor,
+) {
+    write_protoc_insertion_point(w, customize, &format!("field:{}", field.full_name()));
+}
+
+pub(crate) fn write_protoc_insertion_point_for_special_field(
+    w: &mut CodeWriter,
+    customize: &Customize,
+    message: &MessageDescriptor,
+    field: &str,
+) {
+    write_protoc_insertion_point(
+        w,
+        customize,
+        &format!("special_field:{}.{}", message.full_name(), field),
+    );
+}
+
+pub(crate) fn write_protoc_insertion_point_for_enum(
+    w: &mut CodeWriter,
+    customize: &Customize,
+    enumeration: &EnumDescriptor,
+) {
+    write_protoc_insertion_point(w, customize, &format!("enum:{}", enumeration.full_name()));
+}
+
+pub(crate) fn write_protoc_insertion_point_for_enum_value(
+    w: &mut CodeWriter,
+    customize: &Customize,
+    value: &EnumValueDescriptor,
+) {
+    write_protoc_insertion_point(w, customize, &format!("enum_value:{}", value.full_name()));
+}
+
+pub(crate) fn write_protoc_insertion_point_for_oneof(
+    w: &mut CodeWriter,
+    customize: &Customize,
+    oneof: &OneofDescriptor,
+) {
+    write_protoc_insertion_point(w, customize, &format!("oneof:{}", oneof.full_name()));
+}
+
+pub(crate) fn write_protoc_insertion_point_for_oneof_field(
+    w: &mut CodeWriter,
+    customize: &Customize,
+    field: &FieldDescriptor,
+) {
+    write_protoc_insertion_point(w, customize, &format!("oneof_field:{}", field.full_name()));
+}
diff --git a/src/gen/rust/component.rs b/src/gen/rust/component.rs
new file mode 100644
index 0000000..8bf9c85
--- /dev/null
+++ b/src/gen/rust/component.rs
@@ -0,0 +1,34 @@
+use std::fmt;
+use std::fmt::Formatter;
+
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::keywords::parse_rust_keyword;
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub(crate) enum RustPathComponent {
+    Ident(RustIdent),
+    Keyword(&'static str),
+}
+
+impl fmt::Display for RustPathComponent {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            RustPathComponent::Ident(ident) => write!(f, "{}", ident),
+            RustPathComponent::Keyword(keyword) => write!(f, "{}", keyword),
+        }
+    }
+}
+
+impl RustPathComponent {
+    pub(crate) const SUPER: RustPathComponent = RustPathComponent::Keyword("super");
+
+    pub(crate) fn parse(s: &str) -> RustPathComponent {
+        if s.starts_with("r#") {
+            RustPathComponent::Ident(RustIdent::new(&s[2..]))
+        } else if let Some(kw) = parse_rust_keyword(s) {
+            RustPathComponent::Keyword(kw)
+        } else {
+            RustPathComponent::Ident(RustIdent::new(s))
+        }
+    }
+}
diff --git a/src/gen/rust/ident.rs b/src/gen/rust/ident.rs
new file mode 100644
index 0000000..df1d1f0
--- /dev/null
+++ b/src/gen/rust/ident.rs
@@ -0,0 +1,62 @@
+use std::fmt;
+
+use crate::gen::rust::ident_with_path::RustIdentWithPath;
+use crate::gen::rust::keywords::is_rust_keyword;
+use crate::gen::rust::rel_path::RustRelativePath;
+
+/// Valid Rust identifier
+#[derive(Eq, PartialEq, Debug, Clone, Hash)]
+pub(crate) struct RustIdent(String);
+
+impl RustIdent {
+    pub fn new(s: &str) -> RustIdent {
+        assert!(!s.is_empty());
+        assert!(!s.contains("/"), "{}", s);
+        assert!(!s.contains("."), "{}", s);
+        assert!(!s.contains(":"), "{}", s);
+        assert!(!s.contains(" "), "{}", s);
+        assert!(!s.contains("#"), "{}", s);
+        RustIdent(s.to_owned())
+    }
+
+    pub(crate) fn get(&self) -> &str {
+        &self.0
+    }
+
+    pub fn into_string(self) -> String {
+        self.0
+    }
+
+    pub fn to_path(&self) -> RustIdentWithPath {
+        RustIdentWithPath::from(&self.0)
+    }
+
+    pub(crate) fn into_rel_path(self) -> RustRelativePath {
+        RustRelativePath::from_idents([self])
+    }
+}
+
+impl fmt::Display for RustIdent {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // Rust-protobuf uses `_` suffix to escape identifiers instead of raw identifiers
+        // because some identifiers cannot be escaped as raw identifiers,
+        // e.g. `r#self` is not a valid raw identifier.
+        if is_rust_keyword(&self.0) {
+            write!(f, "{}_", self.0)
+        } else {
+            write!(f, "{}", self.0)
+        }
+    }
+}
+
+impl From<&'_ str> for RustIdent {
+    fn from(s: &str) -> Self {
+        RustIdent::new(s)
+    }
+}
+
+impl From<String> for RustIdent {
+    fn from(s: String) -> Self {
+        RustIdent::new(&s)
+    }
+}
diff --git a/src/gen/rust/ident_with_path.rs b/src/gen/rust/ident_with_path.rs
new file mode 100644
index 0000000..bb121a7
--- /dev/null
+++ b/src/gen/rust/ident_with_path.rs
@@ -0,0 +1,45 @@
+use std::fmt;
+
+use crate::gen::rust::component::RustPathComponent;
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::path::RustPath;
+
+#[derive(Eq, PartialEq, Debug, Clone)]
+pub(crate) struct RustIdentWithPath {
+    pub path: RustPath,
+    pub ident: RustIdent,
+}
+
+impl RustIdentWithPath {
+    pub fn new(s: String) -> RustIdentWithPath {
+        let mut path = RustPath::from(s);
+        let ident = match path.path.path.pop() {
+            None => panic!("empty path"),
+            Some(RustPathComponent::Ident(ident)) => ident,
+            Some(RustPathComponent::Keyword(kw)) => {
+                panic!("last path component is a keyword: {}", kw)
+            }
+        };
+        RustIdentWithPath { path, ident }
+    }
+
+    pub fn prepend_ident(&mut self, ident: RustIdent) {
+        self.path.prepend_ident(ident)
+    }
+
+    pub fn to_path(&self) -> RustPath {
+        self.path.clone().append_ident(self.ident.clone())
+    }
+}
+
+impl<S: Into<String>> From<S> for RustIdentWithPath {
+    fn from(s: S) -> Self {
+        RustIdentWithPath::new(s.into())
+    }
+}
+
+impl fmt::Display for RustIdentWithPath {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.to_path(), f)
+    }
+}
diff --git a/src/gen/rust/keywords.rs b/src/gen/rust/keywords.rs
new file mode 100644
index 0000000..155977d
--- /dev/null
+++ b/src/gen/rust/keywords.rs
@@ -0,0 +1,86 @@
+#[cfg_attr(rustfmt, rustfmt_skip)]
+static RUST_KEYWORDS: &'static [&'static str] = &[
+    "_",
+    "as",
+    "async",
+    "await",
+    "break",
+    "crate",
+    "dyn",
+    "else",
+    "enum",
+    "extern",
+    "false",
+    "fn",
+    "for",
+    "if",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "pub",
+    "ref",
+    "return",
+    "static",
+    "self",
+    "Self",
+    "struct",
+    "super",
+    "true",
+    "trait",
+    "type",
+    "unsafe",
+    "use",
+    "while",
+    "continue",
+    "box",
+    "const",
+    "where",
+    "virtual",
+    "proc",
+    "alignof",
+    "become",
+    "offsetof",
+    "priv",
+    "pure",
+    "sizeof",
+    "typeof",
+    "unsized",
+    "yield",
+    "do",
+    "abstract",
+    "final",
+    "override",
+    "macro",
+];
+
+// https://internals.rust-lang.org/t/raw-identifiers-dont-work-for-all-identifiers/9094/3
+#[cfg_attr(rustfmt, rustfmt_skip)]
+static RUST_KEYWORDS_WHICH_CANNOT_BE_RAW: &'static [&'static str] = &[
+    "super",
+    "self",
+    "Self",
+    "extern",
+    "crate",
+];
+
+pub(crate) fn parse_rust_keyword(word: &str) -> Option<&'static str> {
+    RUST_KEYWORDS.iter().cloned().find(|&kw| kw == word)
+}
+
+pub(crate) fn is_rust_keyword(ident: &str) -> bool {
+    parse_rust_keyword(ident).is_some()
+}
+
+#[allow(dead_code)]
+pub(crate) fn is_rust_keyword_which_cannot_be_raw(ident: &str) -> bool {
+    RUST_KEYWORDS_WHICH_CANNOT_BE_RAW
+        .iter()
+        .cloned()
+        .find(|&kw| kw == ident)
+        .is_some()
+}
diff --git a/src/gen/rust/mod.rs b/src/gen/rust/mod.rs
new file mode 100644
index 0000000..343ba92
--- /dev/null
+++ b/src/gen/rust/mod.rs
@@ -0,0 +1,8 @@
+pub(crate) mod component;
+pub(crate) mod ident;
+pub(crate) mod ident_with_path;
+pub(crate) mod keywords;
+pub(crate) mod path;
+pub(crate) mod quote;
+pub(crate) mod rel_path;
+pub(crate) mod snippets;
diff --git a/src/gen/rust/path.rs b/src/gen/rust/path.rs
new file mode 100644
index 0000000..84d38a3
--- /dev/null
+++ b/src/gen/rust/path.rs
@@ -0,0 +1,99 @@
+use std::fmt;
+
+use crate::gen::rust::component::RustPathComponent;
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::ident_with_path::RustIdentWithPath;
+use crate::gen::rust::rel_path::RustRelativePath;
+
+#[derive(Default, Eq, PartialEq, Debug, Clone)]
+pub(crate) struct RustPath {
+    pub(crate) absolute: bool,
+    pub(crate) path: RustRelativePath,
+}
+
+impl RustPath {
+    pub fn super_path() -> RustPath {
+        RustPath::from("super")
+    }
+
+    pub fn is_absolute(&self) -> bool {
+        self.absolute
+    }
+
+    pub fn with_ident(self, ident: RustIdent) -> RustIdentWithPath {
+        RustIdentWithPath { path: self, ident }
+    }
+
+    pub fn first(&self) -> Option<RustPathComponent> {
+        assert!(!self.absolute);
+        self.path.first()
+    }
+
+    pub fn remove_first(&mut self) -> Option<RustPathComponent> {
+        assert!(!self.absolute);
+        self.path.remove_first()
+    }
+
+    pub fn prepend_ident(&mut self, ident: RustIdent) {
+        assert!(!self.absolute);
+        self.path.prepend_ident(ident);
+    }
+
+    pub fn append(self, path: RustPath) -> RustPath {
+        if path.absolute {
+            path
+        } else {
+            RustPath {
+                absolute: self.absolute,
+                path: self.path.append(path.path),
+            }
+        }
+    }
+
+    pub(crate) fn append_component(mut self, component: RustPathComponent) -> RustPath {
+        self.path.path.push(component);
+        self
+    }
+
+    pub fn append_ident(self, ident: RustIdent) -> RustPath {
+        self.append_component(RustPathComponent::Ident(ident))
+    }
+
+    pub fn append_with_ident(self, path: RustIdentWithPath) -> RustIdentWithPath {
+        self.append(path.path).with_ident(path.ident)
+    }
+
+    pub fn into_relative_or_panic(self) -> RustRelativePath {
+        assert!(!self.absolute);
+        self.path
+    }
+}
+
+impl From<&'_ str> for RustPath {
+    fn from(s: &str) -> Self {
+        let (s, absolute) = if s.starts_with("::") {
+            (&s[2..], true)
+        } else {
+            (s, false)
+        };
+        RustPath {
+            absolute,
+            path: RustRelativePath::from(s),
+        }
+    }
+}
+
+impl From<String> for RustPath {
+    fn from(s: String) -> Self {
+        RustPath::from(&s[..])
+    }
+}
+
+impl fmt::Display for RustPath {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.absolute {
+            write!(f, "::")?;
+        }
+        write!(f, "{}", self.path)
+    }
+}
diff --git a/src/gen/rust/quote.rs b/src/gen/rust/quote.rs
new file mode 100644
index 0000000..f01b4ee
--- /dev/null
+++ b/src/gen/rust/quote.rs
@@ -0,0 +1,58 @@
+fn hex_digit(value: u32) -> char {
+    if value < 10 {
+        (b'0' + value as u8) as char
+    } else if value < 0x10 {
+        (b'a' + value as u8 - 10) as char
+    } else {
+        unreachable!()
+    }
+}
+
+pub fn quote_escape_str(s: &str) -> String {
+    let mut buf = String::new();
+    buf.push('"');
+    buf.extend(s.chars().flat_map(|c| c.escape_default()));
+    buf.push('"');
+    buf
+}
+
+pub fn quote_escape_bytes(bytes: &[u8]) -> String {
+    let mut buf = String::new();
+    buf.push('b');
+    buf.push('"');
+    for &b in bytes {
+        match b {
+            b'\n' => buf.push_str(r"\n"),
+            b'\r' => buf.push_str(r"\r"),
+            b'\t' => buf.push_str(r"\t"),
+            b'"' => buf.push_str("\\\""),
+            b'\\' => buf.push_str(r"\\"),
+            b'\x20'..=b'\x7e' => buf.push(b as char),
+            _ => {
+                buf.push_str(r"\x");
+                buf.push(hex_digit((b as u32) >> 4));
+                buf.push(hex_digit((b as u32) & 0x0f));
+            }
+        }
+    }
+    buf.push('"');
+    buf
+}
+
+#[cfg(test)]
+mod test {
+
+    use super::*;
+
+    #[test]
+    fn test_quote_escape_bytes() {
+        assert_eq!("b\"\"", quote_escape_bytes(b""));
+        assert_eq!("b\"xyZW\"", quote_escape_bytes(b"xyZW"));
+        assert_eq!("b\"aa\\\"bb\"", quote_escape_bytes(b"aa\"bb"));
+        assert_eq!("b\"aa\\r\\n\\tbb\"", quote_escape_bytes(b"aa\r\n\tbb"));
+        assert_eq!(
+            "b\"\\x00\\x01\\x12\\xfe\\xff\"",
+            quote_escape_bytes(b"\x00\x01\x12\xfe\xff")
+        );
+    }
+}
diff --git a/src/gen/rust/rel_path.rs b/src/gen/rust/rel_path.rs
new file mode 100644
index 0000000..6188ce6
--- /dev/null
+++ b/src/gen/rust/rel_path.rs
@@ -0,0 +1,97 @@
+use std::fmt;
+use std::iter;
+
+use crate::gen::rust::component::RustPathComponent;
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::path::RustPath;
+
+#[derive(Default, Eq, PartialEq, Debug, Clone)]
+pub(crate) struct RustRelativePath {
+    pub(crate) path: Vec<RustPathComponent>,
+}
+
+impl RustRelativePath {
+    pub fn into_path(self) -> RustPath {
+        RustPath {
+            absolute: false,
+            path: self,
+        }
+    }
+
+    pub fn _empty() -> RustRelativePath {
+        RustRelativePath { path: Vec::new() }
+    }
+
+    pub fn from_components<I: IntoIterator<Item = RustPathComponent>>(i: I) -> RustRelativePath {
+        RustRelativePath {
+            path: i.into_iter().collect(),
+        }
+    }
+
+    pub fn from_idents<I: IntoIterator<Item = RustIdent>>(i: I) -> RustRelativePath {
+        Self::from_components(i.into_iter().map(RustPathComponent::Ident))
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.path.is_empty()
+    }
+
+    pub fn first(&self) -> Option<RustPathComponent> {
+        self.path.iter().cloned().next()
+    }
+
+    pub fn remove_first(&mut self) -> Option<RustPathComponent> {
+        if self.path.is_empty() {
+            None
+        } else {
+            Some(self.path.remove(0))
+        }
+    }
+
+    pub fn prepend_ident(&mut self, ident: RustIdent) {
+        self.path.insert(0, RustPathComponent::Ident(ident));
+    }
+
+    pub fn append(mut self, path: RustRelativePath) -> RustRelativePath {
+        for c in path.path {
+            self.path.push(c);
+        }
+        self
+    }
+
+    pub fn push_ident(&mut self, ident: RustIdent) {
+        self.path.push(RustPathComponent::Ident(ident));
+    }
+
+    pub fn append_ident(mut self, ident: RustIdent) -> RustRelativePath {
+        self.push_ident(ident);
+        self
+    }
+
+    pub fn to_reverse(&self) -> RustRelativePath {
+        RustRelativePath::from_components(
+            iter::repeat(RustPathComponent::SUPER).take(self.path.len()),
+        )
+    }
+}
+
+impl fmt::Display for RustRelativePath {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for (i, c) in self.path.iter().enumerate() {
+            if i != 0 {
+                write!(f, "::")?;
+            }
+            write!(f, "{}", c)?;
+        }
+        Ok(())
+    }
+}
+
+impl From<&'_ str> for RustRelativePath {
+    fn from(s: &str) -> Self {
+        assert!(!s.starts_with("::"), "path is absolute: {:?}", s);
+        RustRelativePath {
+            path: s.split("::").map(RustPathComponent::parse).collect(),
+        }
+    }
+}
diff --git a/src/gen/rust/snippets.rs b/src/gen/rust/snippets.rs
new file mode 100644
index 0000000..c10c4a9
--- /dev/null
+++ b/src/gen/rust/snippets.rs
@@ -0,0 +1,10 @@
+pub(crate) const EXPR_NONE: &str = "::std::option::Option::None";
+pub(crate) const EXPR_VEC_NEW: &str = "::std::vec::Vec::new()";
+
+fn expr_vec_with_capacity(capacity: &str) -> String {
+    format!("::std::vec::Vec::with_capacity({})", capacity)
+}
+
+pub(crate) fn expr_vec_with_capacity_const(capacity: usize) -> String {
+    expr_vec_with_capacity(&capacity.to_string())
+}
diff --git a/src/gen/rust_types_values.rs b/src/gen/rust_types_values.rs
new file mode 100644
index 0000000..cd67f2b
--- /dev/null
+++ b/src/gen/rust_types_values.rs
@@ -0,0 +1,617 @@
+use std::cmp;
+
+use once_cell::sync::Lazy;
+use protobuf::descriptor::*;
+use protobuf::reflect::FileDescriptor;
+use protobuf_parse::ProtobufAbsPath;
+use regex::Regex;
+
+use crate::customize::Customize;
+use crate::gen::field::type_ext::TypeExt;
+use crate::gen::file_and_mod::FileAndMod;
+use crate::gen::inside::protobuf_crate_path;
+use crate::gen::message::RustTypeMessage;
+use crate::gen::paths::proto_path_to_rust_mod;
+use crate::gen::rust::component::RustPathComponent;
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::ident_with_path::RustIdentWithPath;
+use crate::gen::rust::path::RustPath;
+use crate::gen::rust::rel_path::RustRelativePath;
+use crate::gen::rust::snippets::EXPR_NONE;
+use crate::gen::rust::snippets::EXPR_VEC_NEW;
+use crate::gen::scope::RootScope;
+use crate::gen::scope::WithScope;
+use crate::gen::strx::capitalize;
+use crate::gen::well_known_types::is_well_known_type_full;
+
+// Represent subset of rust types used in generated code
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum RustType {
+    // integer: signed?, size in bits
+    Int(bool, u32),
+    // param is size in bits
+    Float(u32),
+    Bool,
+    Vec(Box<RustType>),
+    HashMap(Box<RustType>, Box<RustType>),
+    String,
+    // [T], not &[T]
+    Slice(Box<RustType>),
+    // str, not &str
+    Str,
+    Option(Box<RustType>),
+    MessageField(Box<RustType>),
+    // Box<T>
+    Uniq(Box<RustType>),
+    // &T
+    Ref(Box<RustType>),
+    // protobuf message
+    Message(RustTypeMessage),
+    // protobuf enum, not any enum
+    Enum(RustIdentWithPath, RustIdent, i32),
+    // protobuf enum or unknown
+    EnumOrUnknown(RustIdentWithPath, RustIdent, i32),
+    // oneof enum
+    Oneof(RustIdentWithPath),
+    // bytes::Bytes
+    Bytes,
+    // chars::Chars
+    Chars,
+    // group
+    Group,
+}
+
+impl RustType {
+    #[inline]
+    pub(crate) fn to_code(&self, customize: &Customize) -> String {
+        match *self {
+            RustType::Int(true, bits) => format!("i{}", bits),
+            RustType::Int(false, bits) => format!("u{}", bits),
+            RustType::Float(bits) => format!("f{}", bits),
+            RustType::Bool => format!("bool"),
+            RustType::Vec(ref param) => format!("::std::vec::Vec<{}>", param.to_code(customize)),
+            RustType::HashMap(ref key, ref value) => format!(
+                "::std::collections::HashMap<{}, {}>",
+                key.to_code(customize),
+                value.to_code(customize)
+            ),
+            RustType::String => format!("::std::string::String"),
+            RustType::Slice(ref param) => format!("[{}]", param.to_code(customize)),
+            RustType::Str => format!("str"),
+            RustType::Option(ref param) => {
+                format!("::std::option::Option<{}>", param.to_code(customize))
+            }
+            RustType::MessageField(ref param) => format!(
+                "{}::MessageField<{}>",
+                protobuf_crate_path(customize),
+                param.to_code(customize)
+            ),
+            RustType::Uniq(ref param) => format!("::std::boxed::Box<{}>", param.to_code(customize)),
+            RustType::Ref(ref param) => format!("&{}", param.to_code(customize)),
+            RustType::Message(ref name) => format!("{}", name),
+            RustType::Enum(ref name, ..) | RustType::Oneof(ref name) => format!("{}", name),
+            RustType::EnumOrUnknown(ref name, ..) => format!(
+                "{}::EnumOrUnknown<{}>",
+                protobuf_crate_path(customize),
+                name
+            ),
+            RustType::Group => format!("<group>"),
+            RustType::Bytes => format!("::bytes::Bytes"),
+            RustType::Chars => format!("{}::Chars", protobuf_crate_path(customize)),
+        }
+    }
+}
+
+impl RustType {
+    pub(crate) fn u8() -> RustType {
+        RustType::Int(false, 8)
+    }
+
+    pub(crate) fn i32() -> RustType {
+        RustType::Int(true, 32)
+    }
+
+    /// `&str`.
+    pub(crate) fn amp_str() -> RustType {
+        RustType::Str.wrap_ref()
+    }
+
+    /// `&[u8]`.
+    pub(crate) fn amp_slice_of_u8() -> RustType {
+        RustType::u8().wrap_slice().wrap_ref()
+    }
+
+    /// Type is rust primitive?
+    pub(crate) fn is_primitive(&self) -> bool {
+        match *self {
+            RustType::Int(..) | RustType::Float(..) | RustType::Bool => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_u8(&self) -> bool {
+        match *self {
+            RustType::Int(false, 8) => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_copy(&self) -> bool {
+        if self.is_primitive() {
+            true
+        } else if let RustType::Enum(..) = *self {
+            true
+        } else if let RustType::EnumOrUnknown(..) = *self {
+            true
+        } else {
+            false
+        }
+    }
+
+    fn is_str(&self) -> bool {
+        match *self {
+            RustType::Str => true,
+            _ => false,
+        }
+    }
+
+    fn is_string(&self) -> bool {
+        match *self {
+            RustType::String => true,
+            _ => false,
+        }
+    }
+
+    fn is_slice(&self) -> Option<&RustType> {
+        match *self {
+            RustType::Slice(ref v) => Some(&**v),
+            _ => None,
+        }
+    }
+
+    fn is_slice_u8(&self) -> bool {
+        match self.is_slice() {
+            Some(t) => t.is_u8(),
+            None => false,
+        }
+    }
+
+    fn is_message(&self) -> bool {
+        match *self {
+            RustType::Message(..) => true,
+            _ => false,
+        }
+    }
+
+    fn is_enum(&self) -> bool {
+        match *self {
+            RustType::Enum(..) => true,
+            _ => false,
+        }
+    }
+
+    fn is_enum_or_unknown(&self) -> bool {
+        match *self {
+            RustType::EnumOrUnknown(..) => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_ref(&self) -> Option<&RustType> {
+        match *self {
+            RustType::Ref(ref v) => Some(&**v),
+            _ => None,
+        }
+    }
+
+    pub fn is_box(&self) -> Option<&RustType> {
+        match *self {
+            RustType::Uniq(ref v) => Some(&**v),
+            _ => None,
+        }
+    }
+
+    // default value for type
+    pub fn default_value(&self, customize: &Customize, const_expr: bool) -> String {
+        match *self {
+            RustType::Ref(ref t) if t.is_str() => "\"\"".to_string(),
+            RustType::Ref(ref t) if t.is_slice().is_some() => "&[]".to_string(),
+            RustType::Int(..) => "0".to_string(),
+            RustType::Float(..) => "0.".to_string(),
+            RustType::Bool => "false".to_string(),
+            RustType::Vec(..) => EXPR_VEC_NEW.to_string(),
+            RustType::HashMap(..) => "::std::collections::HashMap::new()".to_string(),
+            RustType::String => "::std::string::String::new()".to_string(),
+            RustType::Bytes => "::bytes::Bytes::new()".to_string(),
+            RustType::Chars => format!("{}::Chars::new()", protobuf_crate_path(customize)),
+            RustType::Option(..) => EXPR_NONE.to_string(),
+            RustType::MessageField(..) => {
+                format!("{}::MessageField::none()", protobuf_crate_path(customize))
+            }
+            RustType::Message(ref name) => format!("{}::new()", name),
+            RustType::Ref(ref m) if m.is_message() => match **m {
+                RustType::Message(ref name) => name.default_instance(customize),
+                _ => unreachable!(),
+            },
+            // Note: default value of enum type may not be equal to default value of field
+            RustType::Enum(ref name, ref default, ..) => format!("{}::{}", name, default),
+            RustType::EnumOrUnknown(_, _, number) if const_expr => format!(
+                "{}::EnumOrUnknown::from_i32({})",
+                protobuf_crate_path(customize),
+                number,
+            ),
+            RustType::EnumOrUnknown(ref name, ref default, ..) if !const_expr => format!(
+                "{}::EnumOrUnknown::new({}::{})",
+                protobuf_crate_path(customize),
+                name,
+                default
+            ),
+            _ => panic!("cannot create default value for: {:?}", self),
+        }
+    }
+
+    pub fn default_value_typed(self, customize: &Customize, const_expr: bool) -> RustValueTyped {
+        RustValueTyped {
+            value: self.default_value(customize, const_expr),
+            rust_type: self,
+        }
+    }
+
+    /// Emit a code to clear a variable `v`
+    pub fn clear(&self, v: &str, customize: &Customize) -> String {
+        match *self {
+            RustType::Option(..) => format!("{} = {}", v, EXPR_NONE),
+            RustType::Vec(..)
+            | RustType::Bytes
+            | RustType::Chars
+            | RustType::String
+            | RustType::MessageField(..)
+            | RustType::HashMap(..) => format!("{}.clear()", v),
+            RustType::Bool
+            | RustType::Float(..)
+            | RustType::Int(..)
+            | RustType::Enum(..)
+            | RustType::EnumOrUnknown(..) => {
+                format!("{} = {}", v, self.default_value(customize, false))
+            }
+            ref ty => panic!("cannot clear type: {:?}", ty),
+        }
+    }
+
+    // expression to convert `v` of type `self` to type `target`
+    pub fn into_target(&self, target: &RustType, v: &str, customize: &Customize) -> String {
+        self.try_into_target(target, v, customize)
+            .expect(&format!("failed to convert {:?} into {:?}", self, target))
+    }
+
+    // https://github.com/rust-lang-nursery/rustfmt/issues/3131
+    #[cfg_attr(rustfmt, rustfmt_skip)]
+    fn try_into_target(&self, target: &RustType, v: &str, customize: &Customize) -> Result<String, ()> {
+        {
+            if let Some(t1) = self.is_ref().and_then(|t| t.is_box()) {
+                if let Some(t2) = target.is_ref() {
+                    if t1 == t2 {
+                        return Ok(format!("&**{}", v));
+                    }
+                }
+            }
+        }
+
+        match (self, target) {
+            (x, y) if x == y => return Ok(format!("{}", v)),
+            (&RustType::Ref(ref x), y) if **x == *y => return Ok(format!("*{}", v)),
+            (x, &RustType::Uniq(ref y)) if *x == **y => {
+                return Ok(format!("::std::boxed::Box::new({})", v))
+            }
+            (&RustType::Uniq(ref x), y) if **x == *y => return Ok(format!("*{}", v)),
+            (&RustType::String, &RustType::Ref(ref t)) if **t == RustType::Str => {
+                return Ok(format!("&{}", v))
+            }
+            (&RustType::Chars, &RustType::Ref(ref t)) if **t == RustType::Str => {
+                return Ok(format!("&{}", v))
+            }
+            (&RustType::Ref(ref t1), &RustType::Ref(ref t2)) if t1.is_string() && t2.is_str() => {
+                return Ok(format!("&{}", v))
+            }
+            (&RustType::Ref(ref t1), &RustType::String)
+                if match **t1 {
+                       RustType::Str => true,
+                       _ => false,
+                   } => return Ok(format!("{}.to_owned()", v)),
+            (&RustType::Ref(ref t1), &RustType::Chars)
+                if match **t1 {
+                       RustType::Str => true,
+                       _ => false,
+                   } => {
+                return Ok(format!("<{}::Chars as ::std::convert::From<_>>::from({}.to_owned())",
+                    protobuf_crate_path(customize), v))
+            },
+            (&RustType::Ref(ref t1), &RustType::Vec(ref t2))
+                if match (&**t1, &**t2) {
+                       (&RustType::Slice(ref x), ref y) => **x == **y,
+                       _ => false,
+                   } => return Ok(format!("{}.to_vec()", v)),
+            (&RustType::Ref(ref t1), &RustType::Bytes)
+                if t1.is_slice_u8() =>
+                    return Ok(format!("<::bytes::Bytes as ::std::convert::From<_>>::from({}.to_vec())", v)),
+            (&RustType::Vec(ref x), &RustType::Ref(ref t))
+                if match **t {
+                       RustType::Slice(ref y) => x == y,
+                       _ => false,
+                   } => return Ok(format!("&{}", v)),
+            (&RustType::Bytes, &RustType::Ref(ref t))
+                if match **t {
+                       RustType::Slice(ref y) => **y == RustType::u8(),
+                       _ => false,
+                   } => return Ok(format!("&{}", v)),
+            (&RustType::Ref(ref t1), &RustType::Ref(ref t2))
+                if match (&**t1, &**t2) {
+                       (&RustType::Vec(ref x), &RustType::Slice(ref y)) => x == y,
+                       _ => false,
+                   } => return Ok(format!("&{}", v)),
+            (&RustType::Enum(..), &RustType::Int(true, 32)) => {
+                return Ok(format!("{}::Enum::value(&{})", protobuf_crate_path(customize), v))
+            },
+            (&RustType::EnumOrUnknown(..), &RustType::Int(true, 32)) => {
+                return Ok(format!("{}::EnumOrUnknown::value(&{})", protobuf_crate_path(customize), v))
+            },
+            (&RustType::Ref(ref t), &RustType::Int(true, 32)) if t.is_enum() => {
+                return Ok(format!("{}::Enum::value({})", protobuf_crate_path(customize), v))
+            }
+            (&RustType::Ref(ref t), &RustType::Int(true, 32)) if t.is_enum_or_unknown() => {
+                return Ok(format!("{}::EnumOrUnknown::value({})", protobuf_crate_path(customize), v))
+            },
+            (&RustType::EnumOrUnknown(ref f, ..), &RustType::Enum(ref t, ..)) if f == t => {
+                return Ok(format!("{}::EnumOrUnknown::enum_value_or_default(&{})", protobuf_crate_path(customize), v))
+            }
+            (&RustType::Enum(ref f, ..), &RustType::EnumOrUnknown(ref t, ..)) if f == t => {
+                return Ok(format!("{}::EnumOrUnknown::new({})", protobuf_crate_path(customize), v))
+            }
+            _ => (),
+        };
+
+        if let &RustType::Ref(ref s) = self {
+            if let Ok(conv) = s.try_into_target(target, v, customize) {
+                return Ok(conv);
+            }
+        }
+
+        Err(())
+    }
+
+    /// Type to view data of this type
+    pub fn ref_type(&self) -> RustType {
+        RustType::Ref(Box::new(match self {
+            &RustType::String | &RustType::Chars => RustType::Str,
+            &RustType::Vec(ref p) => RustType::Slice(p.clone()),
+            &RustType::Bytes => RustType::Slice(Box::new(RustType::u8())),
+            &RustType::Message(ref p) => RustType::Message(p.clone()),
+            &RustType::Uniq(ref p) => RustType::Uniq(p.clone()),
+            x => panic!("no ref type for {:?}", x),
+        }))
+    }
+
+    pub(crate) fn wrap_ref(&self) -> RustType {
+        RustType::Ref(Box::new(self.clone()))
+    }
+
+    pub(crate) fn wrap_slice(&self) -> RustType {
+        RustType::Slice(Box::new(self.clone()))
+    }
+
+    pub fn elem_type(&self) -> RustType {
+        match self {
+            &RustType::Option(ref ty) => (**ty).clone(),
+            &RustType::MessageField(ref ty) => (**ty).clone(),
+            x => panic!("cannot get elem type of {:?}", x),
+        }
+    }
+
+    // type of `v` in `for v in xxx`
+    pub fn iter_elem_type(&self) -> RustType {
+        match self {
+            &RustType::Vec(ref ty)
+            | &RustType::Option(ref ty)
+            | &RustType::MessageField(ref ty) => RustType::Ref(ty.clone()),
+            x => panic!("cannot iterate {:?}", x),
+        }
+    }
+
+    pub fn value(self, value: String) -> RustValueTyped {
+        RustValueTyped {
+            value: value,
+            rust_type: self,
+        }
+    }
+}
+
+/// Representation of an expression in code generator: text and type
+pub(crate) struct RustValueTyped {
+    pub value: String,
+    pub rust_type: RustType,
+}
+
+impl RustValueTyped {
+    pub fn into_type(&self, target: RustType, customize: &Customize) -> RustValueTyped {
+        let target_value = self.rust_type.into_target(&target, &self.value, customize);
+        RustValueTyped {
+            value: target_value,
+            rust_type: target,
+        }
+    }
+
+    pub fn boxed(self, customize: &Customize) -> RustValueTyped {
+        self.into_type(RustType::Uniq(Box::new(self.rust_type.clone())), customize)
+    }
+}
+
+fn file_last_component(file: &str) -> &str {
+    let bs = file.rfind('\\').map(|i| i + 1).unwrap_or(0);
+    let fs = file.rfind('/').map(|i| i + 1).unwrap_or(0);
+    &file[cmp::max(fs, bs)..]
+}
+
+#[cfg(test)]
+#[test]
+fn test_file_last_component() {
+    assert_eq!("ab.proto", file_last_component("ab.proto"));
+    assert_eq!("ab.proto", file_last_component("xx/ab.proto"));
+    assert_eq!("ab.proto", file_last_component("xx\\ab.proto"));
+    assert_eq!("ab.proto", file_last_component("yy\\xx\\ab.proto"));
+}
+
+fn is_descriptor_proto(file: &FileDescriptor) -> bool {
+    file.package() == "google.protobuf" && file_last_component(file.name()) == "descriptor.proto"
+}
+
+fn make_path_to_path(source: &RustRelativePath, dest: &RustPath) -> RustPath {
+    if dest.is_absolute() {
+        return dest.clone();
+    }
+
+    let mut source = source.clone();
+    let mut dest = dest.clone();
+    while !source.is_empty() && source.first() == dest.first() {
+        source.remove_first().unwrap();
+        dest.remove_first().unwrap();
+    }
+    source.to_reverse().into_path().append(dest)
+}
+
+pub(crate) fn make_path(source: &RustRelativePath, dest: &RustIdentWithPath) -> RustIdentWithPath {
+    make_path_to_path(source, &dest.path).with_ident(dest.ident.clone())
+}
+
+pub(crate) fn message_or_enum_to_rust_relative(
+    message_or_enum: &dyn WithScope,
+    current: &FileAndMod,
+) -> RustIdentWithPath {
+    let same_file = message_or_enum.file_descriptor().name() == current.file;
+    if same_file {
+        // field type is a message or enum declared in the same file
+        make_path(&current.relative_mod, &message_or_enum.rust_name_to_file())
+    } else if let Some(name) = is_well_known_type_full(&message_or_enum.name_absolute()) {
+        // Well-known types are included in rust-protobuf library
+        // https://developers.google.com/protocol-buffers/docs/reference/google.protobuf
+        let file_descriptor = message_or_enum.file_descriptor();
+        static REGEX: Lazy<Regex> =
+            Lazy::new(|| Regex::new(r"^google/protobuf/([^/]+\.proto)$").unwrap());
+        let captures = REGEX
+            .captures(file_descriptor.name())
+            .unwrap_or_else(|| panic!("`{}` does not match the regex", file_descriptor.name()));
+        let file_name = captures.get(1).unwrap().as_str();
+        let mod_name = proto_path_to_rust_mod(file_name);
+        RustIdentWithPath::from(format!(
+            "{protobuf_crate}::well_known_types::{mod_name}::{name}",
+            protobuf_crate = protobuf_crate_path(&current.customize),
+        ))
+    } else if is_descriptor_proto(&message_or_enum.file_descriptor()) {
+        // Messages defined in descriptor.proto
+        RustIdentWithPath::from(format!(
+            "{}::descriptor::{}",
+            protobuf_crate_path(&current.customize),
+            message_or_enum.rust_name_to_file()
+        ))
+    } else {
+        current
+            .relative_mod
+            .to_reverse()
+            .into_path()
+            .append_component(RustPathComponent::SUPER)
+            .append_with_ident(message_or_enum.rust_name_with_file())
+    }
+}
+
+pub(crate) fn type_name_to_rust_relative(
+    type_name: &ProtobufAbsPath,
+    current: &FileAndMod,
+    root_scope: &RootScope,
+) -> RustIdentWithPath {
+    assert!(!type_name.is_root());
+    let message_or_enum = root_scope.find_message_or_enum(type_name);
+    message_or_enum_to_rust_relative(&message_or_enum, current)
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum PrimitiveTypeVariant {
+    Default,
+    TokioBytes,
+}
+
+pub enum _TokioBytesType {
+    Bytes,
+    Chars,
+}
+
+// ProtobufType trait name
+pub(crate) enum ProtobufTypeGen {
+    Primitive(field_descriptor_proto::Type, PrimitiveTypeVariant),
+    Message(RustTypeMessage),
+    EnumOrUnknown(RustIdentWithPath),
+}
+
+impl ProtobufTypeGen {
+    pub(crate) fn protobuf_value(&self, customize: &Customize) -> String {
+        match self {
+            ProtobufTypeGen::Primitive(t, PrimitiveTypeVariant::Default) => {
+                t.rust_type().to_code(customize)
+            }
+            ProtobufTypeGen::Primitive(_, PrimitiveTypeVariant::TokioBytes) => unimplemented!(),
+            ProtobufTypeGen::Message(m) => m.0.to_string(),
+            ProtobufTypeGen::EnumOrUnknown(e) => format!(
+                "{protobuf_crate}::EnumOrUnknown<{e}>",
+                protobuf_crate = protobuf_crate_path(customize)
+            ),
+        }
+    }
+
+    pub(crate) fn _rust_type(&self, customize: &Customize) -> String {
+        match self {
+            &ProtobufTypeGen::Primitive(t, PrimitiveTypeVariant::Default) => format!(
+                "{}::reflect::types::ProtobufType{}",
+                protobuf_crate_path(customize),
+                capitalize(t.protobuf_name())
+            ),
+            &ProtobufTypeGen::Primitive(
+                field_descriptor_proto::Type::TYPE_BYTES,
+                PrimitiveTypeVariant::TokioBytes,
+            ) => format!(
+                "{}::reflect::types::ProtobufTypeTokioBytes",
+                protobuf_crate_path(customize)
+            ),
+            &ProtobufTypeGen::Primitive(
+                field_descriptor_proto::Type::TYPE_STRING,
+                PrimitiveTypeVariant::TokioBytes,
+            ) => format!(
+                "{}::reflect::types::ProtobufTypeTokioChars",
+                protobuf_crate_path(customize)
+            ),
+            &ProtobufTypeGen::Primitive(.., PrimitiveTypeVariant::TokioBytes) => unreachable!(),
+            &ProtobufTypeGen::Message(ref name) => format!(
+                "{}::reflect::types::ProtobufTypeMessage<{}>",
+                protobuf_crate_path(customize),
+                name
+            ),
+            &ProtobufTypeGen::EnumOrUnknown(ref name) => format!(
+                "{}::reflect::types::ProtobufTypeEnumOrUnknown<{}>",
+                protobuf_crate_path(customize),
+                name
+            ),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn into_target_ref_box_to_ref() {
+        let t1 = RustType::Ref(Box::new(RustType::Uniq(Box::new(RustType::Message(
+            RustTypeMessage::from("Ab"),
+        )))));
+        let t2 = RustType::Ref(Box::new(RustType::Message(RustTypeMessage::from("Ab"))));
+
+        assert_eq!("&**v", t1.into_target(&t2, "v", &Customize::default()));
+    }
+}
diff --git a/src/gen/scope.rs b/src/gen/scope.rs
new file mode 100644
index 0000000..f70d233
--- /dev/null
+++ b/src/gen/scope.rs
@@ -0,0 +1,536 @@
+use std::ops::Deref;
+
+use protobuf::reflect::EnumDescriptor;
+use protobuf::reflect::EnumValueDescriptor;
+use protobuf::reflect::FieldDescriptor;
+use protobuf::reflect::FileDescriptor;
+use protobuf::reflect::MessageDescriptor;
+use protobuf::reflect::OneofDescriptor;
+use protobuf_parse::ProtobufAbsPath;
+use protobuf_parse::ProtobufAbsPathRef;
+use protobuf_parse::ProtobufIdentRef;
+use protobuf_parse::ProtobufRelPath;
+use protobuf_parse::ProtobufRelPathRef;
+
+use crate::customize::Customize;
+use crate::gen::field::rust_field_name_for_protobuf_field_name;
+use crate::gen::file_and_mod::FileAndMod;
+use crate::gen::map::map_entry;
+use crate::gen::message::message_name_to_nested_mod_name;
+use crate::gen::paths::proto_path_to_rust_mod;
+use crate::gen::rust::ident::RustIdent;
+use crate::gen::rust::ident_with_path::RustIdentWithPath;
+use crate::gen::rust::rel_path::RustRelativePath;
+use crate::gen::strx::capitalize;
+
+pub(crate) struct RootScope<'a> {
+    pub file_descriptors: &'a [FileDescriptor],
+}
+
+impl<'a> RootScope<'a> {
+    fn packages(&'a self) -> Vec<FileScope<'a>> {
+        self.file_descriptors
+            .iter()
+            .map(|fd| FileScope {
+                file_descriptor: fd,
+            })
+            .collect()
+    }
+
+    // find enum by fully qualified name
+    pub fn _find_enum(&'a self, fqn: &ProtobufAbsPath) -> EnumWithScope<'a> {
+        match self.find_message_or_enum(fqn) {
+            MessageOrEnumWithScope::Enum(e) => e,
+            _ => panic!("not an enum: {}", fqn),
+        }
+    }
+
+    // find message by fully qualified name
+    pub fn find_message(&'a self, fqn: &ProtobufAbsPath) -> MessageWithScope<'a> {
+        match self.find_message_or_enum(fqn) {
+            MessageOrEnumWithScope::Message(m) => m,
+            _ => panic!("not a message: {}", fqn),
+        }
+    }
+
+    // find message or enum by fully qualified name
+    pub fn find_message_or_enum(&'a self, fqn: &ProtobufAbsPath) -> MessageOrEnumWithScope<'a> {
+        assert!(!fqn.is_root());
+        self.packages()
+            .into_iter()
+            .flat_map(|p| p.find_message_or_enum_abs(fqn))
+            .next()
+            .expect(&format!("enum not found by name: {}", fqn))
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct FileScope<'a> {
+    pub file_descriptor: &'a FileDescriptor,
+}
+
+impl<'a> Deref for FileScope<'a> {
+    type Target = FileDescriptor;
+
+    fn deref(&self) -> &Self::Target {
+        self.file_descriptor
+    }
+}
+
+impl<'a> FileScope<'a> {
+    fn package(&self) -> ProtobufAbsPath {
+        ProtobufAbsPath::package_from_file_descriptor(self.file_descriptor)
+    }
+
+    pub fn to_scope(&self) -> Scope<'a> {
+        Scope {
+            file_scope: self.clone(),
+            path: Vec::new(),
+        }
+    }
+
+    fn find_message_or_enum(
+        &self,
+        name: &ProtobufRelPathRef,
+    ) -> Option<MessageOrEnumWithScope<'a>> {
+        self.find_messages_and_enums()
+            .into_iter()
+            .filter(|e| e.protobuf_name_to_package().as_ref() == name)
+            .next()
+    }
+
+    fn find_message_or_enum_abs(
+        &self,
+        name: &ProtobufAbsPathRef,
+    ) -> Option<MessageOrEnumWithScope<'a>> {
+        let name = name.to_owned();
+        match name.remove_prefix(&self.package()) {
+            Some(rem) => self.find_message_or_enum(&rem),
+            None => None,
+        }
+    }
+
+    // find all enums in given file descriptor
+    pub fn find_enums(&self) -> Vec<EnumWithScope<'a>> {
+        let mut r = Vec::new();
+
+        self.to_scope().walk_scopes(|scope| {
+            r.extend(scope.enums());
+        });
+
+        r
+    }
+
+    /// Find all messages in given file descriptor
+    pub fn find_messages(&self) -> Vec<MessageWithScope<'a>> {
+        let mut r = Vec::new();
+
+        self.to_scope().walk_scopes(|scope| {
+            r.extend(scope.messages());
+        });
+
+        r
+    }
+
+    /// Find all messages in given file descriptor, except map messages
+    pub fn find_messages_except_map(&self) -> Vec<MessageWithScope<'a>> {
+        self.find_messages()
+            .into_iter()
+            .filter(|m| !m.is_map())
+            .collect()
+    }
+
+    /// find all messages and enums in given file descriptor
+    pub fn find_messages_and_enums(&self) -> Vec<MessageOrEnumWithScope<'a>> {
+        let mut r = Vec::new();
+
+        self.to_scope().walk_scopes(|scope| {
+            r.extend(scope.messages_and_enums());
+        });
+
+        r
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Scope<'a> {
+    pub file_scope: FileScope<'a>,
+    pub path: Vec<MessageDescriptor>,
+}
+
+impl<'a> Scope<'a> {
+    pub(crate) fn file_descriptor(&self) -> FileDescriptor {
+        self.file_scope.file_descriptor.clone()
+    }
+
+    // get message descriptors in this scope
+    fn message_descriptors(&self) -> Vec<MessageDescriptor> {
+        if self.path.is_empty() {
+            self.file_scope.file_descriptor.messages().collect()
+        } else {
+            self.path.last().unwrap().nested_messages().collect()
+        }
+    }
+
+    // get enum descriptors in this scope
+    fn enum_descriptors(&self) -> Vec<EnumDescriptor> {
+        if self.path.is_empty() {
+            self.file_scope.file_descriptor.enums().collect()
+        } else {
+            self.path.last().unwrap().nested_enums().collect()
+        }
+    }
+
+    // get messages with attached scopes in this scope
+    pub fn messages(&self) -> Vec<MessageWithScope<'a>> {
+        self.message_descriptors()
+            .into_iter()
+            .map(|message| MessageWithScope {
+                scope: self.clone(),
+                message,
+            })
+            .collect()
+    }
+
+    // get enums with attached scopes in this scope
+    pub fn enums(&self) -> Vec<EnumWithScope<'a>> {
+        self.enum_descriptors()
+            .into_iter()
+            .map(|en| EnumWithScope {
+                scope: self.clone(),
+                en,
+            })
+            .collect()
+    }
+
+    // get messages and enums with attached scopes in this scope
+    pub fn messages_and_enums(&self) -> Vec<MessageOrEnumWithScope<'a>> {
+        self.messages()
+            .into_iter()
+            .map(|m| MessageOrEnumWithScope::Message(m))
+            .chain(
+                self.enums()
+                    .into_iter()
+                    .map(|m| MessageOrEnumWithScope::Enum(m)),
+            )
+            .collect()
+    }
+
+    // nested scopes, i. e. scopes of nested messages
+    fn nested_scopes(&self) -> Vec<Scope<'a>> {
+        self.message_descriptors()
+            .into_iter()
+            .map(|m| {
+                let mut nested = self.clone();
+                nested.path.push(m);
+                nested
+            })
+            .collect()
+    }
+
+    fn walk_scopes_impl<F: FnMut(&Scope<'a>)>(&self, callback: &mut F) {
+        (*callback)(self);
+
+        for nested in self.nested_scopes() {
+            nested.walk_scopes_impl(callback);
+        }
+    }
+
+    // apply callback for this scope and all nested scopes
+    fn walk_scopes<F>(&self, mut callback: F)
+    where
+        F: FnMut(&Scope<'a>),
+    {
+        self.walk_scopes_impl(&mut callback);
+    }
+
+    pub fn rust_path_to_file(&self) -> RustRelativePath {
+        RustRelativePath::from_idents(
+            self.path
+                .iter()
+                .map(|m| message_name_to_nested_mod_name(m.name())),
+        )
+    }
+
+    pub fn path_str(&self) -> String {
+        let v: Vec<&str> = self.path.iter().map(|m| m.name()).collect();
+        v.join(".")
+    }
+
+    pub fn prefix(&self) -> String {
+        let path_str = self.path_str();
+        if path_str.is_empty() {
+            path_str
+        } else {
+            format!("{}.", path_str)
+        }
+    }
+
+    pub fn protobuf_path_to_file(&self) -> ProtobufRelPath {
+        ProtobufRelPath::from_components(self.path.iter().map(|m| ProtobufIdentRef::new(m.name())))
+    }
+
+    pub fn protobuf_absolute_path(&self) -> ProtobufAbsPath {
+        let mut r = self.file_scope.package();
+        r.push_relative(&self.protobuf_path_to_file());
+        r
+    }
+
+    pub fn file_and_mod(&self, customize: Customize) -> FileAndMod {
+        FileAndMod {
+            file: self.file_scope.file_descriptor.proto().name().to_owned(),
+            relative_mod: self.rust_path_to_file(),
+            customize,
+        }
+    }
+}
+
+pub(crate) trait WithScope<'a> {
+    fn scope(&self) -> &Scope<'a>;
+
+    fn file_descriptor(&self) -> FileDescriptor {
+        self.scope().file_descriptor()
+    }
+
+    // message or enum name
+    fn name(&self) -> &ProtobufIdentRef;
+
+    fn name_to_package(&self) -> String {
+        let mut r = self.scope().prefix();
+        r.push_str(&self.name());
+        r
+    }
+
+    fn protobuf_name_to_package(&self) -> ProtobufRelPath {
+        let r = self.scope().protobuf_path_to_file();
+        r.append_ident(ProtobufIdentRef::new(self.name()))
+    }
+
+    /// Return absolute name starting with dot
+    fn name_absolute(&self) -> ProtobufAbsPath {
+        let mut path = self.scope().protobuf_absolute_path();
+        path.push_simple(self.name());
+        path
+    }
+
+    // rust type name of this descriptor
+    fn rust_name(&self) -> RustIdent {
+        let rust_name = capitalize(&self.name());
+        RustIdent::new(&rust_name)
+    }
+
+    fn rust_name_to_file(&self) -> RustIdentWithPath {
+        self.scope()
+            .rust_path_to_file()
+            .into_path()
+            .with_ident(self.rust_name())
+    }
+
+    // fully-qualified name of this type
+    fn rust_name_with_file(&self) -> RustIdentWithPath {
+        let mut r = self.rust_name_to_file();
+        r.prepend_ident(proto_path_to_rust_mod(
+            self.scope().file_descriptor().name(),
+        ));
+        r
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct MessageWithScope<'a> {
+    pub scope: Scope<'a>,
+    pub message: MessageDescriptor,
+}
+
+impl<'a> WithScope<'a> for MessageWithScope<'a> {
+    fn scope(&self) -> &Scope<'a> {
+        &self.scope
+    }
+
+    fn name(&self) -> &ProtobufIdentRef {
+        ProtobufIdentRef::new(self.message.name())
+    }
+}
+
+impl<'a> MessageWithScope<'a> {
+    pub fn into_scope(mut self) -> Scope<'a> {
+        self.scope.path.push(self.message);
+        self.scope
+    }
+
+    pub fn to_scope(&self) -> Scope<'a> {
+        self.clone().into_scope()
+    }
+
+    pub fn fields(&self) -> Vec<FieldWithContext<'a>> {
+        self.message
+            .fields()
+            .into_iter()
+            .map(|field| FieldWithContext {
+                field,
+                message: self.clone(),
+            })
+            .collect()
+    }
+
+    pub fn oneofs(&self) -> Vec<OneofWithContext<'a>> {
+        self.message
+            .oneofs()
+            .into_iter()
+            .map(|oneof| OneofWithContext {
+                message: self.clone(),
+                oneof,
+            })
+            .collect()
+    }
+
+    pub fn mod_name(&self) -> RustIdent {
+        message_name_to_nested_mod_name(self.message.name())
+    }
+
+    /// This message is a special message which is a map.
+    pub fn is_map(&self) -> bool {
+        map_entry(self).is_some()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct EnumWithScope<'a> {
+    pub scope: Scope<'a>,
+    pub en: EnumDescriptor,
+}
+
+impl<'a> EnumWithScope<'a> {
+    pub fn values(&self) -> Vec<EnumValueWithContext<'a>> {
+        self.en
+            .values()
+            .into_iter()
+            .map(|v| EnumValueWithContext {
+                en: self.clone(),
+                proto: v,
+            })
+            .collect()
+    }
+
+    // find enum value by protobuf name
+    pub fn value_by_name(&self, name: &str) -> EnumValueWithContext<'a> {
+        self.values()
+            .into_iter()
+            .find(|v| v.proto.proto().name() == name)
+            .unwrap()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct EnumValueWithContext<'a> {
+    pub en: EnumWithScope<'a>,
+    pub proto: EnumValueDescriptor,
+}
+
+impl<'a> EnumValueWithContext<'a> {
+    pub fn rust_name(&self) -> RustIdent {
+        // TODO: camel case or something.
+        RustIdent::new(self.proto.name())
+    }
+}
+
+impl<'a> WithScope<'a> for EnumWithScope<'a> {
+    fn scope(&self) -> &Scope<'a> {
+        &self.scope
+    }
+
+    fn name(&self) -> &ProtobufIdentRef {
+        ProtobufIdentRef::new(self.en.name())
+    }
+}
+
+pub(crate) enum MessageOrEnumWithScope<'a> {
+    Message(MessageWithScope<'a>),
+    Enum(EnumWithScope<'a>),
+}
+
+impl<'a> WithScope<'a> for MessageOrEnumWithScope<'a> {
+    fn scope(&self) -> &Scope<'a> {
+        match self {
+            MessageOrEnumWithScope::Message(m) => m.scope(),
+            MessageOrEnumWithScope::Enum(e) => e.scope(),
+        }
+    }
+
+    fn name(&self) -> &ProtobufIdentRef {
+        match self {
+            MessageOrEnumWithScope::Message(m) => m.name(),
+            MessageOrEnumWithScope::Enum(e) => e.name(),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct FieldWithContext<'a> {
+    pub field: FieldDescriptor,
+    pub message: MessageWithScope<'a>,
+}
+
+impl<'a> Deref for FieldWithContext<'a> {
+    type Target = FieldDescriptor;
+
+    fn deref(&self) -> &Self::Target {
+        &self.field
+    }
+}
+
+impl<'a> FieldWithContext<'a> {
+    pub fn is_oneof(&self) -> bool {
+        self.field.containing_oneof().is_some()
+    }
+
+    pub fn oneof(&self) -> Option<OneofWithContext<'a>> {
+        match self.field.containing_oneof() {
+            Some(oneof) => Some(OneofWithContext {
+                message: self.message.clone(),
+                oneof,
+            }),
+            None => None,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct OneofVariantWithContext<'a> {
+    pub oneof: &'a OneofWithContext<'a>,
+    pub field: FieldDescriptor,
+}
+
+#[derive(Clone)]
+pub(crate) struct OneofWithContext<'a> {
+    pub oneof: OneofDescriptor,
+    pub message: MessageWithScope<'a>,
+}
+
+impl<'a> OneofWithContext<'a> {
+    pub fn field_name(&'a self) -> RustIdent {
+        return rust_field_name_for_protobuf_field_name(self.oneof.name());
+    }
+
+    // rust type name of enum
+    pub fn rust_name(&self) -> RustIdentWithPath {
+        let type_name = RustIdent::from(capitalize(self.oneof.name()));
+        self.message
+            .to_scope()
+            .rust_path_to_file()
+            .into_path()
+            .with_ident(type_name)
+    }
+
+    pub fn variants(&'a self) -> Vec<OneofVariantWithContext<'a>> {
+        self.message
+            .fields()
+            .into_iter()
+            .filter(|f| f.field.containing_oneof().as_ref() == Some(&self.oneof))
+            .map(|f| OneofVariantWithContext {
+                oneof: self,
+                field: f.field,
+            })
+            .collect()
+    }
+}
diff --git a/src/strx.rs b/src/gen/strx.rs
similarity index 100%
rename from src/strx.rs
rename to src/gen/strx.rs
diff --git a/src/gen/well_known_types.rs b/src/gen/well_known_types.rs
new file mode 100644
index 0000000..6b0b389
--- /dev/null
+++ b/src/gen/well_known_types.rs
@@ -0,0 +1,123 @@
+use protobuf_parse::ProtobufAbsPath;
+use protobuf_parse::ProtobufRelPath;
+use protobuf_parse::ProtobufRelPathRef;
+
+use crate::compiler_plugin;
+use crate::gen::code_writer::CodeWriter;
+use crate::gen::paths::proto_path_to_rust_mod;
+
+pub(crate) static WELL_KNOWN_TYPES_PROTO_FILE_NAMES: &[&str] = &[
+    "any.proto",
+    "api.proto",
+    "duration.proto",
+    "empty.proto",
+    "field_mask.proto",
+    "source_context.proto",
+    "struct.proto",
+    "timestamp.proto",
+    "type.proto",
+    "wrappers.proto",
+];
+
+pub(crate) static WELL_KNOWN_TYPES_PROTO_FILE_FULL_NAMES: &[&str] = &[
+    "google/protobuf/any.proto",
+    "google/protobuf/api.proto",
+    "google/protobuf/duration.proto",
+    "google/protobuf/empty.proto",
+    "google/protobuf/field_mask.proto",
+    "google/protobuf/source_context.proto",
+    "google/protobuf/struct.proto",
+    "google/protobuf/timestamp.proto",
+    "google/protobuf/type.proto",
+    "google/protobuf/wrappers.proto",
+];
+
+static NAMES: &'static [&'static str] = &[
+    "Any",
+    "Api",
+    "BoolValue",
+    "BytesValue",
+    "DoubleValue",
+    "Duration",
+    "Empty",
+    "Enum",
+    "EnumValue",
+    "Field",
+    "Field.Cardinality",
+    "Field.Kind",
+    "FieldMask",
+    "FloatValue",
+    "Int32Value",
+    "Int64Value",
+    "ListValue",
+    "Method",
+    "Mixin",
+    "NullValue",
+    "Option",
+    "SourceContext",
+    "StringValue",
+    "Struct",
+    "Syntax",
+    "Timestamp",
+    "Type",
+    "UInt32Value",
+    "UInt64Value",
+    "Value",
+];
+
+fn is_well_known_type(name: &ProtobufRelPathRef) -> bool {
+    NAMES.iter().any(|&n| n == format!("{}", name))
+}
+
+pub(crate) fn is_well_known_type_full(name: &ProtobufAbsPath) -> Option<ProtobufRelPath> {
+    if let Some(rem) = name.remove_prefix(&ProtobufAbsPath::from(".google.protobuf")) {
+        if is_well_known_type(rem) {
+            Some(rem.to_owned())
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
+pub(crate) fn gen_well_known_types_mod() -> compiler_plugin::GenResult {
+    let v = CodeWriter::with_no_error(|w| {
+        w.comment("This file is generated. Do not edit");
+        w.comment("@generated");
+        w.mod_doc("Generated code for \"well known types\"");
+        w.mod_doc("");
+        w.mod_doc("[This document](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf) describes these types.");
+
+        w.write_line("");
+        w.write_line("#![allow(unused_attributes)]");
+        w.write_line("#![cfg_attr(rustfmt, rustfmt::skip)]");
+
+        w.write_line("");
+        for m in WELL_KNOWN_TYPES_PROTO_FILE_NAMES {
+            w.write_line(&format!("pub mod {};", proto_path_to_rust_mod(m)));
+        }
+    });
+
+    compiler_plugin::GenResult {
+        name: "well_known_types_mod.rs".to_string(),
+        content: v.into_bytes(),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_is_well_known_type_full() {
+        assert_eq!(
+            Some(ProtobufRelPath::from("BoolValue")),
+            is_well_known_type_full(&ProtobufAbsPath::from(".google.protobuf.BoolValue"))
+        );
+        assert_eq!(
+            None,
+            is_well_known_type_full(&ProtobufAbsPath::from(".google.protobuf.Fgfg"))
+        );
+    }
+}
diff --git a/src/gen_and_write.rs b/src/gen_and_write.rs
new file mode 100644
index 0000000..95d621e
--- /dev/null
+++ b/src/gen_and_write.rs
@@ -0,0 +1,62 @@
+#![doc(hidden)]
+
+use std::fs;
+use std::io;
+use std::path::Path;
+
+use protobuf::descriptor::FileDescriptorProto;
+use protobuf_parse::ProtoPathBuf;
+
+use crate::customize::CustomizeCallback;
+use crate::gen::all::gen_all;
+use crate::Customize;
+
+#[derive(Debug, thiserror::Error)]
+enum Error {
+    #[error("output path `{0}` is not a directory")]
+    OutputIsNotDirectory(String),
+    #[error("output path `{0}` does not exist or not accessible")]
+    OutputDoesNotExistOrNotAccssible(String, #[source] io::Error),
+    #[error("failed to create file `{0}`: {1}")]
+    FailedToWriteFile(String, #[source] io::Error),
+}
+
+#[doc(hidden)]
+pub fn gen_and_write(
+    file_descriptors: &[FileDescriptorProto],
+    parser: &str,
+    files_to_generate: &[ProtoPathBuf],
+    out_dir: &Path,
+    customize: &Customize,
+    customize_callback: &dyn CustomizeCallback,
+) -> anyhow::Result<()> {
+    match out_dir.metadata() {
+        Ok(m) => {
+            if !m.is_dir() {
+                return Err(Error::OutputIsNotDirectory(out_dir.display().to_string()).into());
+            }
+        }
+        Err(e) => {
+            return Err(
+                Error::OutputDoesNotExistOrNotAccssible(out_dir.display().to_string(), e).into(),
+            );
+        }
+    }
+
+    let results = gen_all(
+        file_descriptors,
+        parser,
+        files_to_generate,
+        customize,
+        customize_callback,
+    )?;
+
+    for r in &results {
+        let mut file_path = out_dir.to_owned();
+        file_path.push(&r.name);
+        fs::write(&file_path, r.content.as_slice())
+            .map_err(|e| Error::FailedToWriteFile(file_path.display().to_string(), e))?;
+    }
+
+    Ok(())
+}
diff --git a/src/inside.rs b/src/inside.rs
deleted file mode 100644
index bbdcfdb..0000000
--- a/src/inside.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use Customize;
-
-/// Path to `protobuf` crate, different when `.proto` file is
-/// used inside or outside of protobuf crate.
-pub(crate) fn protobuf_crate_path(customize: &Customize) -> &str {
-    match customize.inside_protobuf {
-        Some(true) => "crate",
-        _ => "::protobuf",
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index 826e18b..0471d7c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,35 +1,68 @@
-//! # Protobuf code generator
+//! # Protobuf code generator for `protobuf` crate
 //!
-//! This crate contains protobuf code generator implementation
-//! and a `protoc-gen-rust` `protoc` plugin.
+//! This crate is useful mostly from `build.rs` scripts to generate `.rs` files during the build.
 //!
-//! This crate:
-//! * provides `protoc-gen-rust` plugin for `protoc` command
-//! * implement protobuf codegen
+//! # How to generate code
 //!
-//! This crate is not meant to be used directly, in fact, it does not provide any public API
-//! (except for `protoc-gen-rust` binary).
+//! There are three main ways to generate `.rs` files from `.proto` files:
+//! * using `protoc` command line tool and `protoc-gen-rust` plugin
+//! * using this crate `Codegen` with pure rust parser
+//! * using this crate `Codegen` with `protoc` parser
 //!
-//! Code can be generated with either:
-//! * `protoc-gen-rust` plugin for `protoc` or
-//! * [`protoc-rust`](https://docs.rs/protoc) crate
-//!   (code generator which depends on `protoc` binary for parsing of `.proto` files)
-//! * [`protobuf-codegen-pure`](https://docs.rs/protobuf-codegen-pure) crate,
-//!   similar API to `protoc-rust`, but uses pure rust parser of `.proto` files.
+//! Which one should you use depends on your needs.
 //!
-//! # `protoc-gen-rust` plugin for `protoc`
+//! If you are using non-cargo build system (like Bazel), you might prefer
+//! using `protoc-gen-rust` plugin for `protoc`.
 //!
-//! When non-cargo build system is used, consider using standard protobuf code generation pattern:
-//! `protoc` command does all the work of handling paths and parsing `.proto` files.
-//! When `protoc` is invoked with `--rust_out=` option, it invokes `protoc-gen-rust` plugin.
-//! provided by this crate.
+//! If you build with `cargo`, you probably want to use `Codegen` from this crate.
 //!
-//! When building with cargo, consider using `protoc-rust` or `protobuf-codegen-pure` crates.
+//! # Protoc parser vs pure rust parser
 //!
-//! ## How to use `protoc-gen-rust` if you have to
+//! There are two protobuf parsers which can be plugged into this crate:
+//! * `protoc`-based parser (`protoc` is a command like utility from Google protobuf)
+//! * pure rust parser (`protobuf-parse` crate)
+//!
+//! `protoc`-based parser is expected to parse `.proto` files very correctly:
+//! all Google's protobuf implementations rely on it.
+//!
+//! While there are no known bugs in `protobuf-parse`, it is not tested very well.
+//! Also `protobuf-parse` does not implement certain rarely used features of `.proto` parser,
+//! mostly complex message options specified in `.proto` files.
+//! I never saw anyone using them, but you have been warned.
+//!
+//! Note `protoc` command can be obtained from
+//! [`protoc-bin-vendored`](https://docs.rs/protoc-bin-vendored) crate.
+//!
+//! # Example
+//!
+//! ```no_run
+//! # mod protoc_bin_vendored {
+//! #   pub fn protoc_bin_path() -> Result<std::path::PathBuf, std::io::Error> {
+//! #       unimplemented!()
+//! #   }
+//! # }
+//! // Use this in build.rs
+//! protobuf_codegen::Codegen::new()
+//!     // Use `protoc` parser, optional.
+//!     .protoc()
+//!     // Use `protoc-bin-vendored` bundled protoc command, optional.
+//!     .protoc_path(&protoc_bin_vendored::protoc_bin_path().unwrap())
+//!     // All inputs and imports from the inputs must reside in `includes` directories.
+//!     .includes(&["src/protos"])
+//!     // Inputs must reside in some of include paths.
+//!     .input("src/protos/apple.proto")
+//!     .input("src/protos/banana.proto")
+//!     // Specify output directory relative to Cargo output directory.
+//!     .cargo_out_dir("protos")
+//!     .run_from_script();
+//! ```
+//!
+//! ## How to use `protoc-gen-rust`
+//!
+//! If you have to.
 //!
 //! (Note `protoc` can be invoked programmatically with
-//! [protoc crate](https://docs.rs/protoc))
+//! [protoc crate](https://docs.rs/protoc/%3E=3.0.0-alpha))
 //!
 //! 0) Install protobuf for `protoc` binary.
 //!
@@ -46,11 +79,11 @@
 //! ```
 //!
 //! Protobuf is needed only for code generation, `rust-protobuf` runtime
-//! does not use `protobuf` library.
+//! does not use C++ protobuf library.
 //!
 //! 1) Install `protoc-gen-rust` program (which is `protoc` plugin)
 //!
-//! It can be installed either from source or with `cargo install protobuf` command.
+//! It can be installed either from source or with `cargo install protobuf-codegen` command.
 //!
 //! 2) Add `protoc-gen-rust` to $PATH
 //!
@@ -68,320 +101,45 @@
 //!
 //! This will generate .rs files in current directory.
 //!
-//! # Version 2
+//! # Customize generate code
 //!
-//! This is documentation for version 2 of the crate.
+//! Sometimes generated code need to be adjusted, e. g. to have custom derives.
 //!
-//! [Version 3 of the crate](https://docs.rs/protobuf-codegen/%3E=3.0.0-alpha)
-//! (currently in development) encapsulates both `protoc` and pure codegens in this crate.
+//! rust-protobuf provides two options to do that:
+//! * generated `.rs` files contain `@@protoc_insertion_point(...)` markers
+//!   (similar markers inserts Google's protobuf generator for C++ or Java).
+//!   Simple script `sed` one-liners can be used to replace these markers with custom annotations.
+//! * `Codegen::customize_callback` can be used to patch generated code
+//!   when invoked from `build.rs` script.
+//!
+//! # Serde
+//!
+//! rust-protobuf since version 3 no longer directly supports serde.
+//!
+//! Rust-protobuf 3 fully supports:
+//! * runtime reflection
+//! * JSON parsing and printing via
+//!  [`protobuf-json-mapping`](https://docs.rs/protobuf-json-mapping)
+//!
+//! Which covers the most of serde use cases.
+//!
+//! If you still need serde, generic customization callback (see above) can be used
+//! to insert `#[serde(...)]` annotations.
+//!
+//! [Example project](https://github.com/stepancheg/rust-protobuf/tree/master/protobuf-examples/customize-serde)
+//! in the rust-protobuf repository demonstrates how to do it.
 
 #![deny(rustdoc::broken_intra_doc_links)]
-#![deny(missing_docs)]
 
-extern crate protobuf;
-
-use std::collections::hash_map::HashMap;
-use std::fmt::Write as FmtWrite;
-use std::fs::File;
-use std::io;
-use std::io::Write;
-use std::path::Path;
-
-use protobuf::compiler_plugin;
-use protobuf::descriptor::*;
-use protobuf::Message;
-
+mod codegen;
+mod compiler_plugin;
 mod customize;
-mod enums;
-mod extensions;
-mod field;
-mod file;
-mod file_and_mod;
-mod file_descriptor;
-#[doc(hidden)]
-pub mod float;
-mod inside;
-mod message;
-mod oneof;
-mod protobuf_name;
-mod rust_name;
-mod rust_types_values;
-mod serde;
-mod well_known_types;
+mod gen;
+pub mod gen_and_write;
+pub mod protoc_gen_rust;
 
-pub(crate) mod rust;
-pub(crate) mod scope;
-pub(crate) mod strx;
-pub(crate) mod syntax;
-
-use customize::customize_from_rustproto_for_file;
-#[doc(hidden)]
+pub use codegen::Codegen;
 pub use customize::Customize;
-
-pub mod code_writer;
-
-use inside::protobuf_crate_path;
+pub use customize::CustomizeCallback;
 #[doc(hidden)]
-pub use protobuf_name::ProtobufAbsolutePath;
-#[doc(hidden)]
-pub use protobuf_name::ProtobufIdent;
-#[doc(hidden)]
-pub use protobuf_name::ProtobufRelativePath;
-use scope::FileScope;
-use scope::RootScope;
-
-use self::code_writer::CodeWriter;
-use self::enums::*;
-use self::extensions::*;
-use self::message::*;
-use crate::file::proto_path_to_rust_mod;
-
-fn escape_byte(s: &mut String, b: u8) {
-    if b == b'\n' {
-        write!(s, "\\n").unwrap();
-    } else if b == b'\r' {
-        write!(s, "\\r").unwrap();
-    } else if b == b'\t' {
-        write!(s, "\\t").unwrap();
-    } else if b == b'\\' || b == b'"' {
-        write!(s, "\\{}", b as char).unwrap();
-    } else if b == b'\0' {
-        write!(s, "\\0").unwrap();
-    // ASCII printable except space
-    } else if b > 0x20 && b < 0x7f {
-        write!(s, "{}", b as char).unwrap();
-    } else {
-        write!(s, "\\x{:02x}", b).unwrap();
-    }
-}
-
-fn write_file_descriptor_data(
-    file: &FileDescriptorProto,
-    customize: &Customize,
-    w: &mut CodeWriter,
-) {
-    let fdp_bytes = file.write_to_bytes().unwrap();
-    w.write_line("static file_descriptor_proto_data: &'static [u8] = b\"\\");
-    w.indented(|w| {
-        const MAX_LINE_LEN: usize = 72;
-
-        let mut s = String::new();
-        for &b in &fdp_bytes {
-            let prev_len = s.len();
-            escape_byte(&mut s, b);
-            let truncate = s.len() > MAX_LINE_LEN;
-            if truncate {
-                s.truncate(prev_len);
-            }
-            if truncate || s.len() == MAX_LINE_LEN {
-                write!(s, "\\").unwrap();
-                w.write_line(&s);
-                s.clear();
-            }
-            if truncate {
-                escape_byte(&mut s, b);
-            }
-        }
-        if !s.is_empty() {
-            write!(s, "\\").unwrap();
-            w.write_line(&s);
-            s.clear();
-        }
-    });
-    w.write_line("\";");
-    w.write_line("");
-    w.lazy_static(
-        "file_descriptor_proto_lazy",
-        &format!(
-            "{}::descriptor::FileDescriptorProto",
-            protobuf_crate_path(customize)
-        ),
-        customize,
-    );
-    w.write_line("");
-    w.def_fn(
-        &format!(
-            "parse_descriptor_proto() -> {}::descriptor::FileDescriptorProto",
-            protobuf_crate_path(customize)
-        ),
-        |w| {
-            w.write_line(&format!(
-                "{}::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()",
-                protobuf_crate_path(customize)
-            ));
-        },
-    );
-    w.write_line("");
-    w.pub_fn(
-        &format!(
-            "file_descriptor_proto() -> &'static {}::descriptor::FileDescriptorProto",
-            protobuf_crate_path(customize)
-        ),
-        |w| {
-            w.block("file_descriptor_proto_lazy.get(|| {", "})", |w| {
-                w.write_line("parse_descriptor_proto()");
-            });
-        },
-    );
-}
-
-struct GenFileResult {
-    compiler_plugin_result: compiler_plugin::GenResult,
-    mod_name: String,
-}
-
-fn gen_file(
-    file: &FileDescriptorProto,
-    _files_map: &HashMap<&str, &FileDescriptorProto>,
-    root_scope: &RootScope,
-    customize: &Customize,
-) -> GenFileResult {
-    // TODO: use it
-    let mut customize = customize.clone();
-    // options specified in invocation have precedence over options specified in file
-    customize.update_with(&customize_from_rustproto_for_file(file.get_options()));
-
-    let scope = FileScope {
-        file_descriptor: file,
-    }
-    .to_scope();
-    let lite_runtime = customize.lite_runtime.unwrap_or_else(|| {
-        file.get_options().get_optimize_for() == FileOptions_OptimizeMode::LITE_RUNTIME
-    });
-
-    let mut v = Vec::new();
-
-    {
-        let mut w = CodeWriter::new(&mut v);
-
-        w.write_generated_by("rust-protobuf", "2.27.1");
-        w.write_line(&format!("//! Generated file from `{}`", file.get_name()));
-        if customize.inside_protobuf != Some(true) {
-            w.write_line("");
-            w.write_line("/// Generated files are compatible only with the same version");
-            w.write_line("/// of protobuf runtime.");
-            w.commented(|w| {
-                w.write_line(&format!(
-                    "const _PROTOBUF_VERSION_CHECK: () = {}::{};",
-                    protobuf_crate_path(&customize),
-                    protobuf::VERSION_IDENT
-                ));
-            })
-        }
-
-        for message in &scope.get_messages() {
-            // ignore map entries, because they are not used in map fields
-            if message.map_entry().is_none() {
-                w.write_line("");
-                MessageGen::new(message, &root_scope, &customize).write(&mut w);
-            }
-        }
-        for enum_type in &scope.get_enums() {
-            w.write_line("");
-            EnumGen::new(enum_type, file, &customize, root_scope).write(&mut w);
-        }
-
-        write_extensions(file, &root_scope, &mut w, &customize);
-
-        if !lite_runtime {
-            w.write_line("");
-            write_file_descriptor_data(file, &customize, &mut w);
-        }
-    }
-
-    GenFileResult {
-        compiler_plugin_result: compiler_plugin::GenResult {
-            name: format!("{}.rs", proto_path_to_rust_mod(file.get_name())),
-            content: v,
-        },
-        mod_name: proto_path_to_rust_mod(file.get_name()).into_string(),
-    }
-}
-
-fn gen_mod_rs(mods: &[String]) -> compiler_plugin::GenResult {
-    let mut v = Vec::new();
-    let mut w = CodeWriter::new(&mut v);
-    w.comment("@generated");
-    w.write_line("");
-    for m in mods {
-        w.write_line(&format!("pub mod {};", m));
-    }
-    drop(w);
-    compiler_plugin::GenResult {
-        name: "mod.rs".to_owned(),
-        content: v,
-    }
-}
-
-// This function is also used externally by cargo plugin
-// https://github.com/plietar/rust-protobuf-build
-// So be careful changing its signature.
-#[doc(hidden)]
-pub fn gen(
-    file_descriptors: &[FileDescriptorProto],
-    files_to_generate: &[String],
-    customize: &Customize,
-) -> Vec<compiler_plugin::GenResult> {
-    let root_scope = RootScope {
-        file_descriptors: file_descriptors,
-    };
-
-    let mut results: Vec<compiler_plugin::GenResult> = Vec::new();
-    let files_map: HashMap<&str, &FileDescriptorProto> =
-        file_descriptors.iter().map(|f| (f.get_name(), f)).collect();
-
-    let all_file_names: Vec<&str> = file_descriptors.iter().map(|f| f.get_name()).collect();
-
-    let mut mods = Vec::new();
-
-    for file_name in files_to_generate {
-        let file = files_map.get(&file_name[..]).expect(&format!(
-            "file not found in file descriptors: {:?}, files: {:?}",
-            file_name, all_file_names
-        ));
-
-        let gen_file_result = gen_file(file, &files_map, &root_scope, customize);
-        results.push(gen_file_result.compiler_plugin_result);
-        mods.push(gen_file_result.mod_name);
-    }
-
-    if customize.gen_mod_rs.unwrap_or(false) {
-        results.push(gen_mod_rs(&mods));
-    }
-
-    results
-}
-
-#[doc(hidden)]
-pub fn gen_and_write(
-    file_descriptors: &[FileDescriptorProto],
-    files_to_generate: &[String],
-    out_dir: &Path,
-    customize: &Customize,
-) -> io::Result<()> {
-    let results = gen(file_descriptors, files_to_generate, customize);
-
-    for r in &results {
-        let mut file_path = out_dir.to_owned();
-        file_path.push(&r.name);
-        let mut file_writer = File::create(&file_path)?;
-        file_writer.write_all(&r.content)?;
-        file_writer.flush()?;
-    }
-
-    Ok(())
-}
-
-#[doc(hidden)]
-pub fn protoc_gen_rust_main() {
-    compiler_plugin::plugin_main_2(|r| {
-        let customize = Customize::parse_from_parameter(r.parameter).expect("parse options");
-        gen(r.file_descriptors, r.files_to_generate, &customize)
-    });
-}
-
-/// Used in protobuf-codegen-identical-test
-#[doc(hidden)]
-pub fn proto_name_to_rs(name: &str) -> String {
-    format!("{}.rs", proto_path_to_rust_mod(name))
-}
+pub use gen::paths::proto_name_to_rs;
diff --git a/src/message.rs b/src/message.rs
deleted file mode 100644
index fbe9ed4..0000000
--- a/src/message.rs
+++ /dev/null
@@ -1,626 +0,0 @@
-use std::fmt;
-
-use file_descriptor::file_descriptor_proto_expr;
-use inside::protobuf_crate_path;
-use oneof::OneofGen;
-use oneof::OneofVariantGen;
-use protobuf::descriptor::*;
-use rust_name::RustIdentWithPath;
-use scope::MessageWithScope;
-use scope::RootScope;
-use scope::WithScope;
-use serde;
-
-use super::code_writer::*;
-use super::customize::customize_from_rustproto_for_message;
-use super::customize::Customize;
-use super::enums::*;
-use super::field::*;
-use super::rust_types_values::*;
-
-/// Protobuf message Rust type name
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct RustTypeMessage(pub RustIdentWithPath);
-
-impl fmt::Display for RustTypeMessage {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.0, f)
-    }
-}
-
-impl RustTypeMessage {
-    /// Code which emits default instance.
-    pub fn default_instance(&self, customize: &Customize) -> String {
-        format!(
-            "<{} as {}::Message>::default_instance()",
-            self.0,
-            protobuf_crate_path(customize)
-        )
-    }
-}
-
-/// Message info for codegen
-pub(crate) struct MessageGen<'a> {
-    pub message: &'a MessageWithScope<'a>,
-    pub root_scope: &'a RootScope<'a>,
-    type_name: RustIdentWithPath,
-    pub fields: Vec<FieldGen<'a>>,
-    pub lite_runtime: bool,
-    customize: Customize,
-}
-
-impl<'a> MessageGen<'a> {
-    pub fn new(
-        message: &'a MessageWithScope<'a>,
-        root_scope: &'a RootScope<'a>,
-        customize: &Customize,
-    ) -> MessageGen<'a> {
-        let mut customize = customize.clone();
-        customize.update_with(&customize_from_rustproto_for_message(
-            message.message.get_options(),
-        ));
-
-        let fields: Vec<_> = message
-            .fields()
-            .into_iter()
-            .map(|field| FieldGen::parse(field, root_scope, &customize))
-            .collect();
-        let lite_runtime = customize.lite_runtime.unwrap_or_else(|| {
-            message
-                .get_file_descriptor()
-                .get_options()
-                .get_optimize_for()
-                == FileOptions_OptimizeMode::LITE_RUNTIME
-        });
-        MessageGen {
-            message,
-            root_scope,
-            type_name: message.rust_name().into(),
-            fields,
-            lite_runtime,
-            customize,
-        }
-    }
-
-    fn expose_oneof(&self) -> bool {
-        self.customize.expose_oneof.unwrap_or(true)
-    }
-
-    fn oneofs(&'a self) -> Vec<OneofGen<'a>> {
-        self.message
-            .oneofs()
-            .into_iter()
-            .map(|oneof| OneofGen::parse(self, oneof, &self.customize))
-            .collect()
-    }
-
-    fn required_fields(&'a self) -> Vec<&'a FieldGen> {
-        self.fields
-            .iter()
-            .filter(|f| match f.kind {
-                FieldKind::Singular(ref singular) => singular.flag.is_required(),
-                _ => false,
-            })
-            .collect()
-    }
-
-    fn message_fields(&'a self) -> Vec<&'a FieldGen> {
-        self.fields
-            .iter()
-            .filter(|f| f.proto_type == FieldDescriptorProto_Type::TYPE_MESSAGE)
-            .collect()
-    }
-
-    fn fields_except_oneof(&'a self) -> Vec<&'a FieldGen> {
-        self.fields.iter().filter(|f| !f.is_oneof()).collect()
-    }
-
-    fn fields_except_group(&'a self) -> Vec<&'a FieldGen> {
-        self.fields
-            .iter()
-            .filter(|f| f.proto_type != FieldDescriptorProto_Type::TYPE_GROUP)
-            .collect()
-    }
-
-    fn fields_except_oneof_and_group(&'a self) -> Vec<&'a FieldGen> {
-        self.fields
-            .iter()
-            .filter(|f| !f.is_oneof() && f.proto_type != FieldDescriptorProto_Type::TYPE_GROUP)
-            .collect()
-    }
-
-    fn write_match_each_oneof_variant<F>(&self, w: &mut CodeWriter, cb: F)
-    where
-        F: Fn(&mut CodeWriter, &OneofVariantGen, &str, &RustType),
-    {
-        for oneof in self.oneofs() {
-            w.if_let_stmt(
-                "::std::option::Option::Some(ref v)",
-                &format!("self.{}", oneof.oneof.field_name())[..],
-                |w| {
-                    w.match_block("v", |w| {
-                        for variant in oneof.variants_except_group() {
-                            let ref field = variant.field;
-                            let (refv, vtype) = if !field.elem_type_is_copy() {
-                                ("ref v", field.elem().rust_storage_type().ref_type())
-                            } else {
-                                ("v", field.elem().rust_storage_type())
-                            };
-                            w.case_block(format!("&{}({})", variant.path(), refv), |w| {
-                                cb(w, &variant, "v", &vtype);
-                            });
-                        }
-                    });
-                },
-            );
-        }
-    }
-
-    fn write_write_to_with_cached_sizes(&self, w: &mut CodeWriter) {
-        let sig = format!(
-            "write_to_with_cached_sizes(&self, os: &mut {}::CodedOutputStream<'_>) -> {}::ProtobufResult<()>",
-            protobuf_crate_path(&self.customize),
-            protobuf_crate_path(&self.customize),
-        );
-        w.def_fn(&sig, |w| {
-            // To have access to its methods but not polute the name space.
-            for f in self.fields_except_oneof_and_group() {
-                f.write_message_write_field(w);
-            }
-            self.write_match_each_oneof_variant(w, |w, variant, v, v_type| {
-                variant.field.write_write_element(w, "os", v, v_type);
-            });
-            w.write_line("os.write_unknown_fields(self.get_unknown_fields())?;");
-            w.write_line("::std::result::Result::Ok(())");
-        });
-    }
-
-    fn write_get_cached_size(&self, w: &mut CodeWriter) {
-        w.def_fn("get_cached_size(&self) -> u32", |w| {
-            w.write_line("self.cached_size.get()");
-        });
-    }
-
-    fn write_default_instance(&self, w: &mut CodeWriter) {
-        w.def_fn(
-            &format!("default_instance() -> &'static {}", self.type_name),
-            |w| {
-                w.lazy_static_decl_get_simple(
-                    "instance",
-                    &self.type_name.to_string(),
-                    &format!("{}::new", self.type_name),
-                    &self.customize,
-                );
-            },
-        );
-    }
-
-    fn write_compute_size(&self, w: &mut CodeWriter) {
-        // Append sizes of messages in the tree to the specified vector.
-        // First appended element is size of self, and then nested message sizes.
-        // in serialization order are appended recursively.");
-        w.comment("Compute sizes of nested messages");
-        // there are unused variables in oneof
-        w.allow(&["unused_variables"]);
-        w.def_fn("compute_size(&self) -> u32", |w| {
-            // To have access to its methods but not polute the name space.
-            w.write_line("let mut my_size = 0;");
-            for field in self.fields_except_oneof_and_group() {
-                field.write_message_compute_field_size("my_size", w);
-            }
-            self.write_match_each_oneof_variant(w, |w, variant, v, vtype| {
-                variant.field.write_element_size(w, v, vtype, "my_size");
-            });
-            w.write_line(&format!(
-                "my_size += {}::rt::unknown_fields_size(self.get_unknown_fields());",
-                protobuf_crate_path(&self.customize)
-            ));
-            w.write_line("self.cached_size.set(my_size);");
-            w.write_line("my_size");
-        });
-    }
-
-    fn write_field_accessors(&self, w: &mut CodeWriter) {
-        for f in self.fields_except_group() {
-            w.write_line("");
-            let reconstruct_def = f.reconstruct_def();
-            w.comment(&(reconstruct_def + ";"));
-            w.write_line("");
-            f.write_message_single_field_accessors(w);
-        }
-    }
-
-    fn write_impl_self(&self, w: &mut CodeWriter) {
-        w.impl_self_block(&self.type_name.to_string(), |w| {
-            // TODO: new should probably be a part of Message trait
-            w.pub_fn(&format!("new() -> {}", self.type_name), |w| {
-                w.write_line("::std::default::Default::default()");
-            });
-
-            self.write_field_accessors(w);
-        });
-    }
-
-    fn write_unknown_fields(&self, w: &mut CodeWriter) {
-        w.def_fn(
-            &format!(
-                "get_unknown_fields(&self) -> &{}::UnknownFields",
-                protobuf_crate_path(&self.customize)
-            ),
-            |w| {
-                w.write_line("&self.unknown_fields");
-            },
-        );
-        w.write_line("");
-        w.def_fn(
-            &format!(
-                "mut_unknown_fields(&mut self) -> &mut {}::UnknownFields",
-                protobuf_crate_path(&self.customize)
-            ),
-            |w| {
-                w.write_line("&mut self.unknown_fields");
-            },
-        );
-    }
-
-    fn write_merge_from(&self, w: &mut CodeWriter) {
-        let sig = format!(
-            "merge_from(&mut self, is: &mut {}::CodedInputStream<'_>) -> {}::ProtobufResult<()>",
-            protobuf_crate_path(&self.customize),
-            protobuf_crate_path(&self.customize),
-        );
-        w.def_fn(&sig, |w| {
-            w.while_block("!is.eof()?", |w| {
-                w.write_line(&format!("let (field_number, wire_type) = is.read_tag_unpack()?;"));
-                w.match_block("field_number", |w| {
-                    for f in &self.fields_except_group() {
-                        let number = f.proto_field.number();
-                        w.case_block(number.to_string(), |w| {
-                            f.write_merge_from_field("wire_type", w);
-                        });
-                    }
-                    w.case_block("_", |w| {
-                        w.write_line(&format!("{}::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;", protobuf_crate_path(&self.customize)));
-                    });
-                });
-            });
-            w.write_line("::std::result::Result::Ok(())");
-        });
-    }
-
-    fn write_descriptor_field(&self, fields_var: &str, field: &FieldGen, w: &mut CodeWriter) {
-        let accessor_fn = field.accessor_fn();
-        w.write_line(&format!(
-            "{}.push({}::reflect::accessor::{}(",
-            fields_var,
-            protobuf_crate_path(&self.customize),
-            accessor_fn.sig()
-        ));
-        w.indented(|w| {
-            w.write_line(&format!("\"{}\",", field.proto_field.name()));
-            match accessor_fn.style {
-                AccessorStyle::Lambda => {
-                    w.write_line(&format!(
-                        "|m: &{}| {{ &m.{} }},",
-                        self.type_name, field.rust_name
-                    ));
-                    w.write_line(&format!(
-                        "|m: &mut {}| {{ &mut m.{} }},",
-                        self.type_name, field.rust_name
-                    ));
-                }
-                AccessorStyle::HasGet => {
-                    w.write_line(&format!("{}::has_{},", self.type_name, field.rust_name));
-                    w.write_line(&format!("{}::get_{},", self.type_name, field.rust_name));
-                }
-            }
-        });
-        w.write_line("));");
-    }
-
-    fn write_descriptor_static(&self, w: &mut CodeWriter) {
-        w.def_fn(
-            &format!(
-                "descriptor_static() -> &'static {}::reflect::MessageDescriptor",
-                protobuf_crate_path(&self.customize)
-            ),
-            |w| {
-                w.lazy_static_decl_get(
-                    "descriptor",
-                    &format!(
-                        "{}::reflect::MessageDescriptor",
-                        protobuf_crate_path(&self.customize)
-                    ),
-                    &self.customize,
-                    |w| {
-                        let fields = self.fields_except_group();
-                        if fields.is_empty() {
-                            w.write_line(&format!("let fields = ::std::vec::Vec::new();"));
-                        } else {
-                            w.write_line(&format!("let mut fields = ::std::vec::Vec::new();"));
-                        }
-                        for field in fields {
-                            self.write_descriptor_field("fields", field, w);
-                        }
-                        w.write_line(&format!(
-                            "{}::reflect::MessageDescriptor::new_pb_name::<{}>(",
-                            protobuf_crate_path(&self.customize),
-                            self.type_name
-                        ));
-                        w.indented(|w| {
-                            w.write_line(&format!("\"{}\",", self.message.name_to_package()));
-                            w.write_line("fields,");
-                            w.write_line(&file_descriptor_proto_expr(&self.message.scope));
-                        });
-                        w.write_line(")");
-                    },
-                );
-            },
-        );
-    }
-
-    fn write_is_initialized(&self, w: &mut CodeWriter) {
-        w.def_fn(&format!("is_initialized(&self) -> bool"), |w| {
-            // TODO: use single loop
-
-            for f in self.required_fields() {
-                f.write_if_self_field_is_none(w, |w| {
-                    w.write_line("return false;");
-                });
-            }
-
-            for f in self.message_fields() {
-                if let FieldKind::Map(..) = f.kind {
-                    // TODO: check values
-                    continue;
-                }
-
-                // TODO:
-                // if message is declared in this file and has no message fields,
-                // we could skip the check here
-                f.write_for_self_field(w, "v", |w, _t| {
-                    w.if_stmt("!v.is_initialized()", |w| {
-                        w.write_line("return false;");
-                    });
-                });
-            }
-            w.write_line("true");
-        });
-    }
-
-    fn write_impl_message(&self, w: &mut CodeWriter) {
-        w.impl_for_block(
-            &format!("{}::Message", protobuf_crate_path(&self.customize)),
-            &self.type_name.to_string(), |w| {
-            self.write_is_initialized(w);
-            w.write_line("");
-            self.write_merge_from(w);
-            w.write_line("");
-            self.write_compute_size(w);
-            w.write_line("");
-            self.write_write_to_with_cached_sizes(w);
-            w.write_line("");
-            self.write_get_cached_size(w);
-            w.write_line("");
-            self.write_unknown_fields(w);
-            w.write_line("");
-            w.def_fn("as_any(&self) -> &dyn (::std::any::Any)", |w| {
-                w.write_line("self as &dyn (::std::any::Any)");
-            });
-            w.def_fn("as_any_mut(&mut self) -> &mut dyn (::std::any::Any)", |w| {
-                w.write_line("self as &mut dyn (::std::any::Any)");
-            });
-            w.def_fn(
-                "into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>",
-                |w| {
-                    w.write_line("self");
-                },
-            );
-            w.write_line("");
-            w.def_fn(
-                &format!("descriptor(&self) -> &'static {}::reflect::MessageDescriptor", protobuf_crate_path(&self.customize)),
-                |w| {
-                    w.write_line("Self::descriptor_static()");
-                },
-            );
-            w.write_line("");
-            w.def_fn(&format!("new() -> {}", self.type_name), |w| {
-                w.write_line(&format!("{}::new()", self.type_name));
-            });
-            if !self.lite_runtime {
-                w.write_line("");
-                self.write_descriptor_static(w);
-            }
-            w.write_line("");
-            self.write_default_instance(w);
-        });
-    }
-
-    fn write_impl_value(&self, w: &mut CodeWriter) {
-        w.impl_for_block(
-            &format!(
-                "{}::reflect::ProtobufValue",
-                protobuf_crate_path(&self.customize)
-            ),
-            &self.type_name.to_string(),
-            |w| {
-                w.def_fn(
-                    &format!(
-                        "as_ref(&self) -> {}::reflect::ReflectValueRef",
-                        protobuf_crate_path(&self.customize)
-                    ),
-                    |w| {
-                        w.write_line(&format!(
-                            "{}::reflect::ReflectValueRef::Message(self)",
-                            protobuf_crate_path(&self.customize)
-                        ))
-                    },
-                )
-            },
-        )
-    }
-
-    fn write_impl_show(&self, w: &mut CodeWriter) {
-        w.impl_for_block("::std::fmt::Debug", &self.type_name.to_string(), |w| {
-            w.def_fn(
-                "fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result",
-                |w| {
-                    w.write_line(&format!(
-                        "{}::text_format::fmt(self, f)",
-                        protobuf_crate_path(&self.customize)
-                    ));
-                },
-            );
-        });
-    }
-
-    fn write_impl_clear(&self, w: &mut CodeWriter) {
-        w.impl_for_block(
-            &format!("{}::Clear", protobuf_crate_path(&self.customize)),
-            &format!("{}", self.type_name),
-            |w| {
-                w.def_fn("clear(&mut self)", |w| {
-                    for f in self.fields_except_group() {
-                        f.write_clear(w);
-                    }
-                    w.write_line("self.unknown_fields.clear();");
-                });
-            },
-        );
-    }
-
-    #[allow(dead_code)]
-    fn supports_derive_partial_eq(&self) -> bool {
-        // There's stack overflow in the compiler when struct has too many fields
-        // https://github.com/rust-lang/rust/issues/40119
-        self.fields.len() <= 500
-    }
-
-    fn write_struct(&self, w: &mut CodeWriter) {
-        let mut derive = vec!["PartialEq", "Clone", "Default"];
-        if self.lite_runtime {
-            derive.push("Debug");
-        }
-        w.derive(&derive);
-        serde::write_serde_attr(
-            w,
-            &self.customize,
-            "derive(::serde::Serialize, ::serde::Deserialize)",
-        );
-        w.pub_struct(&self.type_name.to_string(), |w| {
-            if !self.fields_except_oneof().is_empty() {
-                w.comment("message fields");
-                for field in self.fields_except_oneof() {
-                    if field.proto_type == FieldDescriptorProto_Type::TYPE_GROUP {
-                        w.comment(&format!("{}: <group>", &field.rust_name));
-                    } else {
-                        let vis = if field.expose_field {
-                            Visibility::Public
-                        } else {
-                            match field.kind {
-                                FieldKind::Repeated(..) => Visibility::Default,
-                                FieldKind::Singular(SingularField { ref flag, .. }) => {
-                                    match *flag {
-                                        SingularFieldFlag::WithFlag { .. } => Visibility::Default,
-                                        SingularFieldFlag::WithoutFlag => Visibility::Public,
-                                    }
-                                }
-                                FieldKind::Map(..) => Visibility::Public,
-                                FieldKind::Oneof(..) => unreachable!(),
-                            }
-                        };
-                        w.field_decl_vis(
-                            vis,
-                            &field.rust_name.get(),
-                            &field.full_storage_type().to_code(&self.customize),
-                        );
-                    }
-                }
-            }
-            if !self.oneofs().is_empty() {
-                w.comment("message oneof groups");
-                for oneof in self.oneofs() {
-                    let vis = match self.expose_oneof() {
-                        true => Visibility::Public,
-                        false => Visibility::Default,
-                    };
-                    w.field_decl_vis(
-                        vis,
-                        oneof.oneof.field_name().get(),
-                        &oneof.full_storage_type().to_code(&self.customize),
-                    );
-                }
-            }
-            w.comment("special fields");
-            serde::write_serde_attr(w, &self.customize, "serde(skip)");
-            w.pub_field_decl(
-                "unknown_fields",
-                &format!("{}::UnknownFields", protobuf_crate_path(&self.customize)),
-            );
-            serde::write_serde_attr(w, &self.customize, "serde(skip)");
-            w.pub_field_decl(
-                "cached_size",
-                &format!("{}::CachedSize", protobuf_crate_path(&self.customize)),
-            );
-        });
-    }
-
-    fn write_impl_default_for_amp(&self, w: &mut CodeWriter) {
-        w.impl_args_for_block(
-            &["'a"],
-            "::std::default::Default",
-            &format!("&'a {}", self.type_name),
-            |w| {
-                w.def_fn(&format!("default() -> &'a {}", self.type_name), |w| {
-                    w.write_line(&format!(
-                        "<{} as {}::Message>::default_instance()",
-                        self.type_name,
-                        protobuf_crate_path(&self.customize),
-                    ));
-                });
-            },
-        );
-    }
-
-    pub fn write(&self, w: &mut CodeWriter) {
-        self.write_struct(w);
-
-        w.write_line("");
-        self.write_impl_default_for_amp(w);
-
-        for oneof in self.oneofs() {
-            w.write_line("");
-            oneof.write_enum(w);
-        }
-
-        w.write_line("");
-        self.write_impl_self(w);
-        w.write_line("");
-        self.write_impl_message(w);
-        w.write_line("");
-        self.write_impl_clear(w);
-        if !self.lite_runtime {
-            w.write_line("");
-            self.write_impl_show(w);
-        }
-        w.write_line("");
-        self.write_impl_value(w);
-
-        let mut nested_prefix = self.type_name.to_string();
-        nested_prefix.push_str("_");
-
-        for nested in &self.message.to_scope().get_messages() {
-            // ignore map entries, because they are not used in map fields
-            if nested.map_entry().is_none() {
-                w.write_line("");
-                MessageGen::new(nested, self.root_scope, &self.customize).write(w);
-            }
-        }
-
-        for enum_type in &self.message.to_scope().get_enums() {
-            w.write_line("");
-            let current_file = self.message.get_scope().get_file_descriptor();
-            EnumGen::new(enum_type, current_file, &self.customize, self.root_scope).write(w);
-        }
-    }
-}
diff --git a/src/oneof.rs b/src/oneof.rs
deleted file mode 100644
index 44201ea..0000000
--- a/src/oneof.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-//! Oneof-related codegen functions.
-
-use std::collections::HashSet;
-
-use code_writer::CodeWriter;
-use field::FieldElem;
-use field::FieldGen;
-use message::MessageGen;
-use protobuf::descriptor::FieldDescriptorProto_Type;
-use protobuf_name::ProtobufAbsolutePath;
-use rust_name::RustIdent;
-use rust_types_values::RustType;
-use scope::FieldWithContext;
-use scope::OneofVariantWithContext;
-use scope::OneofWithContext;
-use scope::RootScope;
-use scope::WithScope;
-use serde;
-use Customize;
-
-// oneof one { ... }
-#[derive(Clone)]
-pub(crate) struct OneofField<'a> {
-    pub elem: FieldElem<'a>,
-    pub oneof_rust_field_name: RustIdent,
-    pub oneof_type_name: RustType,
-    pub boxed: bool,
-}
-
-impl<'a> OneofField<'a> {
-    // Detecting recursion: if oneof fields contains a self-reference
-    // or another message which has a reference to self,
-    // put oneof variant into a box.
-    fn need_boxed(field: &FieldWithContext, root_scope: &RootScope, owner_name: &str) -> bool {
-        let mut visited_messages = HashSet::new();
-        let mut fields = vec![field.clone()];
-        while let Some(field) = fields.pop() {
-            if field.field.get_field_type() == FieldDescriptorProto_Type::TYPE_MESSAGE {
-                let message_name = ProtobufAbsolutePath::from(field.field.get_type_name());
-                if !visited_messages.insert(message_name.clone()) {
-                    continue;
-                }
-                if message_name.path == owner_name {
-                    return true;
-                }
-                let message = root_scope.find_message(&message_name);
-                fields.extend(message.fields().into_iter().filter(|f| f.is_oneof()));
-            }
-        }
-        false
-    }
-
-    pub fn parse(
-        oneof: &OneofWithContext<'a>,
-        field: &FieldWithContext<'a>,
-        elem: FieldElem<'a>,
-        root_scope: &RootScope,
-    ) -> OneofField<'a> {
-        let boxed = OneofField::need_boxed(field, root_scope, &oneof.message.name_absolute().path);
-
-        OneofField {
-            elem,
-            boxed,
-            oneof_rust_field_name: oneof.field_name().into(),
-            oneof_type_name: RustType::Oneof(oneof.rust_name().to_string()),
-        }
-    }
-
-    pub fn rust_type(&self) -> RustType {
-        let t = self.elem.rust_storage_type();
-
-        if self.boxed {
-            RustType::Uniq(Box::new(t))
-        } else {
-            t
-        }
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct OneofVariantGen<'a> {
-    _oneof: &'a OneofGen<'a>,
-    _variant: OneofVariantWithContext<'a>,
-    oneof_field: OneofField<'a>,
-    pub field: FieldGen<'a>,
-    path: String,
-    _customize: Customize,
-}
-
-impl<'a> OneofVariantGen<'a> {
-    fn parse(
-        oneof: &'a OneofGen<'a>,
-        variant: OneofVariantWithContext<'a>,
-        field: &'a FieldGen,
-        _root_scope: &RootScope,
-        customize: Customize,
-    ) -> OneofVariantGen<'a> {
-        OneofVariantGen {
-            _oneof: oneof,
-            _variant: variant.clone(),
-            field: field.clone(),
-            path: format!(
-                "{}::{}",
-                oneof.type_name.to_code(&field.customize),
-                field.rust_name
-            ),
-            oneof_field: OneofField::parse(
-                variant.oneof,
-                &field.proto_field,
-                field.oneof().elem.clone(),
-                oneof.message.root_scope,
-            ),
-            _customize: customize,
-        }
-    }
-
-    fn rust_type(&self) -> RustType {
-        self.oneof_field.rust_type()
-    }
-
-    pub fn path(&self) -> String {
-        self.path.clone()
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct OneofGen<'a> {
-    // Message containing this oneof
-    message: &'a MessageGen<'a>,
-    pub oneof: OneofWithContext<'a>,
-    type_name: RustType,
-    customize: Customize,
-}
-
-impl<'a> OneofGen<'a> {
-    pub fn parse(
-        message: &'a MessageGen,
-        oneof: OneofWithContext<'a>,
-        customize: &Customize,
-    ) -> OneofGen<'a> {
-        let rust_name = oneof.rust_name();
-        OneofGen {
-            message,
-            oneof,
-            type_name: RustType::Oneof(rust_name.to_string()),
-            customize: customize.clone(),
-        }
-    }
-
-    pub fn variants_except_group(&'a self) -> Vec<OneofVariantGen<'a>> {
-        self.oneof
-            .variants()
-            .into_iter()
-            .filter_map(|v| {
-                let field = self
-                    .message
-                    .fields
-                    .iter()
-                    .filter(|f| f.proto_field.name() == v.field.get_name())
-                    .next()
-                    .expect(&format!("field not found by name: {}", v.field.get_name()));
-                match field.proto_type {
-                    FieldDescriptorProto_Type::TYPE_GROUP => None,
-                    _ => Some(OneofVariantGen::parse(
-                        self,
-                        v,
-                        field,
-                        self.message.root_scope,
-                        self.customize.clone(),
-                    )),
-                }
-            })
-            .collect()
-    }
-
-    pub fn full_storage_type(&self) -> RustType {
-        RustType::Option(Box::new(self.type_name.clone()))
-    }
-
-    pub fn write_enum(&self, w: &mut CodeWriter) {
-        let derive = vec!["Clone", "PartialEq", "Debug"];
-        w.derive(&derive);
-        serde::write_serde_attr(
-            w,
-            &self.customize,
-            "derive(::serde::Serialize, ::serde::Deserialize)",
-        );
-        w.pub_enum(&self.type_name.to_code(&self.customize), |w| {
-            for variant in self.variants_except_group() {
-                w.write_line(&format!(
-                    "{}({}),",
-                    variant.field.rust_name,
-                    &variant.rust_type().to_code(&self.customize)
-                ));
-            }
-        });
-    }
-}
diff --git a/src/protobuf_name.rs b/src/protobuf_name.rs
deleted file mode 100644
index c40a69c..0000000
--- a/src/protobuf_name.rs
+++ /dev/null
@@ -1,374 +0,0 @@
-use std::fmt;
-
-/// Identifier in `.proto` file
-#[derive(Eq, PartialEq, Debug, Clone)]
-pub struct ProtobufIdent(String);
-
-impl ProtobufIdent {
-    /// New ident from a string.
-    #[allow(dead_code)]
-    pub fn new(s: &str) -> ProtobufIdent {
-        assert!(!s.is_empty());
-        assert!(!s.contains("/"));
-        assert!(!s.contains("."));
-        assert!(!s.contains(":"));
-        ProtobufIdent(s.to_owned())
-    }
-
-    /// Get as a string.
-    pub fn get(&self) -> &str {
-        &self.0
-    }
-}
-
-impl From<&'_ str> for ProtobufIdent {
-    fn from(s: &str) -> Self {
-        ProtobufIdent::new(s)
-    }
-}
-
-impl From<String> for ProtobufIdent {
-    fn from(s: String) -> Self {
-        ProtobufIdent::new(&s)
-    }
-}
-
-impl fmt::Display for ProtobufIdent {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.get(), f)
-    }
-}
-
-/// Relative protobuf identifier path.
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub struct ProtobufRelativePath {
-    /// The path
-    pub path: String,
-}
-
-#[allow(dead_code)]
-impl ProtobufRelativePath {
-    /// Empty relative path.
-    pub fn empty() -> ProtobufRelativePath {
-        ProtobufRelativePath::new(String::new())
-    }
-
-    /// New path from a string.
-    pub fn new(path: String) -> ProtobufRelativePath {
-        assert!(!path.starts_with("."));
-
-        ProtobufRelativePath { path }
-    }
-
-    /// From path components.
-    pub fn from_components<I: IntoIterator<Item = ProtobufIdent>>(i: I) -> ProtobufRelativePath {
-        let v: Vec<String> = i.into_iter().map(|c| c.get().to_owned()).collect();
-        ProtobufRelativePath::from(v.join("."))
-    }
-
-    /// Get the string.
-    pub fn get(&self) -> &str {
-        &self.path
-    }
-
-    /// The path is empty.
-    pub fn is_empty(&self) -> bool {
-        self.path.is_empty()
-    }
-
-    /// As absolute path from root namespace.
-    pub fn into_absolute(self) -> ProtobufAbsolutePath {
-        if self.is_empty() {
-            ProtobufAbsolutePath::root()
-        } else {
-            ProtobufAbsolutePath::from(format!(".{}", self))
-        }
-    }
-
-    fn _last_part(&self) -> Option<&str> {
-        match self.path.rfind('.') {
-            Some(pos) => Some(&self.path[pos + 1..]),
-            None => {
-                if self.path.is_empty() {
-                    None
-                } else {
-                    Some(&self.path)
-                }
-            }
-        }
-    }
-
-    fn parent(&self) -> Option<ProtobufRelativePath> {
-        match self.path.rfind('.') {
-            Some(pos) => Some(ProtobufRelativePath::new(self.path[..pos].to_owned())),
-            None => {
-                if self.path.is_empty() {
-                    None
-                } else {
-                    Some(ProtobufRelativePath::empty())
-                }
-            }
-        }
-    }
-
-    /// Self path and parent paths.
-    pub fn self_and_parents(&self) -> Vec<ProtobufRelativePath> {
-        let mut tmp = self.clone();
-
-        let mut r = Vec::new();
-
-        r.push(self.clone());
-
-        while let Some(parent) = tmp.parent() {
-            r.push(parent.clone());
-            tmp = parent;
-        }
-
-        r
-    }
-
-    /// Append path component.
-    pub fn append(&self, simple: &ProtobufRelativePath) -> ProtobufRelativePath {
-        if self.path.is_empty() {
-            ProtobufRelativePath::from(simple.get())
-        } else {
-            ProtobufRelativePath::new(format!("{}.{}", self.path, simple))
-        }
-    }
-
-    /// Append identifier to the path.
-    pub fn append_ident(&self, simple: &ProtobufIdent) -> ProtobufRelativePath {
-        self.append(&ProtobufRelativePath::from(simple.clone()))
-    }
-
-    /// Get first component path and remaining.
-    pub fn split_first_rem(&self) -> Option<(ProtobufIdent, ProtobufRelativePath)> {
-        if self.is_empty() {
-            None
-        } else {
-            Some(match self.path.find('.') {
-                Some(dot) => (
-                    ProtobufIdent::from(&self.path[..dot]),
-                    ProtobufRelativePath::new(self.path[dot + 1..].to_owned()),
-                ),
-                None => (
-                    ProtobufIdent::from(self.path.clone()),
-                    ProtobufRelativePath::empty(),
-                ),
-            })
-        }
-    }
-}
-
-impl From<&'_ str> for ProtobufRelativePath {
-    fn from(s: &str) -> ProtobufRelativePath {
-        ProtobufRelativePath::from(s.to_owned())
-    }
-}
-
-impl From<String> for ProtobufRelativePath {
-    fn from(s: String) -> ProtobufRelativePath {
-        ProtobufRelativePath::new(s)
-    }
-}
-
-impl From<ProtobufIdent> for ProtobufRelativePath {
-    fn from(s: ProtobufIdent) -> ProtobufRelativePath {
-        ProtobufRelativePath::from(s.get())
-    }
-}
-
-impl From<Vec<ProtobufIdent>> for ProtobufRelativePath {
-    fn from(s: Vec<ProtobufIdent>) -> ProtobufRelativePath {
-        ProtobufRelativePath::from_components(s.into_iter())
-    }
-}
-
-impl fmt::Display for ProtobufRelativePath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.path, f)
-    }
-}
-
-#[cfg(test)]
-mod relative_path_test {
-    use super::*;
-
-    #[test]
-    fn parent() {
-        assert_eq!(None, ProtobufRelativePath::empty().parent());
-        assert_eq!(
-            Some(ProtobufRelativePath::empty()),
-            ProtobufRelativePath::new("aaa".to_owned()).parent()
-        );
-        assert_eq!(
-            Some(ProtobufRelativePath::new("abc".to_owned())),
-            ProtobufRelativePath::new("abc.def".to_owned()).parent()
-        );
-        assert_eq!(
-            Some(ProtobufRelativePath::new("abc.def".to_owned())),
-            ProtobufRelativePath::new("abc.def.gh".to_owned()).parent()
-        );
-    }
-
-    #[test]
-    fn last_part() {
-        assert_eq!(None, ProtobufRelativePath::empty()._last_part());
-        assert_eq!(
-            Some("aaa"),
-            ProtobufRelativePath::new("aaa".to_owned())._last_part()
-        );
-        assert_eq!(
-            Some("def"),
-            ProtobufRelativePath::new("abc.def".to_owned())._last_part()
-        );
-        assert_eq!(
-            Some("gh"),
-            ProtobufRelativePath::new("abc.def.gh".to_owned())._last_part()
-        );
-    }
-}
-
-/// Absolute protobuf path (e. g. package).
-///
-/// This is not filesystem path.
-#[derive(Clone, Eq, PartialEq, Debug, Hash)]
-pub struct ProtobufAbsolutePath {
-    /// The path.
-    pub path: String,
-}
-
-impl ProtobufAbsolutePath {
-    fn root() -> ProtobufAbsolutePath {
-        ProtobufAbsolutePath::new(String::new())
-    }
-
-    /// From string.
-    pub fn new(path: String) -> ProtobufAbsolutePath {
-        assert!(path.is_empty() || path.starts_with("."), "{}", path);
-        assert!(!path.ends_with("."), "{}", path);
-        ProtobufAbsolutePath { path }
-    }
-
-    /// The path is empty.
-    pub fn is_empty(&self) -> bool {
-        self.path.is_empty()
-    }
-
-    /// From a path without leading dot.
-    ///
-    /// (Protobuf paths start with dot).
-    pub fn from_path_without_dot(path: &str) -> ProtobufAbsolutePath {
-        if path.is_empty() {
-            ProtobufAbsolutePath::root()
-        } else {
-            assert!(!path.starts_with("."));
-            assert!(!path.ends_with("."));
-            ProtobufAbsolutePath::new(format!(".{}", path))
-        }
-    }
-
-    /// Parse absolute path.
-    #[allow(dead_code)]
-    pub fn from_package_path(path: Option<&str>) -> ProtobufAbsolutePath {
-        match path {
-            None => ProtobufAbsolutePath::root(),
-            Some(path) => ProtobufAbsolutePath::from_path_without_dot(path),
-        }
-    }
-
-    /// Construct abs path from a string which may start with a dot.
-    pub fn from_path_maybe_dot(path: &str) -> ProtobufAbsolutePath {
-        if path.starts_with(".") {
-            ProtobufAbsolutePath::new(path.to_owned())
-        } else {
-            ProtobufAbsolutePath::from_path_without_dot(path)
-        }
-    }
-
-    /// Push identifier to the path.
-    pub fn push_simple(&mut self, simple: ProtobufIdent) {
-        self.path.push('.');
-        self.path.push_str(simple.get());
-    }
-
-    /// Push relative path.
-    pub fn push_relative(&mut self, relative: &ProtobufRelativePath) {
-        if !relative.is_empty() {
-            self.path.push('.');
-            self.path.push_str(&relative.path);
-        }
-    }
-
-    /// Try remove a prefix.
-    pub fn remove_prefix(&self, prefix: &ProtobufAbsolutePath) -> Option<ProtobufRelativePath> {
-        if self.path.starts_with(&prefix.path) {
-            let rem = &self.path[prefix.path.len()..];
-            if rem.is_empty() {
-                return Some(ProtobufRelativePath::empty());
-            }
-            if rem.starts_with('.') {
-                return Some(ProtobufRelativePath::new(rem[1..].to_owned()));
-            }
-        }
-        None
-    }
-}
-
-impl From<&'_ str> for ProtobufAbsolutePath {
-    fn from(s: &str) -> Self {
-        ProtobufAbsolutePath::new(s.to_owned())
-    }
-}
-
-impl From<String> for ProtobufAbsolutePath {
-    fn from(s: String) -> Self {
-        ProtobufAbsolutePath::new(s)
-    }
-}
-
-impl fmt::Display for ProtobufAbsolutePath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.path, f)
-    }
-}
-
-#[cfg(test)]
-mod absolute_path_test {
-    use super::*;
-
-    #[test]
-    fn absolute_path_push_simple() {
-        let mut foo = ProtobufAbsolutePath::new(".foo".to_owned());
-        foo.push_simple(ProtobufIdent::from("bar"));
-        assert_eq!(ProtobufAbsolutePath::new(".foo.bar".to_owned()), foo);
-
-        let mut foo = ProtobufAbsolutePath::root();
-        foo.push_simple(ProtobufIdent::from("bar"));
-        assert_eq!(ProtobufAbsolutePath::new(".bar".to_owned()), foo);
-    }
-
-    #[test]
-    fn absolute_path_remove_prefix() {
-        assert_eq!(
-            Some(ProtobufRelativePath::empty()),
-            ProtobufAbsolutePath::new(".foo".to_owned())
-                .remove_prefix(&ProtobufAbsolutePath::new(".foo".to_owned()))
-        );
-        assert_eq!(
-            Some(ProtobufRelativePath::new("bar".to_owned())),
-            ProtobufAbsolutePath::new(".foo.bar".to_owned())
-                .remove_prefix(&ProtobufAbsolutePath::new(".foo".to_owned()))
-        );
-        assert_eq!(
-            Some(ProtobufRelativePath::new("baz.qux".to_owned())),
-            ProtobufAbsolutePath::new(".foo.bar.baz.qux".to_owned())
-                .remove_prefix(&ProtobufAbsolutePath::new(".foo.bar".to_owned()))
-        );
-        assert_eq!(
-            None,
-            ProtobufAbsolutePath::new(".foo.barbaz".to_owned())
-                .remove_prefix(&ProtobufAbsolutePath::new(".foo.bar".to_owned()))
-        );
-    }
-}
diff --git a/src/protoc_gen_rust.rs b/src/protoc_gen_rust.rs
new file mode 100644
index 0000000..014db6a
--- /dev/null
+++ b/src/protoc_gen_rust.rs
@@ -0,0 +1,21 @@
+#![doc(hidden)]
+
+use crate::compiler_plugin;
+use crate::customize::CustomizeCallbackDefault;
+use crate::gen::all::gen_all;
+use crate::Customize;
+
+#[doc(hidden)]
+pub fn protoc_gen_rust_main() {
+    compiler_plugin::plugin_main(|r| {
+        let customize = Customize::parse_from_parameter(r.parameter).expect("parse options");
+        gen_all(
+            r.file_descriptors,
+            "protoc --rust-out=...",
+            r.files_to_generate,
+            &customize,
+            &CustomizeCallbackDefault,
+        )
+    })
+    .expect("plugin failed");
+}
diff --git a/src/rust.rs b/src/rust.rs
deleted file mode 100644
index 263cba0..0000000
--- a/src/rust.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-#[cfg_attr(rustfmt, rustfmt_skip)]
-static RUST_KEYWORDS: &'static [&'static str] = &[
-    "as",
-    "async",
-    "await",
-    "break",
-    "crate",
-    "dyn",
-    "else",
-    "enum",
-    "extern",
-    "false",
-    "fn",
-    "for",
-    "if",
-    "impl",
-    "in",
-    "let",
-    "loop",
-    "match",
-    "mod",
-    "move",
-    "mut",
-    "pub",
-    "ref",
-    "return",
-    "static",
-    "self",
-    "Self",
-    "struct",
-    "super",
-    "true",
-    "trait",
-    "type",
-    "unsafe",
-    "use",
-    "while",
-    "continue",
-    "box",
-    "const",
-    "where",
-    "virtual",
-    "proc",
-    "alignof",
-    "become",
-    "offsetof",
-    "priv",
-    "pure",
-    "sizeof",
-    "typeof",
-    "unsized",
-    "yield",
-    "do",
-    "abstract",
-    "final",
-    "override",
-    "macro",
-];
-
-pub fn is_rust_keyword(ident: &str) -> bool {
-    RUST_KEYWORDS.contains(&ident)
-}
diff --git a/src/rust_name.rs b/src/rust_name.rs
deleted file mode 100644
index 234925b..0000000
--- a/src/rust_name.rs
+++ /dev/null
@@ -1,273 +0,0 @@
-use std::fmt;
-use std::iter;
-
-/// Valid Rust identifier
-#[derive(Eq, PartialEq, Debug, Clone)]
-pub(crate) struct RustIdent(String);
-
-#[allow(dead_code)]
-impl RustIdent {
-    pub fn new(s: &str) -> RustIdent {
-        assert!(!s.is_empty());
-        assert!(!s.contains("/"), "{}", s);
-        assert!(!s.contains("."), "{}", s);
-        assert!(!s.contains(":"), "{}", s);
-        RustIdent(s.to_owned())
-    }
-
-    pub fn super_ident() -> RustIdent {
-        RustIdent::new("super")
-    }
-
-    pub fn get(&self) -> &str {
-        &self.0
-    }
-
-    pub fn into_string(self) -> String {
-        self.0
-    }
-
-    pub fn to_path(&self) -> RustIdentWithPath {
-        RustIdentWithPath::from(&self.0)
-    }
-}
-
-impl fmt::Display for RustIdent {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.get(), f)
-    }
-}
-
-impl From<&'_ str> for RustIdent {
-    fn from(s: &str) -> Self {
-        RustIdent::new(s)
-    }
-}
-
-impl From<String> for RustIdent {
-    fn from(s: String) -> Self {
-        RustIdent::new(&s)
-    }
-}
-
-impl Into<String> for RustIdent {
-    fn into(self) -> String {
-        self.0
-    }
-}
-
-#[derive(Default, Eq, PartialEq, Debug, Clone)]
-pub(crate) struct RustRelativePath {
-    path: Vec<RustIdent>,
-}
-
-#[allow(dead_code)]
-impl RustRelativePath {
-    pub fn into_path(self) -> RustPath {
-        RustPath {
-            absolute: false,
-            path: self,
-        }
-    }
-
-    pub fn empty() -> RustRelativePath {
-        RustRelativePath { path: Vec::new() }
-    }
-
-    pub fn from_components<I: IntoIterator<Item = RustIdent>>(i: I) -> RustRelativePath {
-        RustRelativePath {
-            path: i.into_iter().collect(),
-        }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.path.is_empty()
-    }
-
-    pub fn first(&self) -> Option<RustIdent> {
-        self.path.iter().cloned().next()
-    }
-
-    pub fn remove_first(&mut self) -> Option<RustIdent> {
-        if self.path.is_empty() {
-            None
-        } else {
-            Some(self.path.remove(0))
-        }
-    }
-
-    pub fn prepend_ident(&mut self, ident: RustIdent) {
-        self.path.insert(0, ident);
-    }
-
-    pub fn append(mut self, path: RustRelativePath) -> RustRelativePath {
-        for c in path.path {
-            self.path.push(c);
-        }
-        self
-    }
-
-    pub fn push_ident(&mut self, ident: RustIdent) {
-        self.path.push(ident);
-    }
-
-    pub fn _append_ident(mut self, ident: RustIdent) -> RustRelativePath {
-        self.push_ident(ident);
-        self
-    }
-
-    pub fn to_reverse(&self) -> RustRelativePath {
-        RustRelativePath::from_components(
-            iter::repeat(RustIdent::super_ident()).take(self.path.len()),
-        )
-    }
-}
-
-#[derive(Default, Eq, PartialEq, Debug, Clone)]
-pub(crate) struct RustPath {
-    absolute: bool,
-    path: RustRelativePath,
-}
-
-impl fmt::Display for RustRelativePath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for (i, c) in self.path.iter().enumerate() {
-            if i != 0 {
-                write!(f, "::")?;
-            }
-            write!(f, "{}", c)?;
-        }
-        Ok(())
-    }
-}
-
-impl From<&'_ str> for RustRelativePath {
-    fn from(s: &str) -> Self {
-        RustRelativePath {
-            path: s.split("::").map(RustIdent::from).collect(),
-        }
-    }
-}
-
-#[allow(dead_code)]
-impl RustPath {
-    pub fn is_absolute(&self) -> bool {
-        self.absolute
-    }
-
-    pub fn is_empty(&self) -> bool {
-        assert!(!self.absolute);
-        self.path.is_empty()
-    }
-
-    pub fn with_ident(self, ident: RustIdent) -> RustIdentWithPath {
-        RustIdentWithPath { path: self, ident }
-    }
-
-    pub fn first(&self) -> Option<RustIdent> {
-        assert!(!self.absolute);
-        self.path.first()
-    }
-
-    pub fn remove_first(&mut self) -> Option<RustIdent> {
-        assert!(!self.absolute);
-        self.path.remove_first()
-    }
-
-    pub fn to_reverse(&self) -> RustPath {
-        assert!(!self.absolute);
-        RustPath {
-            absolute: false,
-            path: self.path.to_reverse(),
-        }
-    }
-
-    pub fn prepend_ident(&mut self, ident: RustIdent) {
-        assert!(!self.absolute);
-        self.path.prepend_ident(ident);
-    }
-
-    pub fn append(self, path: RustPath) -> RustPath {
-        if path.absolute {
-            path
-        } else {
-            RustPath {
-                absolute: self.absolute,
-                path: self.path.append(path.path),
-            }
-        }
-    }
-
-    pub fn append_ident(mut self, ident: RustIdent) -> RustPath {
-        self.path.path.push(ident);
-        self
-    }
-
-    pub fn append_with_ident(self, path: RustIdentWithPath) -> RustIdentWithPath {
-        self.append(path.path).with_ident(path.ident)
-    }
-}
-
-impl From<&'_ str> for RustPath {
-    fn from(s: &str) -> Self {
-        let (s, absolute) = if s.starts_with("::") {
-            (&s[2..], true)
-        } else {
-            (s, false)
-        };
-        RustPath {
-            absolute,
-            path: RustRelativePath::from(s),
-        }
-    }
-}
-
-impl From<String> for RustPath {
-    fn from(s: String) -> Self {
-        RustPath::from(&s[..])
-    }
-}
-
-impl fmt::Display for RustPath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.absolute {
-            write!(f, "::")?;
-        }
-        write!(f, "{}", self.path)
-    }
-}
-
-#[derive(Eq, PartialEq, Debug, Clone)]
-pub(crate) struct RustIdentWithPath {
-    pub path: RustPath,
-    pub ident: RustIdent,
-}
-
-#[allow(dead_code)]
-impl RustIdentWithPath {
-    pub fn new(s: String) -> RustIdentWithPath {
-        let mut path = RustPath::from(s);
-        let ident = path.path.path.pop().unwrap();
-        RustIdentWithPath { path, ident }
-    }
-
-    pub fn prepend_ident(&mut self, ident: RustIdent) {
-        self.path.prepend_ident(ident)
-    }
-
-    pub fn to_path(&self) -> RustPath {
-        self.path.clone().append_ident(self.ident.clone())
-    }
-}
-
-impl<S: Into<String>> From<S> for RustIdentWithPath {
-    fn from(s: S) -> Self {
-        RustIdentWithPath::new(s.into())
-    }
-}
-
-impl fmt::Display for RustIdentWithPath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.to_path(), f)
-    }
-}
diff --git a/src/rust_types_values.rs b/src/rust_types_values.rs
deleted file mode 100644
index e9b017d..0000000
--- a/src/rust_types_values.rs
+++ /dev/null
@@ -1,593 +0,0 @@
-use std::cmp;
-
-use inside::protobuf_crate_path;
-use message::RustTypeMessage;
-use protobuf::descriptor::*;
-use protobuf_name::ProtobufAbsolutePath;
-use rust_name::RustIdent;
-use scope::RootScope;
-use scope::WithScope;
-use strx::capitalize;
-use Customize;
-
-use super::well_known_types::is_well_known_type_full;
-
-// Represent subset of rust types used in generated code
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum RustType {
-    // integer: signed?, size in bits
-    Int(bool, u32),
-    // param is size in bits
-    Float(u32),
-    Bool,
-    Vec(Box<RustType>),
-    HashMap(Box<RustType>, Box<RustType>),
-    String,
-    // [T], not &[T]
-    Slice(Box<RustType>),
-    // str, not &str
-    Str,
-    Option(Box<RustType>),
-    SingularField(Box<RustType>),
-    SingularPtrField(Box<RustType>),
-    RepeatedField(Box<RustType>),
-    // Box<T>
-    Uniq(Box<RustType>),
-    // &T
-    Ref(Box<RustType>),
-    // protobuf message
-    Message(RustTypeMessage),
-    // protobuf enum, not any enum
-    Enum(String, RustIdent),
-    // oneof enum
-    Oneof(String),
-    // bytes::Bytes
-    Bytes,
-    // chars::Chars
-    Chars,
-    // group
-    Group,
-}
-
-impl RustType {
-    #[inline]
-    pub(crate) fn to_code(&self, customize: &Customize) -> String {
-        match *self {
-            RustType::Int(true, bits) => format!("i{}", bits),
-            RustType::Int(false, bits) => format!("u{}", bits),
-            RustType::Float(bits) => format!("f{}", bits),
-            RustType::Bool => format!("bool"),
-            RustType::Vec(ref param) => format!("::std::vec::Vec<{}>", param.to_code(customize)),
-            RustType::HashMap(ref key, ref value) => format!(
-                "::std::collections::HashMap<{}, {}>",
-                key.to_code(customize),
-                value.to_code(customize)
-            ),
-            RustType::String => format!("::std::string::String"),
-            RustType::Slice(ref param) => format!("[{}]", param.to_code(customize)),
-            RustType::Str => format!("str"),
-            RustType::Option(ref param) => {
-                format!("::std::option::Option<{}>", param.to_code(customize))
-            }
-            RustType::SingularField(ref param) => format!(
-                "{}::SingularField<{}>",
-                protobuf_crate_path(customize),
-                param.to_code(customize)
-            ),
-            RustType::SingularPtrField(ref param) => format!(
-                "{}::SingularPtrField<{}>",
-                protobuf_crate_path(customize),
-                param.to_code(customize)
-            ),
-            RustType::RepeatedField(ref param) => format!(
-                "{}::RepeatedField<{}>",
-                protobuf_crate_path(customize),
-                param.to_code(customize)
-            ),
-            RustType::Uniq(ref param) => format!("::std::boxed::Box<{}>", param.to_code(customize)),
-            RustType::Ref(ref param) => format!("&{}", param.to_code(customize)),
-            RustType::Message(ref name) => format!("{}", name),
-            RustType::Enum(ref name, _) | RustType::Oneof(ref name) => format!("{}", name),
-            RustType::Group => format!("<group>"),
-            RustType::Bytes => format!("::bytes::Bytes"),
-            RustType::Chars => format!("{}::Chars", protobuf_crate_path(customize)),
-        }
-    }
-}
-
-impl RustType {
-    pub fn u8() -> RustType {
-        RustType::Int(false, 8)
-    }
-
-    /// Type is rust primitive?
-    pub fn is_primitive(&self) -> bool {
-        match *self {
-            RustType::Int(..) | RustType::Float(..) | RustType::Bool => true,
-            _ => false,
-        }
-    }
-
-    pub fn is_u8(&self) -> bool {
-        match *self {
-            RustType::Int(false, 8) => true,
-            _ => false,
-        }
-    }
-
-    pub fn is_copy(&self) -> bool {
-        if self.is_primitive() {
-            true
-        } else if let RustType::Enum(..) = *self {
-            true
-        } else {
-            false
-        }
-    }
-
-    fn is_str(&self) -> bool {
-        match *self {
-            RustType::Str => true,
-            _ => false,
-        }
-    }
-
-    fn is_string(&self) -> bool {
-        match *self {
-            RustType::String => true,
-            _ => false,
-        }
-    }
-
-    fn is_slice(&self) -> Option<&RustType> {
-        match *self {
-            RustType::Slice(ref v) => Some(&**v),
-            _ => None,
-        }
-    }
-
-    fn is_slice_u8(&self) -> bool {
-        match self.is_slice() {
-            Some(t) => t.is_u8(),
-            None => false,
-        }
-    }
-
-    fn is_message(&self) -> bool {
-        match *self {
-            RustType::Message(..) => true,
-            _ => false,
-        }
-    }
-
-    fn is_enum(&self) -> bool {
-        match *self {
-            RustType::Enum(..) => true,
-            _ => false,
-        }
-    }
-
-    pub fn is_ref(&self) -> bool {
-        match *self {
-            RustType::Ref(..) => true,
-            _ => false,
-        }
-    }
-
-    // default value for type
-    pub fn default_value(&self, customize: &Customize) -> String {
-        match *self {
-            RustType::Ref(ref t) if t.is_str() => "\"\"".to_string(),
-            RustType::Ref(ref t) if t.is_slice().is_some() => "&[]".to_string(),
-            RustType::Int(..) => "0".to_string(),
-            RustType::Float(..) => "0.".to_string(),
-            RustType::Bool => "false".to_string(),
-            RustType::Vec(..) => "::std::vec::Vec::new()".to_string(),
-            RustType::HashMap(..) => "::std::collections::HashMap::new()".to_string(),
-            RustType::String => "::std::string::String::new()".to_string(),
-            RustType::Bytes => "::bytes::Bytes::new()".to_string(),
-            RustType::Chars => format!("{}::Chars::new()", protobuf_crate_path(customize)),
-            RustType::Option(..) => "::std::option::Option::None".to_string(),
-            RustType::SingularField(..) => {
-                format!("{}::SingularField::none()", protobuf_crate_path(customize))
-            }
-            RustType::SingularPtrField(..) => format!(
-                "{}::SingularPtrField::none()",
-                protobuf_crate_path(customize)
-            ),
-            RustType::RepeatedField(..) => {
-                format!("{}::RepeatedField::new()", protobuf_crate_path(customize))
-            }
-            RustType::Message(ref name) => format!("{}::new()", name),
-            RustType::Ref(ref m) if m.is_message() => match **m {
-                RustType::Message(ref name) => name.default_instance(customize),
-                _ => unreachable!(),
-            },
-            // Note: default value of enum type may not be equal to default value of field
-            RustType::Enum(ref name, ref default) => format!("{}::{}", name, default),
-            _ => panic!("cannot create default value for: {:?}", *self),
-        }
-    }
-
-    pub fn default_value_typed(self, customize: &Customize) -> RustValueTyped {
-        RustValueTyped {
-            value: self.default_value(customize),
-            rust_type: self,
-        }
-    }
-
-    /// Emit a code to clear a variable `v`
-    pub fn clear(&self, v: &str, customize: &Customize) -> String {
-        match *self {
-            RustType::Option(..) => format!("{} = ::std::option::Option::None", v),
-            RustType::Vec(..)
-            | RustType::Bytes
-            | RustType::String
-            | RustType::RepeatedField(..)
-            | RustType::SingularField(..)
-            | RustType::SingularPtrField(..)
-            | RustType::HashMap(..) => format!("{}.clear()", v),
-            RustType::Chars => format!(
-                "{}::Clear::clear(&mut {})",
-                protobuf_crate_path(customize),
-                v
-            ),
-            RustType::Bool | RustType::Float(..) | RustType::Int(..) | RustType::Enum(..) => {
-                format!("{} = {}", v, self.default_value(customize))
-            }
-            ref ty => panic!("cannot clear type: {:?}", ty),
-        }
-    }
-
-    // wrap value in storage type
-    pub fn wrap_value(&self, value: &str, customize: &Customize) -> String {
-        match *self {
-            RustType::Option(..) => format!("::std::option::Option::Some({})", value),
-            RustType::SingularField(..) => format!(
-                "{}::SingularField::some({})",
-                protobuf_crate_path(customize),
-                value
-            ),
-            RustType::SingularPtrField(..) => format!(
-                "{}::SingularPtrField::some({})",
-                protobuf_crate_path(customize),
-                value
-            ),
-            _ => panic!("not a wrapper type: {:?}", *self),
-        }
-    }
-
-    // expression to convert `v` of type `self` to type `target`
-    pub fn into_target(&self, target: &RustType, v: &str, customize: &Customize) -> String {
-        self.try_into_target(target, v, customize)
-            .expect(&format!("failed to convert {:?} into {:?}", self, target))
-    }
-
-    fn try_into_target(
-        &self,
-        target: &RustType,
-        v: &str,
-        customize: &Customize,
-    ) -> Result<String, ()> {
-        match (self, target) {
-            (x, y) if x == y => return Ok(format!("{}", v)),
-            (&RustType::Ref(ref x), y) if **x == *y => return Ok(format!("*{}", v)),
-            (x, &RustType::Uniq(ref y)) if *x == **y => {
-                return Ok(format!("::std::boxed::Box::new({})", v))
-            }
-            (&RustType::Uniq(ref x), y) if **x == *y => return Ok(format!("*{}", v)),
-            (&RustType::String, &RustType::Ref(ref t)) if **t == RustType::Str => {
-                return Ok(format!("&{}", v))
-            }
-            (&RustType::Chars, &RustType::Ref(ref t)) if **t == RustType::Str => {
-                return Ok(format!("&{}", v))
-            }
-            (&RustType::Ref(ref t1), &RustType::Ref(ref t2)) if t1.is_string() && t2.is_str() => {
-                return Ok(format!("&{}", v))
-            }
-            (&RustType::Ref(ref t1), &RustType::String)
-                if match **t1 {
-                    RustType::Str => true,
-                    _ => false,
-                } =>
-            {
-                return Ok(format!("{}.to_owned()", v))
-            }
-            (&RustType::Ref(ref t1), &RustType::Chars)
-                if match **t1 {
-                    RustType::Str => true,
-                    _ => false,
-                    // TODO: from_static
-                } =>
-            {
-                return Ok(format!(
-                    "<{}::Chars as ::std::convert::From<_>>::from({}.to_owned())",
-                    protobuf_crate_path(customize),
-                    v
-                ))
-            }
-            (&RustType::Ref(ref t1), &RustType::Vec(ref t2))
-                if match (&**t1, &**t2) {
-                    (&RustType::Slice(ref x), ref y) => **x == **y,
-                    _ => false,
-                } =>
-            {
-                return Ok(format!("{}.to_vec()", v))
-            }
-            (&RustType::Ref(ref t1), &RustType::Bytes) if t1.is_slice_u8() => {
-                return Ok(format!(
-                    "<::bytes::Bytes as ::std::convert::From<_>>::from({}.to_vec())",
-                    v
-                ))
-            }
-            (&RustType::Vec(ref x), &RustType::Ref(ref t))
-                if match **t {
-                    RustType::Slice(ref y) => x == y,
-                    _ => false,
-                } =>
-            {
-                return Ok(format!("&{}", v))
-            }
-            (&RustType::Bytes, &RustType::Ref(ref t))
-                if match **t {
-                    RustType::Slice(ref y) => **y == RustType::u8(),
-                    _ => false,
-                } =>
-            {
-                return Ok(format!("&{}", v))
-            }
-            (&RustType::Ref(ref t1), &RustType::Ref(ref t2))
-                if match (&**t1, &**t2) {
-                    (&RustType::Vec(ref x), &RustType::Slice(ref y)) => x == y,
-                    _ => false,
-                } =>
-            {
-                return Ok(format!("&{}", v))
-            }
-            (&RustType::Enum(..), &RustType::Int(true, 32)) => {
-                return Ok(format!(
-                    "{}::ProtobufEnum::value(&{})",
-                    protobuf_crate_path(customize),
-                    v
-                ))
-            }
-            (&RustType::Ref(ref t), &RustType::Int(true, 32)) if t.is_enum() => {
-                return Ok(format!(
-                    "{}::ProtobufEnum::value({})",
-                    protobuf_crate_path(customize),
-                    v
-                ))
-            }
-            _ => (),
-        };
-
-        if let &RustType::Ref(ref s) = self {
-            if let Ok(conv) = s.try_into_target(target, v, customize) {
-                return Ok(conv);
-            }
-        }
-
-        Err(())
-    }
-
-    /// Type to view data of this type
-    pub fn ref_type(&self) -> RustType {
-        RustType::Ref(Box::new(match self {
-            &RustType::String | &RustType::Chars => RustType::Str,
-            &RustType::Vec(ref p) | &RustType::RepeatedField(ref p) => RustType::Slice(p.clone()),
-            &RustType::Bytes => RustType::Slice(Box::new(RustType::u8())),
-            &RustType::Message(ref p) => RustType::Message(p.clone()),
-            x => panic!("no ref type for {:?}", x),
-        }))
-    }
-
-    pub fn elem_type(&self) -> RustType {
-        match self {
-            &RustType::Option(ref ty) => (**ty).clone(),
-            x => panic!("cannot get elem type of {:?}", x),
-        }
-    }
-
-    // type of `v` in `for v in xxx`
-    pub fn iter_elem_type(&self) -> RustType {
-        match self {
-            &RustType::Vec(ref ty)
-            | &RustType::Option(ref ty)
-            | &RustType::RepeatedField(ref ty)
-            | &RustType::SingularField(ref ty)
-            | &RustType::SingularPtrField(ref ty) => RustType::Ref(ty.clone()),
-            x => panic!("cannot iterate {:?}", x),
-        }
-    }
-
-    pub fn value(self, value: String) -> RustValueTyped {
-        RustValueTyped {
-            value: value,
-            rust_type: self,
-        }
-    }
-}
-
-/// Representation of an expression in code generator: text and type
-pub(crate) struct RustValueTyped {
-    pub value: String,
-    pub rust_type: RustType,
-}
-
-impl RustValueTyped {
-    pub fn into_type(&self, target: RustType, customize: &Customize) -> RustValueTyped {
-        let target_value = self.rust_type.into_target(&target, &self.value, customize);
-        RustValueTyped {
-            value: target_value,
-            rust_type: target,
-        }
-    }
-
-    pub fn boxed(self, customize: &Customize) -> RustValueTyped {
-        self.into_type(RustType::Uniq(Box::new(self.rust_type.clone())), customize)
-    }
-}
-
-// protobuf type name for protobuf base type
-pub fn protobuf_name(field_type: FieldDescriptorProto_Type) -> &'static str {
-    match field_type {
-        FieldDescriptorProto_Type::TYPE_DOUBLE => "double",
-        FieldDescriptorProto_Type::TYPE_FLOAT => "float",
-        FieldDescriptorProto_Type::TYPE_INT32 => "int32",
-        FieldDescriptorProto_Type::TYPE_INT64 => "int64",
-        FieldDescriptorProto_Type::TYPE_UINT32 => "uint32",
-        FieldDescriptorProto_Type::TYPE_UINT64 => "uint64",
-        FieldDescriptorProto_Type::TYPE_SINT32 => "sint32",
-        FieldDescriptorProto_Type::TYPE_SINT64 => "sint64",
-        FieldDescriptorProto_Type::TYPE_FIXED32 => "fixed32",
-        FieldDescriptorProto_Type::TYPE_FIXED64 => "fixed64",
-        FieldDescriptorProto_Type::TYPE_SFIXED32 => "sfixed32",
-        FieldDescriptorProto_Type::TYPE_SFIXED64 => "sfixed64",
-        FieldDescriptorProto_Type::TYPE_BOOL => "bool",
-        FieldDescriptorProto_Type::TYPE_STRING => "string",
-        FieldDescriptorProto_Type::TYPE_BYTES => "bytes",
-        FieldDescriptorProto_Type::TYPE_ENUM => "enum",
-        FieldDescriptorProto_Type::TYPE_MESSAGE => "message",
-        FieldDescriptorProto_Type::TYPE_GROUP => "group",
-    }
-}
-
-// rust type for protobuf base type
-pub(crate) fn rust_name(field_type: FieldDescriptorProto_Type) -> RustType {
-    match field_type {
-        FieldDescriptorProto_Type::TYPE_DOUBLE => RustType::Float(64),
-        FieldDescriptorProto_Type::TYPE_FLOAT => RustType::Float(32),
-        FieldDescriptorProto_Type::TYPE_INT32 => RustType::Int(true, 32),
-        FieldDescriptorProto_Type::TYPE_INT64 => RustType::Int(true, 64),
-        FieldDescriptorProto_Type::TYPE_UINT32 => RustType::Int(false, 32),
-        FieldDescriptorProto_Type::TYPE_UINT64 => RustType::Int(false, 64),
-        FieldDescriptorProto_Type::TYPE_SINT32 => RustType::Int(true, 32),
-        FieldDescriptorProto_Type::TYPE_SINT64 => RustType::Int(true, 64),
-        FieldDescriptorProto_Type::TYPE_FIXED32 => RustType::Int(false, 32),
-        FieldDescriptorProto_Type::TYPE_FIXED64 => RustType::Int(false, 64),
-        FieldDescriptorProto_Type::TYPE_SFIXED32 => RustType::Int(true, 32),
-        FieldDescriptorProto_Type::TYPE_SFIXED64 => RustType::Int(true, 64),
-        FieldDescriptorProto_Type::TYPE_BOOL => RustType::Bool,
-        FieldDescriptorProto_Type::TYPE_STRING => RustType::String,
-        FieldDescriptorProto_Type::TYPE_BYTES => RustType::Vec(Box::new(RustType::Int(false, 8))),
-        FieldDescriptorProto_Type::TYPE_ENUM
-        | FieldDescriptorProto_Type::TYPE_GROUP
-        | FieldDescriptorProto_Type::TYPE_MESSAGE => {
-            panic!("there is no rust name for {:?}", field_type)
-        }
-    }
-}
-
-fn file_last_component(file: &str) -> &str {
-    let bs = file.rfind('\\').map(|i| i + 1).unwrap_or(0);
-    let fs = file.rfind('/').map(|i| i + 1).unwrap_or(0);
-    &file[cmp::max(fs, bs)..]
-}
-
-#[cfg(test)]
-#[test]
-fn test_file_last_component() {
-    assert_eq!("ab.proto", file_last_component("ab.proto"));
-    assert_eq!("ab.proto", file_last_component("xx/ab.proto"));
-    assert_eq!("ab.proto", file_last_component("xx\\ab.proto"));
-    assert_eq!("ab.proto", file_last_component("yy\\xx\\ab.proto"));
-}
-
-fn is_descriptor_proto(file: &FileDescriptorProto) -> bool {
-    file.get_package() == "google.protobuf"
-        && file_last_component(file.get_name()) == "descriptor.proto"
-}
-
-pub(crate) fn type_name_to_rust_relative(
-    type_name: &ProtobufAbsolutePath,
-    file: &FileDescriptorProto,
-    subm: bool,
-    root_scope: &RootScope,
-    customize: &Customize,
-) -> String {
-    let message_or_enum = root_scope.find_message_or_enum(type_name);
-    if message_or_enum.get_scope().get_file_descriptor().get_name() == file.get_name() {
-        // field type is a message or enum declared in the same file
-        if subm {
-            format!("super::{}", message_or_enum.rust_name())
-        } else {
-            format!("{}", message_or_enum.rust_name())
-        }
-    } else if let Some(name) = is_well_known_type_full(&type_name.path) {
-        // Well-known types are included in rust-protobuf library
-        // https://developers.google.com/protocol-buffers/docs/reference/google.protobuf
-        format!(
-            "{}::well_known_types::{}",
-            protobuf_crate_path(customize),
-            name
-        )
-    } else if is_descriptor_proto(message_or_enum.get_file_descriptor()) {
-        // Messages defined in descriptor.proto
-        format!(
-            "{}::descriptor::{}",
-            protobuf_crate_path(customize),
-            message_or_enum.name_to_package()
-        )
-    } else {
-        if subm {
-            format!("super::super::{}", message_or_enum.rust_fq_name())
-        } else {
-            format!("super::{}", message_or_enum.rust_fq_name())
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum PrimitiveTypeVariant {
-    Default,
-    Carllerche,
-}
-
-pub enum _CarllercheBytesType {
-    Bytes,
-    Chars,
-}
-
-// ProtobufType trait name
-pub enum ProtobufTypeGen {
-    Primitive(FieldDescriptorProto_Type, PrimitiveTypeVariant),
-    Message(String),
-    Enum(String),
-}
-
-impl ProtobufTypeGen {
-    pub fn rust_type(&self, customize: &Customize) -> String {
-        match self {
-            &ProtobufTypeGen::Primitive(t, PrimitiveTypeVariant::Default) => format!(
-                "{}::types::ProtobufType{}",
-                protobuf_crate_path(customize),
-                capitalize(protobuf_name(t))
-            ),
-            &ProtobufTypeGen::Primitive(
-                FieldDescriptorProto_Type::TYPE_BYTES,
-                PrimitiveTypeVariant::Carllerche,
-            ) => format!(
-                "{}::types::ProtobufTypeCarllercheBytes",
-                protobuf_crate_path(customize)
-            ),
-            &ProtobufTypeGen::Primitive(
-                FieldDescriptorProto_Type::TYPE_STRING,
-                PrimitiveTypeVariant::Carllerche,
-            ) => format!(
-                "{}::types::ProtobufTypeCarllercheChars",
-                protobuf_crate_path(customize)
-            ),
-            &ProtobufTypeGen::Primitive(.., PrimitiveTypeVariant::Carllerche) => unreachable!(),
-            &ProtobufTypeGen::Message(ref name) => format!(
-                "{}::types::ProtobufTypeMessage<{}>",
-                protobuf_crate_path(customize),
-                name
-            ),
-            &ProtobufTypeGen::Enum(ref name) => format!(
-                "{}::types::ProtobufTypeEnum<{}>",
-                protobuf_crate_path(customize),
-                name
-            ),
-        }
-    }
-}
diff --git a/src/scope.rs b/src/scope.rs
deleted file mode 100644
index 5f92d08..0000000
--- a/src/scope.rs
+++ /dev/null
@@ -1,555 +0,0 @@
-use protobuf::descriptor::DescriptorProto;
-use protobuf::descriptor::EnumDescriptorProto;
-use protobuf::descriptor::EnumValueDescriptorProto;
-use protobuf::descriptor::FieldDescriptorProto;
-use protobuf::descriptor::FileDescriptorProto;
-use protobuf::descriptor::OneofDescriptorProto;
-
-use crate::field::rust_field_name_for_protobuf_field_name;
-use crate::file::proto_path_to_rust_mod;
-use crate::protobuf_name::ProtobufAbsolutePath;
-use crate::protobuf_name::ProtobufIdent;
-use crate::protobuf_name::ProtobufRelativePath;
-use crate::rust;
-use crate::rust_name::RustIdent;
-use crate::rust_name::RustIdentWithPath;
-use crate::syntax::Syntax;
-
-pub(crate) struct RootScope<'a> {
-    pub file_descriptors: &'a [FileDescriptorProto],
-}
-
-impl<'a> RootScope<'a> {
-    fn packages(&'a self) -> Vec<FileScope<'a>> {
-        self.file_descriptors
-            .iter()
-            .map(|fd| FileScope {
-                file_descriptor: fd,
-            })
-            .collect()
-    }
-
-    // find enum by fully qualified name
-    pub fn _find_enum(&'a self, fqn: &ProtobufAbsolutePath) -> EnumWithScope<'a> {
-        match self.find_message_or_enum(fqn) {
-            MessageOrEnumWithScope::Enum(e) => e,
-            _ => panic!("not an enum: {}", fqn),
-        }
-    }
-
-    // find message by fully qualified name
-    pub fn find_message(&'a self, fqn: &ProtobufAbsolutePath) -> MessageWithScope<'a> {
-        match self.find_message_or_enum(fqn) {
-            MessageOrEnumWithScope::Message(m) => m,
-            _ => panic!("not a message: {}", fqn),
-        }
-    }
-
-    // find message or enum by fully qualified name
-    pub fn find_message_or_enum(
-        &'a self,
-        fqn: &ProtobufAbsolutePath,
-    ) -> MessageOrEnumWithScope<'a> {
-        assert!(!fqn.is_empty());
-        self.packages()
-            .into_iter()
-            .flat_map(|p| p.find_message_or_enum_abs(fqn))
-            .next()
-            .expect(&format!("enum not found by name: {}", fqn))
-    }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct FileScope<'a> {
-    pub file_descriptor: &'a FileDescriptorProto,
-}
-
-impl<'a> FileScope<'a> {
-    fn get_package(&self) -> ProtobufAbsolutePath {
-        ProtobufRelativePath::from(self.file_descriptor.get_package()).into_absolute()
-    }
-
-    pub fn syntax(&self) -> Syntax {
-        Syntax::parse(self.file_descriptor.get_syntax())
-    }
-
-    pub fn to_scope(&self) -> Scope<'a> {
-        Scope {
-            file_scope: self.clone(),
-            path: Vec::new(),
-        }
-    }
-
-    fn find_message_or_enum(
-        &self,
-        name: &ProtobufRelativePath,
-    ) -> Option<MessageOrEnumWithScope<'a>> {
-        self.find_messages_and_enums()
-            .into_iter()
-            .filter(|e| e.protobuf_name_to_package() == *name)
-            .next()
-    }
-
-    fn find_message_or_enum_abs(
-        &self,
-        name: &ProtobufAbsolutePath,
-    ) -> Option<MessageOrEnumWithScope<'a>> {
-        match name.remove_prefix(&self.get_package()) {
-            Some(ref rem) => self.find_message_or_enum(rem),
-            None => None,
-        }
-    }
-
-    // find all enums in given file descriptor
-    pub fn _find_enums(&self) -> Vec<EnumWithScope<'a>> {
-        let mut r = Vec::new();
-
-        self.to_scope().walk_scopes(|scope| {
-            r.extend(scope.get_enums());
-        });
-
-        r
-    }
-
-    // find all messages in given file descriptor
-    pub fn _find_messages(&self) -> Vec<MessageWithScope<'a>> {
-        let mut r = Vec::new();
-
-        self.to_scope().walk_scopes(|scope| {
-            r.extend(scope.get_messages());
-        });
-
-        r
-    }
-
-    // find all messages and enums in given file descriptor
-    pub fn find_messages_and_enums(&self) -> Vec<MessageOrEnumWithScope<'a>> {
-        let mut r = Vec::new();
-
-        self.to_scope().walk_scopes(|scope| {
-            r.extend(scope.get_messages_and_enums());
-        });
-
-        r
-    }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct Scope<'a> {
-    pub file_scope: FileScope<'a>,
-    pub path: Vec<&'a DescriptorProto>,
-}
-
-impl<'a> Scope<'a> {
-    pub fn get_file_descriptor(&self) -> &'a FileDescriptorProto {
-        self.file_scope.file_descriptor
-    }
-
-    // get message descriptors in this scope
-    fn get_message_descriptors(&self) -> &'a [DescriptorProto] {
-        if self.path.is_empty() {
-            &self.file_scope.file_descriptor.get_message_type()
-        } else {
-            &self.path.last().unwrap().get_nested_type()
-        }
-    }
-
-    // get enum descriptors in this scope
-    fn get_enum_descriptors(&self) -> &'a [EnumDescriptorProto] {
-        if self.path.is_empty() {
-            &self.file_scope.file_descriptor.get_enum_type()
-        } else {
-            &self.path.last().unwrap().get_enum_type()
-        }
-    }
-
-    // get messages with attached scopes in this scope
-    pub fn get_messages(&self) -> Vec<MessageWithScope<'a>> {
-        self.get_message_descriptors()
-            .iter()
-            .map(|m| MessageWithScope {
-                scope: self.clone(),
-                message: m,
-            })
-            .collect()
-    }
-
-    // get enums with attached scopes in this scope
-    pub fn get_enums(&self) -> Vec<EnumWithScope<'a>> {
-        self.get_enum_descriptors()
-            .iter()
-            .map(|e| EnumWithScope {
-                scope: self.clone(),
-                en: e,
-            })
-            .collect()
-    }
-
-    // get messages and enums with attached scopes in this scope
-    pub fn get_messages_and_enums(&self) -> Vec<MessageOrEnumWithScope<'a>> {
-        self.get_messages()
-            .into_iter()
-            .map(|m| MessageOrEnumWithScope::Message(m))
-            .chain(
-                self.get_enums()
-                    .into_iter()
-                    .map(|m| MessageOrEnumWithScope::Enum(m)),
-            )
-            .collect()
-    }
-
-    // nested scopes, i. e. scopes of nested messages
-    fn nested_scopes(&self) -> Vec<Scope<'a>> {
-        self.get_message_descriptors()
-            .iter()
-            .map(|m| {
-                let mut nested = self.clone();
-                nested.path.push(m);
-                nested
-            })
-            .collect()
-    }
-
-    fn walk_scopes_impl<F: FnMut(&Scope<'a>)>(&self, callback: &mut F) {
-        (*callback)(self);
-
-        for nested in self.nested_scopes() {
-            nested.walk_scopes_impl(callback);
-        }
-    }
-
-    // apply callback for this scope and all nested scopes
-    fn walk_scopes<F>(&self, mut callback: F)
-    where
-        F: FnMut(&Scope<'a>),
-    {
-        self.walk_scopes_impl(&mut callback);
-    }
-
-    pub fn prefix(&self) -> String {
-        if self.path.is_empty() {
-            "".to_string()
-        } else {
-            let v: Vec<&'a str> = self.path.iter().map(|m| m.get_name()).collect();
-            let mut r = v.join(".");
-            r.push_str(".");
-            r
-        }
-    }
-
-    pub fn protobuf_path_to_file(&self) -> ProtobufRelativePath {
-        ProtobufRelativePath::from_components(
-            self.path.iter().map(|m| ProtobufIdent::from(m.get_name())),
-        )
-    }
-
-    pub fn protobuf_absolute_path(&self) -> ProtobufAbsolutePath {
-        let mut r = self.file_scope.get_package();
-        r.push_relative(&self.protobuf_path_to_file());
-        r
-    }
-
-    // rust type name prefix for this scope
-    pub fn rust_prefix(&self) -> String {
-        self.prefix().replace(".", "_")
-    }
-}
-
-pub(crate) trait WithScope<'a> {
-    fn get_scope(&self) -> &Scope<'a>;
-
-    fn get_file_descriptor(&self) -> &'a FileDescriptorProto {
-        self.get_scope().get_file_descriptor()
-    }
-
-    // message or enum name
-    fn get_name(&self) -> ProtobufIdent;
-
-    fn escape_prefix(&self) -> &'static str;
-
-    fn name_to_package(&self) -> String {
-        let mut r = self.get_scope().prefix();
-        r.push_str(self.get_name().get());
-        r
-    }
-
-    fn protobuf_name_to_package(&self) -> ProtobufRelativePath {
-        let r = self.get_scope().protobuf_path_to_file();
-        r.append_ident(&ProtobufIdent::from(self.get_name()))
-    }
-
-    /// Return absolute name starting with dot
-    fn name_absolute(&self) -> ProtobufAbsolutePath {
-        let mut path = self.get_scope().protobuf_absolute_path();
-        path.push_simple(self.get_name());
-        path
-    }
-
-    // rust type name of this descriptor
-    fn rust_name(&self) -> RustIdent {
-        let mut r = self.get_scope().rust_prefix();
-        // Only escape if prefix is not empty
-        if r.is_empty() && rust::is_rust_keyword(self.get_name().get()) {
-            r.push_str(self.escape_prefix());
-        }
-        r.push_str(self.get_name().get());
-        RustIdent::from(r)
-    }
-
-    // fully-qualified name of this type
-    fn rust_fq_name(&self) -> String {
-        format!(
-            "{}::{}",
-            proto_path_to_rust_mod(self.get_scope().get_file_descriptor().get_name()),
-            self.rust_name()
-        )
-    }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct MessageWithScope<'a> {
-    pub scope: Scope<'a>,
-    pub message: &'a DescriptorProto,
-}
-
-impl<'a> WithScope<'a> for MessageWithScope<'a> {
-    fn get_scope(&self) -> &Scope<'a> {
-        &self.scope
-    }
-
-    fn escape_prefix(&self) -> &'static str {
-        "message_"
-    }
-
-    fn get_name(&self) -> ProtobufIdent {
-        ProtobufIdent::from(self.message.get_name())
-    }
-}
-
-impl<'a> MessageWithScope<'a> {
-    pub fn into_scope(mut self) -> Scope<'a> {
-        self.scope.path.push(self.message);
-        self.scope
-    }
-
-    pub fn to_scope(&self) -> Scope<'a> {
-        self.clone().into_scope()
-    }
-
-    pub fn fields(&self) -> Vec<FieldWithContext<'a>> {
-        self.message
-            .get_field()
-            .iter()
-            .map(|f| FieldWithContext {
-                field: f,
-                message: self.clone(),
-            })
-            .collect()
-    }
-
-    pub fn oneofs(&self) -> Vec<OneofWithContext<'a>> {
-        self.message
-            .get_oneof_decl()
-            .iter()
-            .enumerate()
-            .map(|(index, oneof)| OneofWithContext {
-                message: self.clone(),
-                oneof: oneof,
-                index: index as u32,
-            })
-            .collect()
-    }
-
-    pub fn oneof_by_index(&self, index: u32) -> OneofWithContext<'a> {
-        self.oneofs().swap_remove(index as usize)
-    }
-
-    /// Pair of (key, value) if this message is map entry
-    pub fn map_entry(&'a self) -> Option<(FieldWithContext<'a>, FieldWithContext<'a>)> {
-        if self.message.get_options().get_map_entry() {
-            let key = self
-                .fields()
-                .into_iter()
-                .find(|f| f.field.get_number() == 1)
-                .unwrap();
-            let value = self
-                .fields()
-                .into_iter()
-                .find(|f| f.field.get_number() == 2)
-                .unwrap();
-            Some((key, value))
-        } else {
-            None
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct EnumWithScope<'a> {
-    pub scope: Scope<'a>,
-    pub en: &'a EnumDescriptorProto,
-}
-
-impl<'a> EnumWithScope<'a> {
-    pub fn values(&self) -> Vec<EnumValueWithContext<'a>> {
-        self.en
-            .get_value()
-            .iter()
-            .map(|v| EnumValueWithContext {
-                _en: self.clone(),
-                proto: v,
-            })
-            .collect()
-    }
-
-    // find enum value by protobuf name
-    pub fn value_by_name(&self, name: &str) -> EnumValueWithContext<'a> {
-        self.values()
-            .into_iter()
-            .find(|v| v.proto.get_name() == name)
-            .unwrap()
-    }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct EnumValueWithContext<'a> {
-    _en: EnumWithScope<'a>,
-    pub proto: &'a EnumValueDescriptorProto,
-}
-
-impl<'a> EnumValueWithContext<'a> {
-    pub fn rust_name(&self) -> RustIdent {
-        let mut r = String::new();
-        if rust::is_rust_keyword(self.proto.get_name()) {
-            r.push_str("value_");
-        }
-        r.push_str(self.proto.get_name());
-        RustIdent::new(&r)
-    }
-}
-
-impl<'a> WithScope<'a> for EnumWithScope<'a> {
-    fn get_scope(&self) -> &Scope<'a> {
-        &self.scope
-    }
-
-    fn escape_prefix(&self) -> &'static str {
-        "enum_"
-    }
-
-    fn get_name(&self) -> ProtobufIdent {
-        ProtobufIdent::from(self.en.get_name())
-    }
-}
-
-pub(crate) enum MessageOrEnumWithScope<'a> {
-    Message(MessageWithScope<'a>),
-    Enum(EnumWithScope<'a>),
-}
-
-impl<'a> WithScope<'a> for MessageOrEnumWithScope<'a> {
-    fn get_scope(&self) -> &Scope<'a> {
-        match self {
-            &MessageOrEnumWithScope::Message(ref m) => m.get_scope(),
-            &MessageOrEnumWithScope::Enum(ref e) => e.get_scope(),
-        }
-    }
-
-    fn escape_prefix(&self) -> &'static str {
-        match self {
-            &MessageOrEnumWithScope::Message(ref m) => m.escape_prefix(),
-            &MessageOrEnumWithScope::Enum(ref e) => e.escape_prefix(),
-        }
-    }
-
-    fn get_name(&self) -> ProtobufIdent {
-        match self {
-            &MessageOrEnumWithScope::Message(ref m) => m.get_name(),
-            &MessageOrEnumWithScope::Enum(ref e) => e.get_name(),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct FieldWithContext<'a> {
-    pub field: &'a FieldDescriptorProto,
-    pub message: MessageWithScope<'a>,
-}
-
-impl<'a> FieldWithContext<'a> {
-    pub fn is_oneof(&self) -> bool {
-        self.field.has_oneof_index()
-    }
-
-    pub fn oneof(&self) -> Option<OneofWithContext<'a>> {
-        if self.is_oneof() {
-            Some(
-                self.message
-                    .oneof_by_index(self.field.get_oneof_index() as u32),
-            )
-        } else {
-            None
-        }
-    }
-
-    pub fn number(&self) -> u32 {
-        self.field.get_number() as u32
-    }
-
-    /// Shortcut
-    pub fn name(&self) -> &str {
-        self.field.get_name()
-    }
-
-    pub fn rust_name(&self) -> RustIdent {
-        rust_field_name_for_protobuf_field_name(self.name())
-    }
-
-    // From field to file root
-    pub fn _containing_messages(&self) -> Vec<&'a DescriptorProto> {
-        let mut r = Vec::new();
-        r.push(self.message.message);
-        r.extend(self.message.scope.path.iter().rev());
-        r
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct OneofVariantWithContext<'a> {
-    pub oneof: &'a OneofWithContext<'a>,
-    pub field: &'a FieldDescriptorProto,
-}
-
-#[derive(Clone)]
-pub(crate) struct OneofWithContext<'a> {
-    pub oneof: &'a OneofDescriptorProto,
-    pub index: u32,
-    pub message: MessageWithScope<'a>,
-}
-
-impl<'a> OneofWithContext<'a> {
-    pub fn field_name(&'a self) -> RustIdent {
-        return rust_field_name_for_protobuf_field_name(self.oneof.get_name());
-    }
-
-    // rust type name of enum
-    pub fn rust_name(&self) -> RustIdentWithPath {
-        RustIdentWithPath::from(format!(
-            "{}_oneof_{}",
-            self.message.rust_name(),
-            self.oneof.get_name()
-        ))
-    }
-
-    pub fn variants(&'a self) -> Vec<OneofVariantWithContext<'a>> {
-        self.message
-            .fields()
-            .iter()
-            .filter(|f| f.field.has_oneof_index() && f.field.get_oneof_index() == self.index as i32)
-            .map(|f| OneofVariantWithContext {
-                oneof: self,
-                field: &f.field,
-            })
-            .collect()
-    }
-}
diff --git a/src/serde.rs b/src/serde.rs
deleted file mode 100644
index f799611..0000000
--- a/src/serde.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use code_writer::CodeWriter;
-use Customize;
-
-/// Write serde attr according to specified codegen option.
-pub fn write_serde_attr(w: &mut CodeWriter, customize: &Customize, attr: &str) {
-    if customize.serde_derive.unwrap_or(false) {
-        w.write_line(&format!("#[cfg_attr(feature = \"with-serde\", {})]", attr));
-    }
-}
diff --git a/src/syntax.rs b/src/syntax.rs
deleted file mode 100644
index d075063..0000000
--- a/src/syntax.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum Syntax {
-    PROTO2,
-    PROTO3,
-}
-
-impl Syntax {
-    pub fn parse(s: &str) -> Self {
-        match s {
-            "" | "proto2" => Syntax::PROTO2,
-            "proto3" => Syntax::PROTO3,
-            _ => panic!("unsupported syntax value: {:?}", s),
-        }
-    }
-}
diff --git a/src/well_known_types.rs b/src/well_known_types.rs
deleted file mode 100644
index 6264947..0000000
--- a/src/well_known_types.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-static NAMES: &'static [&'static str] = &[
-    "Any",
-    "Api",
-    "BoolValue",
-    "BytesValue",
-    "DoubleValue",
-    "Duration",
-    "Empty",
-    "Enum",
-    "EnumValue",
-    "Field",
-    // TODO: dotted names
-    "Field.Cardinality",
-    "Field.Kind",
-    "FieldMask",
-    "FloatValue",
-    "Int32Value",
-    "Int64Value",
-    "ListValue",
-    "Method",
-    "Mixin",
-    "NullValue",
-    "Option",
-    "SourceContext",
-    "StringValue",
-    "Struct",
-    "Syntax",
-    "Timestamp",
-    "Type",
-    "UInt32Value",
-    "UInt64Value",
-    "Value",
-];
-
-fn is_well_known_type(name: &str) -> bool {
-    NAMES.iter().any(|&n| n == name)
-}
-
-pub fn is_well_known_type_full(name: &str) -> Option<&str> {
-    if let Some(dot) = name.rfind('.') {
-        if &name[..dot] == ".google.protobuf" && is_well_known_type(&name[dot + 1..]) {
-            Some(&name[dot + 1..])
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_is_well_known_type_full() {
-        assert_eq!(
-            Some("BoolValue"),
-            is_well_known_type_full(".google.protobuf.BoolValue")
-        );
-        assert_eq!(None, is_well_known_type_full(".google.protobuf.Fgfg"));
-    }
-}