diff --git a/grpc/src/compiler/BUILD b/grpc/src/compiler/BUILD.bazel
similarity index 97%
rename from grpc/src/compiler/BUILD
rename to grpc/src/compiler/BUILD.bazel
index 23fe540..544885e 100644
--- a/grpc/src/compiler/BUILD
+++ b/grpc/src/compiler/BUILD.bazel
@@ -7,7 +7,6 @@
 filegroup(
     name = "common_headers",
     srcs = [
-        "config.h",
         "schema_interface.h",
     ],
 )
@@ -79,7 +78,6 @@
     ],
     hdrs = [
         "python_generator.h",
-        "python_private_generator.h",
         ":common_headers",
     ],
     include_prefix = "src/compiler",
@@ -120,4 +118,4 @@
     deps = [
         "//:flatbuffers",
     ],
-)
\ No newline at end of file
+)
diff --git a/grpc/src/compiler/config.h b/grpc/src/compiler/config.h
deleted file mode 100644
index 4adc594..0000000
--- a/grpc/src/compiler/config.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef SRC_COMPILER_CONFIG_H
-#define SRC_COMPILER_CONFIG_H
-
-// This file is here only because schema_interface.h, which is copied from gRPC,
-// includes it. There is nothing for Flatbuffers to configure.
-
-#endif  // SRC_COMPILER_CONFIG_H
diff --git a/grpc/src/compiler/cpp_generator.cc b/grpc/src/compiler/cpp_generator.cc
index 6cfd22e..69dcf59 100644
--- a/grpc/src/compiler/cpp_generator.cc
+++ b/grpc/src/compiler/cpp_generator.cc
@@ -1,51 +1,17 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
+#include "src/compiler/cpp_generator.h"
 
 #include <map>
-
-#include "src/compiler/cpp_generator.h"
-#include "flatbuffers/util.h"
-
 #include <sstream>
 
+#include "flatbuffers/util.h"
+
 namespace grpc_cpp_generator {
 namespace {
 
 grpc::string message_header_ext() { return "_generated.h"; }
 grpc::string service_header_ext() { return ".grpc.fb.h"; }
 
-template <class T>
-grpc::string as_string(T x) {
+template<class T> grpc::string as_string(T x) {
   std::ostringstream out;
   out << x;
   return out.str();
@@ -76,10 +42,7 @@
 }
 }  // namespace
 
-template <class T, size_t N>
-T *array_end(T (&array)[N]) {
-  return array + N;
-}
+template<class T, size_t N> T *array_end(T (&array)[N]) { return array + N; }
 
 void PrintIncludes(grpc_generator::Printer *printer,
                    const std::vector<grpc::string> &headers,
@@ -92,9 +55,7 @@
   auto &s = params.grpc_search_path;
   if (!s.empty()) {
     vars["l"] += s;
-    if (s[s.size() - 1] != '/') {
-      vars["l"] += '/';
-    }
+    if (s[s.size() - 1] != '/') { vars["l"] += '/'; }
   }
 
   for (auto i = headers.begin(); i != headers.end(); i++) {
@@ -114,7 +75,7 @@
     vars["filename"] = file->filename();
     vars["filename_identifier"] = FilenameIdentifier(file->filename());
     vars["filename_base"] = file->filename_without_ext();
-    vars["message_header_ext"] = message_header_ext();
+    vars["message_header_ext"] = file->message_header_ext();
 
     printer->Print(vars, "// Generated by the gRPC C++ plugin.\n");
     printer->Print(vars,
@@ -144,15 +105,16 @@
     std::map<grpc::string, grpc::string> vars;
 
     static const char *headers_strs[] = {
-        "grpc++/impl/codegen/async_stream.h",
-        "grpc++/impl/codegen/async_unary_call.h",
-        "grpc++/impl/codegen/method_handler_impl.h",
-        "grpc++/impl/codegen/proto_utils.h",
-        "grpc++/impl/codegen/rpc_method.h",
-        "grpc++/impl/codegen/service_type.h",
-        "grpc++/impl/codegen/status.h",
-        "grpc++/impl/codegen/stub_options.h",
-        "grpc++/impl/codegen/sync_stream.h"};
+      "grpcpp/impl/codegen/async_stream.h",
+      "grpcpp/impl/codegen/async_unary_call.h",
+      "grpcpp/impl/codegen/method_handler.h",
+      "grpcpp/impl/codegen/proto_utils.h",
+      "grpcpp/impl/codegen/rpc_method.h",
+      "grpcpp/impl/codegen/service_type.h",
+      "grpcpp/impl/codegen/status.h",
+      "grpcpp/impl/codegen/stub_options.h",
+      "grpcpp/impl/codegen/sync_stream.h"
+    };
     std::vector<grpc::string> headers(headers_strs, array_end(headers_strs));
     PrintIncludes(printer.get(), headers, params);
     printer->Print(vars, "\n");
@@ -187,8 +149,8 @@
     grpc::string prefix;
     grpc::string method_params;  // extra arguments to method
     grpc::string raw_args;       // extra arguments to raw version of method
-  } async_prefixes[] = {{"Async", ", void* tag", ", tag"},
-                        {"PrepareAsync", "", ""}};
+  } async_prefixes[] = { { "Async", ", void* tag", ", tag" },
+                         { "PrepareAsync", "", "" } };
 
   if (is_public) {
     if (method->NoStreaming()) {
@@ -196,8 +158,9 @@
           *vars,
           "virtual ::grpc::Status $Method$(::grpc::ClientContext* context, "
           "const $Request$& request, $Response$* response) = 0;\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         printer->Print(
             *vars,
@@ -228,8 +191,9 @@
           "($Method$Raw(context, response));\n");
       printer->Outdent();
       printer->Print("}\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
@@ -262,8 +226,9 @@
           "($Method$Raw(context, request));\n");
       printer->Outdent();
       printer->Print("}\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
@@ -295,8 +260,9 @@
           "$Method$Raw(context));\n");
       printer->Outdent();
       printer->Print("}\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
@@ -318,8 +284,9 @@
     }
   } else {
     if (method->NoStreaming()) {
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         printer->Print(
             *vars,
@@ -334,8 +301,9 @@
           "virtual ::grpc::ClientWriterInterface< $Request$>*"
           " $Method$Raw("
           "::grpc::ClientContext* context, $Response$* response) = 0;\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         printer->Print(
@@ -351,8 +319,9 @@
           "virtual ::grpc::ClientReaderInterface< $Response$>* "
           "$Method$Raw("
           "::grpc::ClientContext* context, const $Request$& request) = 0;\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         printer->Print(
@@ -367,8 +336,9 @@
                      "virtual ::grpc::ClientReaderWriterInterface< $Request$, "
                      "$Response$>* "
                      "$Method$Raw(::grpc::ClientContext* context) = 0;\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         printer->Print(
@@ -393,8 +363,8 @@
     grpc::string prefix;
     grpc::string method_params;  // extra arguments to method
     grpc::string raw_args;       // extra arguments to raw version of method
-  } async_prefixes[] = {{"Async", ", void* tag", ", tag"},
-                        {"PrepareAsync", "", ""}};
+  } async_prefixes[] = { { "Async", ", void* tag", ", tag" },
+                         { "PrepareAsync", "", "" } };
 
   if (is_public) {
     if (method->NoStreaming()) {
@@ -402,8 +372,9 @@
           *vars,
           "::grpc::Status $Method$(::grpc::ClientContext* context, "
           "const $Request$& request, $Response$* response) override;\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         printer->Print(
             *vars,
@@ -431,8 +402,9 @@
                      "($Method$Raw(context, response));\n");
       printer->Outdent();
       printer->Print("}\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
@@ -463,8 +435,9 @@
           "($Method$Raw(context, request));\n");
       printer->Outdent();
       printer->Print("}\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
@@ -494,8 +467,9 @@
                      "$Method$Raw(context));\n");
       printer->Outdent();
       printer->Print("}\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
@@ -516,8 +490,9 @@
     }
   } else {
     if (method->NoStreaming()) {
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         printer->Print(
             *vars,
@@ -531,8 +506,9 @@
                      "::grpc::ClientWriter< $Request$>* $Method$Raw("
                      "::grpc::ClientContext* context, $Response$* response) "
                      "override;\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
@@ -547,8 +523,9 @@
                      "::grpc::ClientReader< $Response$>* $Method$Raw("
                      "::grpc::ClientContext* context, const $Request$& request)"
                      " override;\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
@@ -562,8 +539,9 @@
       printer->Print(*vars,
                      "::grpc::ClientReaderWriter< $Request$, $Response$>* "
                      "$Method$Raw(::grpc::ClientContext* context) override;\n");
-      for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-        auto& async_prefix = async_prefixes[i];
+      for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+           i++) {
+        auto &async_prefix = async_prefixes[i];
         (*vars)["AsyncPrefix"] = async_prefix.prefix;
         (*vars)["AsyncMethodParams"] = async_prefix.method_params;
         (*vars)["AsyncRawArgs"] = async_prefix.raw_args;
@@ -630,7 +608,8 @@
                  "class WithAsyncMethod_$Method$ : public BaseClass {\n");
   printer->Print(
       " private:\n"
-      "  void BaseClassMustBeDerivedFromService(const Service *service) {}\n");
+      "  void BaseClassMustBeDerivedFromService(const Service */*service*/) "
+      "{}\n");
   printer->Print(" public:\n");
   printer->Indent();
   printer->Print(*vars,
@@ -646,8 +625,8 @@
         *vars,
         "// disable synchronous version of this method\n"
         "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "$Response$* response) final override {\n"
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "$Response$* /*response*/) final override {\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
         "}\n");
@@ -667,8 +646,8 @@
         *vars,
         "// disable synchronous version of this method\n"
         "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, "
-        "::grpc::ServerReader< $Request$>* reader, "
+        "::grpc::ServerContext* /*context*/, "
+        "::grpc::ServerReader< $Request$>* /*reader*/, "
         "$Response$* response) final override {\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@@ -689,8 +668,8 @@
         *vars,
         "// disable synchronous version of this method\n"
         "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "::grpc::ServerWriter< $Response$>* writer) final override "
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "::grpc::ServerWriter< $Response$>* /*writer*/) final override "
         "{\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@@ -712,8 +691,8 @@
         *vars,
         "// disable synchronous version of this method\n"
         "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, "
-        "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
+        "::grpc::ServerContext* /*context*/, "
+        "::grpc::ServerReaderWriter< $Response$, $Request$>* /*stream*/) "
         "final override {\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@@ -747,7 +726,7 @@
                    "public BaseClass {\n");
     printer->Print(
         " private:\n"
-        "  void BaseClassMustBeDerivedFromService(const Service *service) "
+        "  void BaseClassMustBeDerivedFromService(const Service */*service*/) "
         "{}\n");
     printer->Print(" public:\n");
     printer->Indent();
@@ -768,8 +747,8 @@
         *vars,
         "// disable regular version of this method\n"
         "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "$Response$* response) final override {\n"
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "$Response$* /*response*/) final override {\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
         "}\n");
@@ -798,8 +777,8 @@
                    "public BaseClass {\n");
     printer->Print(
         " private:\n"
-        "  void BaseClassMustBeDerivedFromService(const Service *service) "
-        "{}\n");
+        "  void BaseClassMustBeDerivedFromService(const Service */*service*/) "
+        "{ }\n");
     printer->Print(" public:\n");
     printer->Indent();
     printer->Print(
@@ -820,8 +799,8 @@
         *vars,
         "// disable regular version of this method\n"
         "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "::grpc::ServerWriter< $Response$>* writer) final override "
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "::grpc::ServerWriter< $Response$>* /*writer*/) final override "
         "{\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@@ -849,7 +828,8 @@
                  "class WithGenericMethod_$Method$ : public BaseClass {\n");
   printer->Print(
       " private:\n"
-      "  void BaseClassMustBeDerivedFromService(const Service *service) {}\n");
+      "  void BaseClassMustBeDerivedFromService(const Service */*service*/) "
+      "{}\n");
   printer->Print(" public:\n");
   printer->Indent();
   printer->Print(*vars,
@@ -865,8 +845,8 @@
         *vars,
         "// disable synchronous version of this method\n"
         "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "$Response$* response) final override {\n"
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "$Response$* /*response*/) final override {\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
         "}\n");
@@ -875,9 +855,9 @@
         *vars,
         "// disable synchronous version of this method\n"
         "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, "
-        "::grpc::ServerReader< $Request$>* reader, "
-        "$Response$* response) final override {\n"
+        "::grpc::ServerContext* /*context*/, "
+        "::grpc::ServerReader< $Request$>* /*reader*/, "
+        "$Response$* /*response*/) final override {\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
         "}\n");
@@ -886,8 +866,8 @@
         *vars,
         "// disable synchronous version of this method\n"
         "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, const $Request$* request, "
-        "::grpc::ServerWriter< $Response$>* writer) final override "
+        "::grpc::ServerContext* /*context*/, const $Request$* /*request*/, "
+        "::grpc::ServerWriter< $Response$>* /*writer*/) final override "
         "{\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@@ -897,8 +877,8 @@
         *vars,
         "// disable synchronous version of this method\n"
         "::grpc::Status $Method$("
-        "::grpc::ServerContext* context, "
-        "::grpc::ServerReaderWriter< $Response$, $Request$>* stream) "
+        "::grpc::ServerContext* /*context*/, "
+        "::grpc::ServerReaderWriter< $Response$, $Request$>* /*stream*/) "
         "final override {\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
@@ -1001,9 +981,7 @@
     printer->Print(*vars, "WithAsyncMethod_$method_name$<");
   }
   printer->Print("Service");
-  for (int i = 0; i < service->method_count(); ++i) {
-    printer->Print(" >");
-  }
+  for (int i = 0; i < service->method_count(); ++i) { printer->Print(" >"); }
   printer->Print(" AsyncService;\n");
 
   // Server side - Generic
@@ -1028,9 +1006,7 @@
   }
   printer->Print("Service");
   for (int i = 0; i < service->method_count(); ++i) {
-    if (service->method(i)->NoStreaming()) {
-      printer->Print(" >");
-    }
+    if (service->method(i)->NoStreaming()) { printer->Print(" >"); }
   }
   printer->Print(" StreamedUnaryService;\n");
 
@@ -1052,9 +1028,7 @@
   printer->Print("Service");
   for (int i = 0; i < service->method_count(); ++i) {
     auto method = service->method(i);
-    if (ServerOnlyStreaming(method.get())) {
-      printer->Print(" >");
-    }
+    if (ServerOnlyStreaming(method.get())) { printer->Print(" >"); }
   }
   printer->Print(" SplitStreamedService;\n");
 
@@ -1095,9 +1069,7 @@
     // Package string is empty or ends with a dot. It is used to fully qualify
     // method names.
     vars["Package"] = file->package();
-    if (!file->package().empty()) {
-      vars["Package"].append(".");
-    }
+    if (!file->package().empty()) { vars["Package"].append("."); }
 
     if (!params.services_namespace.empty()) {
       vars["services_namespace"] = params.services_namespace;
@@ -1155,8 +1127,8 @@
 
     vars["filename"] = file->filename();
     vars["filename_base"] = file->filename_without_ext();
-    vars["message_header_ext"] = message_header_ext();
-    vars["service_header_ext"] = service_header_ext();
+    vars["message_header_ext"] = file->message_header_ext();
+    vars["service_header_ext"] = file->service_header_ext();
 
     printer->Print(vars, "// Generated by the gRPC C++ plugin.\n");
     printer->Print(vars,
@@ -1179,14 +1151,15 @@
     std::map<grpc::string, grpc::string> vars;
 
     static const char *headers_strs[] = {
-        "grpc++/impl/codegen/async_stream.h",
-        "grpc++/impl/codegen/async_unary_call.h",
-        "grpc++/impl/codegen/channel_interface.h",
-        "grpc++/impl/codegen/client_unary_call.h",
-        "grpc++/impl/codegen/method_handler_impl.h",
-        "grpc++/impl/codegen/rpc_service_method.h",
-        "grpc++/impl/codegen/service_type.h",
-        "grpc++/impl/codegen/sync_stream.h"};
+      "grpcpp/impl/codegen/async_stream.h",
+      "grpcpp/impl/codegen/async_unary_call.h",
+      "grpcpp/impl/codegen/channel_interface.h",
+      "grpcpp/impl/codegen/client_unary_call.h",
+      "grpcpp/impl/codegen/method_handler.h",
+      "grpcpp/impl/codegen/rpc_service_method.h",
+      "grpcpp/impl/codegen/service_type.h",
+      "grpcpp/impl/codegen/sync_stream.h"
+    };
     std::vector<grpc::string> headers(headers_strs, array_end(headers_strs));
     PrintIncludes(printer.get(), headers, params);
 
@@ -1215,8 +1188,8 @@
     grpc::string start;          // bool literal expressed as string
     grpc::string method_params;  // extra arguments to method
     grpc::string create_args;    // extra arguments to creator
-  } async_prefixes[] = {{"Async", "true", ", void* tag", ", tag"},
-                        {"PrepareAsync", "false", "", ", nullptr"}};
+  } async_prefixes[] = { { "Async", "true", ", void* tag", ", tag" },
+                         { "PrepareAsync", "false", "", ", nullptr" } };
   if (method->NoStreaming()) {
     printer->Print(*vars,
                    "::grpc::Status $ns$$Service$::Stub::$Method$("
@@ -1226,8 +1199,9 @@
                    "  return ::grpc::internal::BlockingUnaryCall"
                    "(channel_.get(), rpcmethod_$Method$_, "
                    "context, request, response);\n}\n\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-      auto& async_prefix = async_prefixes[i];
+    for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+         i++) {
+      auto &async_prefix = async_prefixes[i];
       (*vars)["AsyncPrefix"] = async_prefix.prefix;
       (*vars)["AsyncStart"] = async_prefix.start;
       printer->Print(*vars,
@@ -1257,8 +1231,9 @@
         "rpcmethod_$Method$_, "
         "context, response);\n"
         "}\n\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-      auto& async_prefix = async_prefixes[i];
+    for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+         i++) {
+      auto &async_prefix = async_prefixes[i];
       (*vars)["AsyncPrefix"] = async_prefix.prefix;
       (*vars)["AsyncStart"] = async_prefix.start;
       (*vars)["AsyncMethodParams"] = async_prefix.method_params;
@@ -1289,8 +1264,9 @@
         "rpcmethod_$Method$_, "
         "context, request);\n"
         "}\n\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-      auto& async_prefix = async_prefixes[i];
+    for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+         i++) {
+      auto &async_prefix = async_prefixes[i];
       (*vars)["AsyncPrefix"] = async_prefix.prefix;
       (*vars)["AsyncStart"] = async_prefix.start;
       (*vars)["AsyncMethodParams"] = async_prefix.method_params;
@@ -1321,8 +1297,9 @@
                    "rpcmethod_$Method$_, "
                    "context);\n"
                    "}\n\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-      auto& async_prefix = async_prefixes[i];
+    for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+         i++) {
+      auto &async_prefix = async_prefixes[i];
       (*vars)["AsyncPrefix"] = async_prefix.prefix;
       (*vars)["AsyncStart"] = async_prefix.start;
       (*vars)["AsyncMethodParams"] = async_prefix.method_params;
@@ -1351,13 +1328,11 @@
   (*vars)["Request"] = method->input_type_name();
   (*vars)["Response"] = method->output_type_name();
   if (method->NoStreaming()) {
-    printer->Print(*vars,
-                   "::grpc::Status $ns$$Service$::Service::$Method$("
-                   "::grpc::ServerContext* context, "
-                   "const $Request$* request, $Response$* response) {\n");
-    printer->Print("  (void) context;\n");
-    printer->Print("  (void) request;\n");
-    printer->Print("  (void) response;\n");
+    printer->Print(
+        *vars,
+        "::grpc::Status $ns$$Service$::Service::$Method$("
+        "::grpc::ServerContext* /*context*/, "
+        "const $Request$* /*request*/, $Response$* /*response*/) {\n");
     printer->Print(
         "  return ::grpc::Status("
         "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
@@ -1365,12 +1340,9 @@
   } else if (ClientOnlyStreaming(method)) {
     printer->Print(*vars,
                    "::grpc::Status $ns$$Service$::Service::$Method$("
-                   "::grpc::ServerContext* context, "
-                   "::grpc::ServerReader< $Request$>* reader, "
-                   "$Response$* response) {\n");
-    printer->Print("  (void) context;\n");
-    printer->Print("  (void) reader;\n");
-    printer->Print("  (void) response;\n");
+                   "::grpc::ServerContext* /*context*/, "
+                   "::grpc::ServerReader< $Request$>* /*reader*/, "
+                   "$Response$* /*response*/) {\n");
     printer->Print(
         "  return ::grpc::Status("
         "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
@@ -1378,12 +1350,9 @@
   } else if (ServerOnlyStreaming(method)) {
     printer->Print(*vars,
                    "::grpc::Status $ns$$Service$::Service::$Method$("
-                   "::grpc::ServerContext* context, "
-                   "const $Request$* request, "
-                   "::grpc::ServerWriter< $Response$>* writer) {\n");
-    printer->Print("  (void) context;\n");
-    printer->Print("  (void) request;\n");
-    printer->Print("  (void) writer;\n");
+                   "::grpc::ServerContext* /*context*/, "
+                   "const $Request$* /*request*/, "
+                   "::grpc::ServerWriter< $Response$>* /*writer*/) {\n");
     printer->Print(
         "  return ::grpc::Status("
         "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
@@ -1391,11 +1360,9 @@
   } else if (method->BidiStreaming()) {
     printer->Print(*vars,
                    "::grpc::Status $ns$$Service$::Service::$Method$("
-                   "::grpc::ServerContext* context, "
+                   "::grpc::ServerContext* /*context*/, "
                    "::grpc::ServerReaderWriter< $Response$, $Request$>* "
-                   "stream) {\n");
-    printer->Print("  (void) context;\n");
-    printer->Print("  (void) stream;\n");
+                   "/*stream*/) {\n");
     printer->Print(
         "  return ::grpc::Status("
         "::grpc::StatusCode::UNIMPLEMENTED, \"\");\n");
@@ -1421,7 +1388,7 @@
   printer->Print(*vars,
                  "std::unique_ptr< $ns$$Service$::Stub> $ns$$Service$::NewStub("
                  "const std::shared_ptr< ::grpc::ChannelInterface>& channel, "
-                 "const ::grpc::StubOptions& options) {\n"
+                 "const ::grpc::StubOptions& /*options*/) {\n"
                  "  std::unique_ptr< $ns$$Service$::Stub> stub(new "
                  "$ns$$Service$::Stub(channel));\n"
                  "  return stub;\n"
@@ -1530,9 +1497,7 @@
     // Package string is empty or ends with a dot. It is used to fully qualify
     // method names.
     vars["Package"] = file->package();
-    if (!file->package().empty()) {
-      vars["Package"].append(".");
-    }
+    if (!file->package().empty()) { vars["Package"].append("."); }
     if (!params.services_namespace.empty()) {
       vars["ns"] = params.services_namespace + "::";
       vars["prefix"] = params.services_namespace;
@@ -1604,9 +1569,9 @@
     std::map<grpc::string, grpc::string> vars;
 
     static const char *headers_strs[] = {
-        "grpc++/impl/codegen/async_stream.h",
-        "grpc++/impl/codegen/sync_stream.h",
-        "gmock/gmock.h",
+      "grpcpp/impl/codegen/async_stream.h",
+      "grpcpp/impl/codegen/sync_stream.h",
+      "gmock/gmock.h",
     };
     std::vector<grpc::string> headers(headers_strs, array_end(headers_strs));
     PrintIncludes(printer.get(), headers, params);
@@ -1636,15 +1601,17 @@
     grpc::string prefix;
     grpc::string method_params;  // extra arguments to method
     int extra_method_param_count;
-  } async_prefixes[] = {{"Async", ", void* tag", 1}, {"PrepareAsync", "", 0}};
+  } async_prefixes[] = { { "Async", ", void* tag", 1 },
+                         { "PrepareAsync", "", 0 } };
 
   if (method->NoStreaming()) {
     printer->Print(
         *vars,
         "MOCK_METHOD3($Method$, ::grpc::Status(::grpc::ClientContext* context, "
         "const $Request$& request, $Response$* response));\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-      auto& async_prefix = async_prefixes[i];
+    for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+         i++) {
+      auto &async_prefix = async_prefixes[i];
       (*vars)["AsyncPrefix"] = async_prefix.prefix;
       printer->Print(
           *vars,
@@ -1659,12 +1626,13 @@
         "MOCK_METHOD2($Method$Raw, "
         "::grpc::ClientWriterInterface< $Request$>*"
         "(::grpc::ClientContext* context, $Response$* response));\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-      auto& async_prefix = async_prefixes[i];
+    for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+         i++) {
+      auto &async_prefix = async_prefixes[i];
       (*vars)["AsyncPrefix"] = async_prefix.prefix;
       (*vars)["AsyncMethodParams"] = async_prefix.method_params;
       (*vars)["MockArgs"] =
-        flatbuffers::NumToString(3 + async_prefix.extra_method_param_count);
+          flatbuffers::NumToString(3 + async_prefix.extra_method_param_count);
       printer->Print(*vars,
                      "MOCK_METHOD$MockArgs$($AsyncPrefix$$Method$Raw, "
                      "::grpc::ClientAsyncWriterInterface< $Request$>*"
@@ -1677,8 +1645,9 @@
         "MOCK_METHOD2($Method$Raw, "
         "::grpc::ClientReaderInterface< $Response$>*"
         "(::grpc::ClientContext* context, const $Request$& request));\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-      auto& async_prefix = async_prefixes[i];
+    for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+         i++) {
+      auto &async_prefix = async_prefixes[i];
       (*vars)["AsyncPrefix"] = async_prefix.prefix;
       (*vars)["AsyncMethodParams"] = async_prefix.method_params;
       (*vars)["MockArgs"] =
@@ -1696,8 +1665,9 @@
         "MOCK_METHOD1($Method$Raw, "
         "::grpc::ClientReaderWriterInterface< $Request$, $Response$>*"
         "(::grpc::ClientContext* context));\n");
-    for (size_t i = 0; i < sizeof(async_prefixes)/sizeof(async_prefixes[0]); i ++) {
-      auto& async_prefix = async_prefixes[i];
+    for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);
+         i++) {
+      auto &async_prefix = async_prefixes[i];
       (*vars)["AsyncPrefix"] = async_prefix.prefix;
       (*vars)["AsyncMethodParams"] = async_prefix.method_params;
       (*vars)["MockArgs"] =
@@ -1738,9 +1708,7 @@
     // Package string is empty or ends with a dot. It is used to fully qualify
     // method names.
     vars["Package"] = file->package();
-    if (!file->package().empty()) {
-      vars["Package"].append(".");
-    }
+    if (!file->package().empty()) { vars["Package"].append("."); }
 
     if (!params.services_namespace.empty()) {
       vars["services_namespace"] = params.services_namespace;
diff --git a/grpc/src/compiler/cpp_generator.h b/grpc/src/compiler/cpp_generator.h
index 6119ebe..16aa97a 100644
--- a/grpc/src/compiler/cpp_generator.h
+++ b/grpc/src/compiler/cpp_generator.h
@@ -1,36 +1,3 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
 #ifndef GRPC_INTERNAL_COMPILER_CPP_GENERATOR_H
 #define GRPC_INTERNAL_COMPILER_CPP_GENERATOR_H
 
@@ -41,12 +8,11 @@
 #include <memory>
 #include <vector>
 
-#include "src/compiler/config.h"
 #include "src/compiler/schema_interface.h"
 
 #ifndef GRPC_CUSTOM_STRING
-#include <string>
-#define GRPC_CUSTOM_STRING std::string
+#  include <string>
+#  define GRPC_CUSTOM_STRING std::string
 #endif
 
 namespace grpc {
diff --git a/grpc/src/compiler/go_generator.cc b/grpc/src/compiler/go_generator.cc
index 604828d..9ba2e65 100644
--- a/grpc/src/compiler/go_generator.cc
+++ b/grpc/src/compiler/go_generator.cc
@@ -1,47 +1,13 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation AN/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <map>
-#include <cctype>
-#include <sstream>
-
 #include "src/compiler/go_generator.h"
 
-template <class T>
-grpc::string as_string(T x) {
-	std::ostringstream out;
-	out << x;
-	return out.str();
+#include <cctype>
+#include <map>
+#include <sstream>
+
+template<class T> grpc::string as_string(T x) {
+  std::ostringstream out;
+  out << x;
+  return out.str();
 }
 
 inline bool ClientOnlyStreaming(const grpc_generator::Method *method) {
@@ -56,391 +22,484 @@
 
 // Returns string with first letter to lowerCase
 grpc::string unexportName(grpc::string s) {
-	if (s.empty())
-		return s;
-	s[0] = static_cast<char>(std::tolower(s[0]));
-	return s;
+  if (s.empty()) return s;
+  s[0] = static_cast<char>(std::tolower(s[0]));
+  return s;
 }
 
 // Returns string with first letter to uppercase
 grpc::string exportName(grpc::string s) {
-	if (s.empty())
-		return s;
-	s[0] = static_cast<char>(std::toupper(s[0]));
-	return s;
+  if (s.empty()) return s;
+  s[0] = static_cast<char>(std::toupper(s[0]));
+  return s;
+}
+
+void GenerateError(grpc_generator::Printer *printer,
+                   std::map<grpc::string, grpc::string> vars,
+                   const bool multiple_return = true) {
+  printer->Print(vars, "if $Error_Check$ {\n");
+  printer->Indent();
+  vars["Return"] = multiple_return ? "nil, err" : "err";
+  printer->Print(vars, "return $Return$\n");
+  printer->Outdent();
+  printer->Print("}\n");
 }
 
 // Generates imports for the service
-void GenerateImports(grpc_generator::File *file, grpc_generator::Printer *printer,
+void GenerateImports(grpc_generator::File *file,
+                     grpc_generator::Printer *printer,
                      std::map<grpc::string, grpc::string> vars) {
-	vars["filename"] = file->filename();
-	printer->Print("//Generated by gRPC Go plugin\n");
-	printer->Print("//If you make any local changes, they will be lost\n");
-	printer->Print(vars, "//source: $filename$\n\n");
-	printer->Print(vars, "package $Package$\n\n");
-	if (file->additional_headers() != "") {
-		printer->Print(file->additional_headers().c_str());
-		printer->Print("\n\n");
-	}
-	printer->Print("import (\n");
-	printer->Indent();
-	printer->Print(vars, "$context$ \"context\"\n");
-	printer->Print(vars, "$grpc$ \"google.golang.org/grpc\"\n");
-	printer->Outdent();
-	printer->Print(")\n\n");
+  vars["filename"] = file->filename();
+  printer->Print("//Generated by gRPC Go plugin\n");
+  printer->Print("//If you make any local changes, they will be lost\n");
+  printer->Print(vars, "//source: $filename$\n\n");
+  printer->Print(vars, "package $Package$\n\n");
+  printer->Print("import (\n");
+  printer->Indent();
+  printer->Print(vars, "$context$ \"context\"\n");
+  printer->Print("flatbuffers \"github.com/google/flatbuffers/go\"\n");
+  printer->Print(vars, "$grpc$ \"google.golang.org/grpc\"\n");
+  printer->Print("\"google.golang.org/grpc/codes\"\n");
+  printer->Print("\"google.golang.org/grpc/status\"\n");
+  printer->Outdent();
+  printer->Print(")\n\n");
 }
 
 // Generates Server method signature source
-void GenerateServerMethodSignature(const grpc_generator::Method *method, grpc_generator::Printer *printer,
+void GenerateServerMethodSignature(const grpc_generator::Method *method,
+                                   grpc_generator::Printer *printer,
                                    std::map<grpc::string, grpc::string> vars) {
-	vars["Method"] = exportName(method->name());
-	vars["Request"] = method->get_input_type_name();
-	vars["Response"] = (vars["CustomMethodIO"] == "") ? method->get_output_type_name() : vars["CustomMethodIO"];
-	if (method->NoStreaming()) {
-		printer->Print(vars, "$Method$($context$.Context, *$Request$) (*$Response$, error)");
-	} else if (ServerOnlyStreaming(method)) {
-		printer->Print(vars, "$Method$(*$Request$, $Service$_$Method$Server) error");
-	} else {
-		printer->Print(vars, "$Method$($Service$_$Method$Server) error");
-	}
+  vars["Method"] = exportName(method->name());
+  vars["Request"] = method->get_input_type_name();
+  vars["Response"] = (vars["CustomMethodIO"] == "")
+                         ? method->get_output_type_name()
+                         : vars["CustomMethodIO"];
+  if (method->NoStreaming()) {
+    printer->Print(
+        vars,
+        "$Method$($context$.Context, *$Request$) (*$Response$, error)$Ending$");
+  } else if (ServerOnlyStreaming(method)) {
+    printer->Print(
+        vars, "$Method$(*$Request$, $Service$_$Method$Server) error$Ending$");
+  } else {
+    printer->Print(vars, "$Method$($Service$_$Method$Server) error$Ending$");
+  }
 }
 
-void GenerateServerMethod(const grpc_generator::Method *method, grpc_generator::Printer *printer,
+void GenerateServerMethod(const grpc_generator::Method *method,
+                          grpc_generator::Printer *printer,
                           std::map<grpc::string, grpc::string> vars) {
-	vars["Method"] = exportName(method->name());
-	vars["Request"] = method->get_input_type_name();
-	vars["Response"] = (vars["CustomMethodIO"] == "") ? method->get_output_type_name() : vars["CustomMethodIO"];
-	vars["FullMethodName"] = "/" + vars["ServicePrefix"] + "." + vars["Service"] + "/" + vars["Method"];
-	vars["Handler"] = "_" + vars["Service"] + "_" + vars["Method"] + "_Handler";
-	if (method->NoStreaming()) {
-		printer->Print(vars, "func $Handler$(srv interface{}, ctx $context$.Context,\n\tdec func(interface{}) error, interceptor $grpc$.UnaryServerInterceptor) (interface{}, error) {\n");
-		printer->Indent();
-		printer->Print(vars, "in := new($Request$)\n");
-		printer->Print("if err := dec(in); err != nil { return nil, err }\n");
-		printer->Print(vars, "if interceptor == nil { return srv.($Service$Server).$Method$(ctx, in) }\n");
-		printer->Print(vars, "info := &$grpc$.UnaryServerInfo{\n");
-		printer->Indent();
-		printer->Print("Server: srv,\n");
-		printer->Print(vars, "FullMethod: \"$FullMethodName$\",\n");
-		printer->Outdent();
-		printer->Print("}\n\n");
-		printer->Print(vars, "handler := func(ctx $context$.Context, req interface{}) (interface{}, error) {\n");
-		printer->Indent();
-		printer->Print(vars, "return srv.($Service$Server).$Method$(ctx, req.(* $Request$))\n");
-		printer->Outdent();
-		printer->Print("}\n");
-		printer->Print("return interceptor(ctx, in, info, handler)\n");
-		printer->Outdent();
-		printer->Print("}\n\n");
-		return;
-	}
-	vars["StreamType"] = vars["ServiceUnexported"] + vars["Method"] + "Server";
-	printer->Print(vars, "func $Handler$(srv interface{}, stream $grpc$.ServerStream) error {\n");
-	printer->Indent();
-	if (ServerOnlyStreaming(method)) {
-		printer->Print(vars, "m := new($Request$)\n");
-		printer->Print(vars, "if err := stream.RecvMsg(m); err != nil { return err }\n");
-		printer->Print(vars, "return srv.($Service$Server).$Method$(m, &$StreamType${stream})\n");
-	} else {
-		printer->Print(vars, "return srv.($Service$Server).$Method$(&$StreamType${stream})\n");
-	}
-	printer->Outdent();
-	printer->Print("}\n\n");
+  vars["Method"] = exportName(method->name());
+  vars["Request"] = method->get_input_type_name();
+  vars["Response"] = (vars["CustomMethodIO"] == "")
+                         ? method->get_output_type_name()
+                         : vars["CustomMethodIO"];
+  vars["FullMethodName"] =
+      "/" + vars["ServicePrefix"] + vars["Service"] + "/" + vars["Method"];
+  vars["Handler"] = "_" + vars["Service"] + "_" + vars["Method"] + "_Handler";
+  if (method->NoStreaming()) {
+    printer->Print(
+        vars,
+        "func $Handler$(srv interface{}, ctx $context$.Context,\n\tdec "
+        "func(interface{}) error, interceptor $grpc$.UnaryServerInterceptor) "
+        "(interface{}, error) {\n");
+    printer->Indent();
+    printer->Print(vars, "in := new($Request$)\n");
+    vars["Error_Check"] = "err := dec(in); err != nil";
+    GenerateError(printer, vars);
+    printer->Print("if interceptor == nil {\n");
+    printer->Indent();
+    printer->Print(vars, "return srv.($Service$Server).$Method$(ctx, in)\n");
+    printer->Outdent();
+    printer->Print("}\n");
+    printer->Print(vars, "info := &$grpc$.UnaryServerInfo{\n");
+    printer->Indent();
+    printer->Print("Server:     srv,\n");
+    printer->Print(vars, "FullMethod: \"$FullMethodName$\",\n");
+    printer->Outdent();
+    printer->Print("}\n");
+    printer->Outdent();
+    printer->Print("\n");
+    printer->Indent();
+    printer->Print(vars,
+                   "handler := func(ctx $context$.Context, req interface{}) "
+                   "(interface{}, error) {\n");
+    printer->Indent();
+    printer->Print(
+        vars, "return srv.($Service$Server).$Method$(ctx, req.(*$Request$))\n");
+    printer->Outdent();
+    printer->Print("}\n");
+    printer->Print("return interceptor(ctx, in, info, handler)\n");
+    printer->Outdent();
+    printer->Print("}\n");
+    return;
+  }
+  vars["StreamType"] = vars["ServiceUnexported"] + vars["Method"] + "Server";
+  printer->Print(
+      vars,
+      "func $Handler$(srv interface{}, stream $grpc$.ServerStream) error {\n");
+  printer->Indent();
+  if (ServerOnlyStreaming(method)) {
+    printer->Print(vars, "m := new($Request$)\n");
+    vars["Error_Check"] = "err := stream.RecvMsg(m); err != nil";
+    GenerateError(printer, vars, false);
+    printer->Print(
+        vars,
+        "return srv.($Service$Server).$Method$(m, &$StreamType${stream})\n");
+  } else {
+    printer->Print(
+        vars, "return srv.($Service$Server).$Method$(&$StreamType${stream})\n");
+  }
+  printer->Outdent();
+  printer->Print("}\n\n");
 
-	bool genSend = method->BidiStreaming() || ServerOnlyStreaming(method);
-	bool genRecv = method->BidiStreaming() || ClientOnlyStreaming(method);
-	bool genSendAndClose = ClientOnlyStreaming(method);
+  bool genSend = method->BidiStreaming() || ServerOnlyStreaming(method);
+  bool genRecv = method->BidiStreaming() || ClientOnlyStreaming(method);
+  bool genSendAndClose = ClientOnlyStreaming(method);
 
-	printer->Print(vars, "type $Service$_$Method$Server interface { \n");
-	printer->Indent();
-	if (genSend) {
-		printer->Print(vars, "Send(* $Response$) error\n");
-	}
-	if (genRecv) {
-		printer->Print(vars, "Recv() (* $Request$, error)\n");
-	}
-	if (genSendAndClose) {
-		printer->Print(vars, "SendAndClose(* $Response$) error\n");
-	}
-	printer->Print(vars, "$grpc$.ServerStream\n");
-	printer->Outdent();
-	printer->Print("}\n\n");
+  printer->Print(vars, "type $Service$_$Method$Server interface {\n");
+  printer->Indent();
+  if (genSend) { printer->Print(vars, "Send(*$Response$) error\n"); }
+  if (genRecv) { printer->Print(vars, "Recv() (*$Request$, error)\n"); }
+  if (genSendAndClose) {
+    printer->Print(vars, "SendAndClose(*$Response$) error\n");
+  }
+  printer->Print(vars, "$grpc$.ServerStream\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
 
-	printer->Print(vars, "type $StreamType$ struct {\n");
-	printer->Indent();
-	printer->Print(vars, "$grpc$.ServerStream\n");
-	printer->Outdent();
-	printer->Print("}\n\n");
+  printer->Print(vars, "type $StreamType$ struct {\n");
+  printer->Indent();
+  printer->Print(vars, "$grpc$.ServerStream\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
 
-	if (genSend) {
-		printer->Print(vars, "func (x *$StreamType$) Send(m *$Response$) error {\n");
-		printer->Indent();
-		printer->Print("return x.ServerStream.SendMsg(m)\n");
-		printer->Outdent();
-		printer->Print("}\n\n");
-	}
-	if (genRecv) {
-		printer->Print(vars, "func (x *$StreamType$) Recv() (*$Request$, error) {\n");
-		printer->Indent();
-		printer->Print(vars, "m := new($Request$)\n");
-		printer->Print("if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err }\n");
-		printer->Print("return m, nil\n");
-		printer->Outdent();
-		printer->Print("}\n\n");
-	}
-	if (genSendAndClose) {
-		printer->Print(vars, "func (x *$StreamType$) SendAndClose(m *$Response$) error {\n");
-		printer->Indent();
-		printer->Print("return x.ServerStream.SendMsg(m)\n");
-		printer->Outdent();
-		printer->Print("}\n\n");
-	}
-
+  if (genSend) {
+    printer->Print(vars,
+                   "func (x *$StreamType$) Send(m *$Response$) error {\n");
+    printer->Indent();
+    printer->Print("return x.ServerStream.SendMsg(m)\n");
+    printer->Outdent();
+    printer->Print("}\n\n");
+  }
+  if (genRecv) {
+    printer->Print(vars,
+                   "func (x *$StreamType$) Recv() (*$Request$, error) {\n");
+    printer->Indent();
+    printer->Print(vars, "m := new($Request$)\n");
+    vars["Error_Check"] = "err := x.ServerStream.RecvMsg(m); err != nil";
+    GenerateError(printer, vars);
+    printer->Print("return m, nil\n");
+    printer->Outdent();
+    printer->Print("}\n\n");
+  }
+  if (genSendAndClose) {
+    printer->Print(
+        vars, "func (x *$StreamType$) SendAndClose(m *$Response$) error {\n");
+    printer->Indent();
+    printer->Print("return x.ServerStream.SendMsg(m)\n");
+    printer->Outdent();
+    printer->Print("}\n\n");
+  }
 }
 
 // Generates Client method signature source
-void GenerateClientMethodSignature(const grpc_generator::Method *method, grpc_generator::Printer *printer,
+void GenerateClientMethodSignature(const grpc_generator::Method *method,
+                                   grpc_generator::Printer *printer,
                                    std::map<grpc::string, grpc::string> vars) {
-	vars["Method"] = exportName(method->name());
-	vars["Request"] = ", in *" + ((vars["CustomMethodIO"] == "") ? method->get_input_type_name() : vars["CustomMethodIO"]);
-	if (ClientOnlyStreaming(method) || method->BidiStreaming()) {
-		vars["Request"] = "";
-	}
-	vars["Response"] = "* " + method->get_output_type_name();
-	if (ClientOnlyStreaming(method) || method->BidiStreaming() || ServerOnlyStreaming(method)) {
-		vars["Response"] = vars["Service"] + "_" + vars["Method"] + "Client" ;
-	}
-	printer->Print(vars, "$Method$(ctx $context$.Context$Request$, \n\topts... $grpc$.CallOption) ($Response$, error)");
+  vars["Method"] = exportName(method->name());
+  vars["Request"] =
+      ", in *" + ((vars["CustomMethodIO"] == "") ? method->get_input_type_name()
+                                                 : vars["CustomMethodIO"]);
+  if (ClientOnlyStreaming(method) || method->BidiStreaming()) {
+    vars["Request"] = "";
+  }
+  vars["Response"] = "*" + method->get_output_type_name();
+  if (ClientOnlyStreaming(method) || method->BidiStreaming() ||
+      ServerOnlyStreaming(method)) {
+    vars["Response"] = vars["Service"] + "_" + vars["Method"] + "Client";
+  }
+  printer->Print(vars,
+                 "$Method$(ctx $context$.Context$Request$,\n\topts "
+                 "...$grpc$.CallOption) ($Response$, error)$Ending$");
 }
 
 // Generates Client method source
-void GenerateClientMethod(const grpc_generator::Method *method, grpc_generator::Printer *printer,
+void GenerateClientMethod(const grpc_generator::Method *method,
+                          grpc_generator::Printer *printer,
                           std::map<grpc::string, grpc::string> vars) {
-	printer->Print(vars, "func (c *$ServiceUnexported$Client) ");
-	GenerateClientMethodSignature(method, printer, vars);
-	printer->Print(" {\n");
-	printer->Indent();
-	vars["Method"] = exportName(method->name());
-	vars["Request"] = (vars["CustomMethodIO"] == "") ? method->get_input_type_name() : vars["CustomMethodIO"];
-	vars["Response"] = method->get_output_type_name();
-	vars["FullMethodName"] = "/" + vars["ServicePrefix"] + "." + vars["Service"] + "/" + vars["Method"];
-	if (method->NoStreaming()) {
-		printer->Print(vars, "out := new($Response$)\n");
-		printer->Print(vars, "err := $grpc$.Invoke(ctx, \"$FullMethodName$\", in, out, c.cc, opts...)\n");
-		printer->Print("if err != nil { return nil, err }\n");
-		printer->Print("return out, nil\n");
-		printer->Outdent();
-		printer->Print("}\n\n");
-		return;
-	}
-	vars["StreamType"] = vars["ServiceUnexported"] + vars["Method"] + "Client";
-	printer->Print(vars, "stream, err := $grpc$.NewClientStream(ctx, &$MethodDesc$, c.cc, \"$FullMethodName$\", opts...)\n");
-	printer->Print("if err != nil { return nil, err }\n");
+  printer->Print(vars, "func (c *$ServiceUnexported$Client) ");
+  vars["Ending"] = " {\n";
+  GenerateClientMethodSignature(method, printer, vars);
+  printer->Indent();
+  vars["Method"] = exportName(method->name());
+  vars["Request"] = (vars["CustomMethodIO"] == "")
+                        ? method->get_input_type_name()
+                        : vars["CustomMethodIO"];
+  vars["Response"] = method->get_output_type_name();
+  vars["FullMethodName"] =
+      "/" + vars["ServicePrefix"] + vars["Service"] + "/" + vars["Method"];
+  if (method->NoStreaming()) {
+    printer->Print(vars, "out := new($Response$)\n");
+    printer->Print(
+        vars,
+        "err := c.cc.Invoke(ctx, \"$FullMethodName$\", in, out, opts...)\n");
+    vars["Error_Check"] = "err != nil";
+    GenerateError(printer, vars);
+    printer->Print("return out, nil\n");
+    printer->Outdent();
+    printer->Print("}\n\n");
+    return;
+  }
+  vars["StreamType"] = vars["ServiceUnexported"] + vars["Method"] + "Client";
+  printer->Print(vars,
+                 "stream, err := c.cc.NewStream(ctx, &$MethodDesc$, "
+                 "\"$FullMethodName$\", opts...)\n");
+  vars["Error_Check"] = "err != nil";
+  GenerateError(printer, vars);
 
-	printer->Print(vars, "x := &$StreamType${stream}\n");
-	if (ServerOnlyStreaming(method)) {
-		printer->Print("if err := x.ClientStream.SendMsg(in); err != nil { return nil, err }\n");
-		printer->Print("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }\n");
-	}
-	printer->Print("return x,nil\n");
-	printer->Outdent();
-	printer->Print("}\n\n");
+  printer->Print(vars, "x := &$StreamType${stream}\n");
+  if (ServerOnlyStreaming(method)) {
+    vars["Error_Check"] = "err := x.ClientStream.SendMsg(in); err != nil";
+    GenerateError(printer, vars);
+    vars["Error_Check"] = "err := x.ClientStream.CloseSend(); err != nil";
+    GenerateError(printer, vars);
+  }
+  printer->Print("return x, nil\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
 
-	bool genSend = method->BidiStreaming() || ClientOnlyStreaming(method);
-	bool genRecv = method->BidiStreaming() || ServerOnlyStreaming(method);
-	bool genCloseAndRecv = ClientOnlyStreaming(method);
+  bool genSend = method->BidiStreaming() || ClientOnlyStreaming(method);
+  bool genRecv = method->BidiStreaming() || ServerOnlyStreaming(method);
+  bool genCloseAndRecv = ClientOnlyStreaming(method);
 
-	//Stream interface
-	printer->Print(vars, "type $Service$_$Method$Client interface {\n");
-	printer->Indent();
-	if (genSend) {
-		printer->Print(vars, "Send(*$Request$) error\n");
-	}
-	if (genRecv) {
-		printer->Print(vars, "Recv() (*$Response$, error)\n");
-	}
-	if (genCloseAndRecv) {
-		printer->Print(vars, "CloseAndRecv() (*$Response$, error)\n");
-	}
-	printer->Print(vars, "$grpc$.ClientStream\n");
-	printer->Outdent();
-	printer->Print("}\n\n");
+  // Stream interface
+  printer->Print(vars, "type $Service$_$Method$Client interface {\n");
+  printer->Indent();
+  if (genSend) { printer->Print(vars, "Send(*$Request$) error\n"); }
+  if (genRecv) { printer->Print(vars, "Recv() (*$Response$, error)\n"); }
+  if (genCloseAndRecv) {
+    printer->Print(vars, "CloseAndRecv() (*$Response$, error)\n");
+  }
+  printer->Print(vars, "$grpc$.ClientStream\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
 
-	//Stream Client
-	printer->Print(vars, "type $StreamType$ struct{\n");
-	printer->Indent();
-	printer->Print(vars, "$grpc$.ClientStream\n");
-	printer->Outdent();
-	printer->Print("}\n\n");
+  // Stream Client
+  printer->Print(vars, "type $StreamType$ struct {\n");
+  printer->Indent();
+  printer->Print(vars, "$grpc$.ClientStream\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
 
-	if (genSend) {
-		printer->Print(vars, "func (x *$StreamType$) Send(m *$Request$) error {\n");
-		printer->Indent();
-		printer->Print("return x.ClientStream.SendMsg(m)\n");
-		printer->Outdent();
-		printer->Print("}\n\n");
-	}
+  if (genSend) {
+    printer->Print(vars, "func (x *$StreamType$) Send(m *$Request$) error {\n");
+    printer->Indent();
+    printer->Print("return x.ClientStream.SendMsg(m)\n");
+    printer->Outdent();
+    printer->Print("}\n\n");
+  }
 
-	if (genRecv) {
-		printer->Print(vars, "func (x *$StreamType$) Recv() (*$Response$, error) {\n");
-		printer->Indent();
-		printer->Print(vars, "m := new($Response$)\n");
-		printer->Print("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }\n");
-		printer->Print("return m, nil\n");
-		printer->Outdent();
-		printer->Print("}\n\n");
-	}
+  if (genRecv) {
+    printer->Print(vars,
+                   "func (x *$StreamType$) Recv() (*$Response$, error) {\n");
+    printer->Indent();
+    printer->Print(vars, "m := new($Response$)\n");
+    vars["Error_Check"] = "err := x.ClientStream.RecvMsg(m); err != nil";
+    GenerateError(printer, vars);
+    printer->Print("return m, nil\n");
+    printer->Outdent();
+    printer->Print("}\n\n");
+  }
 
-	if (genCloseAndRecv) {
-		printer->Print(vars, "func (x *$StreamType$) CloseAndRecv() (*$Response$, error) {\n");
-		printer->Indent();
-		printer->Print("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }\n");
-		printer->Print(vars, "m := new ($Response$)\n");
-		printer->Print("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }\n");
-		printer->Print("return m, nil\n");
-		printer->Outdent();
-		printer->Print("}\n\n");
-	}
+  if (genCloseAndRecv) {
+    printer->Print(
+        vars, "func (x *$StreamType$) CloseAndRecv() (*$Response$, error) {\n");
+    printer->Indent();
+    vars["Error_Check"] = "err := x.ClientStream.CloseSend(); err != nil";
+    GenerateError(printer, vars);
+    printer->Print(vars, "m := new($Response$)\n");
+    vars["Error_Check"] = "err := x.ClientStream.RecvMsg(m); err != nil";
+    GenerateError(printer, vars);
+    printer->Print("return m, nil\n");
+    printer->Outdent();
+    printer->Print("}\n\n");
+  }
 }
 
 // Generates client API for the service
-void GenerateService(const grpc_generator::Service *service, grpc_generator::Printer* printer,
+void GenerateService(const grpc_generator::Service *service,
+                     grpc_generator::Printer *printer,
                      std::map<grpc::string, grpc::string> vars) {
-	vars["Service"] = exportName(service->name());
-	// Client Interface
-	printer->Print(vars, "// Client API for $Service$ service\n");
-	printer->Print(vars, "type $Service$Client interface{\n");
-	printer->Indent();
-	for (int i = 0; i < service->method_count(); i++) {
-		GenerateClientMethodSignature(service->method(i).get(), printer, vars);
-		printer->Print("\n");
-	}
-	printer->Outdent();
-	printer->Print("}\n\n");
+  vars["Service"] = exportName(service->name());
+  // Client Interface
+  printer->Print(vars, "// Client API for $Service$ service\n");
+  printer->Print(vars, "type $Service$Client interface {\n");
+  printer->Indent();
+  vars["Ending"] = "\n";
+  for (int i = 0; i < service->method_count(); i++) {
+    GenerateClientMethodSignature(service->method(i).get(), printer, vars);
+  }
+  printer->Outdent();
+  printer->Print("}\n\n");
 
-	// Client structure
-	vars["ServiceUnexported"] = unexportName(vars["Service"]);
-	printer->Print(vars, "type $ServiceUnexported$Client struct {\n");
-	printer->Indent();
-	printer->Print(vars, "cc *$grpc$.ClientConn\n");
-	printer->Outdent();
-	printer->Print("}\n\n");
+  // Client structure
+  vars["ServiceUnexported"] = unexportName(vars["Service"]);
+  printer->Print(vars, "type $ServiceUnexported$Client struct {\n");
+  printer->Indent();
+  printer->Print(vars, "cc $grpc$.ClientConnInterface\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
 
-	// NewClient
-	printer->Print(vars, "func New$Service$Client(cc *$grpc$.ClientConn) $Service$Client {\n");
-	printer->Indent();
-	printer->Print(vars, "return &$ServiceUnexported$Client{cc}");
-	printer->Outdent();
-	printer->Print("\n}\n\n");
+  // NewClient
+  printer->Print(vars,
+                 "func New$Service$Client(cc $grpc$.ClientConnInterface) "
+                 "$Service$Client {\n");
+  printer->Indent();
+  printer->Print(vars, "return &$ServiceUnexported$Client{cc}");
+  printer->Outdent();
+  printer->Print("\n}\n\n");
 
-	int unary_methods = 0, streaming_methods = 0;
-	vars["ServiceDesc"] = "_" + vars["Service"] + "_serviceDesc";
-	for (int i = 0; i < service->method_count(); i++) {
-		auto method = service->method(i);
-		if (method->NoStreaming()) {
-			vars["MethodDesc"] = vars["ServiceDesc"] + ".Method[" + as_string(unary_methods) + "]";
-			unary_methods++;
-		} else {
-			vars["MethodDesc"] = vars["ServiceDesc"] + ".Streams[" + as_string(streaming_methods) + "]";
-			streaming_methods++;
-		}
-		GenerateClientMethod(method.get(), printer, vars);
-	}
+  int unary_methods = 0, streaming_methods = 0;
+  vars["ServiceDesc"] = "_" + vars["Service"] + "_serviceDesc";
+  for (int i = 0; i < service->method_count(); i++) {
+    auto method = service->method(i);
+    if (method->NoStreaming()) {
+      vars["MethodDesc"] =
+          vars["ServiceDesc"] + ".Method[" + as_string(unary_methods) + "]";
+      unary_methods++;
+    } else {
+      vars["MethodDesc"] = vars["ServiceDesc"] + ".Streams[" +
+                           as_string(streaming_methods) + "]";
+      streaming_methods++;
+    }
+    GenerateClientMethod(method.get(), printer, vars);
+  }
 
-	//Server Interface
-	printer->Print(vars, "// Server API for $Service$ service\n");
-	printer->Print(vars, "type $Service$Server interface {\n");
-	printer->Indent();
-	for (int i = 0; i < service->method_count(); i++) {
-		GenerateServerMethodSignature(service->method(i).get(), printer, vars);
-		printer->Print("\n");
-	}
-	printer->Outdent();
-	printer->Print("}\n\n");
+  // Server Interface
+  printer->Print(vars, "// Server API for $Service$ service\n");
+  printer->Print(vars, "type $Service$Server interface {\n");
+  printer->Indent();
+  vars["Ending"] = "\n";
+  for (int i = 0; i < service->method_count(); i++) {
+    GenerateServerMethodSignature(service->method(i).get(), printer, vars);
+  }
+  printer->Print(vars, "mustEmbedUnimplemented$Service$Server()\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
 
-	// Server registration.
-	printer->Print(vars, "func Register$Service$Server(s *$grpc$.Server, srv $Service$Server) {\n");
-	printer->Indent();
-	printer->Print(vars, "s.RegisterService(&$ServiceDesc$, srv)\n");
-	printer->Outdent();
-	printer->Print("}\n\n");
+  printer->Print(vars, "type Unimplemented$Service$Server struct {\n");
+  printer->Print("}\n\n");
 
-	for (int i = 0; i < service->method_count(); i++) {
-		GenerateServerMethod(service->method(i).get(), printer, vars);
-		printer->Print("\n");
-	}
+  vars["Ending"] = " {\n";
+  for (int i = 0; i < service->method_count(); i++) {
+    auto method = service->method(i);
+    vars["Method"] = exportName(method->name());
+    vars["Nil"] = method->NoStreaming() ? "nil, " : "";
+    printer->Print(vars, "func (Unimplemented$Service$Server) ");
+    GenerateServerMethodSignature(method.get(), printer, vars);
+    printer->Indent();
+    printer->Print(vars,
+                   "return $Nil$status.Errorf(codes.Unimplemented, \"method "
+                   "$Method$ not implemented\")\n");
+    printer->Outdent();
+    printer->Print("}\n");
+    printer->Print("\n");
+  }
 
+  printer->Print(vars,
+                 "func (Unimplemented$Service$Server) "
+                 "mustEmbedUnimplemented$Service$Server() {}");
+  printer->Print("\n\n");
 
-	//Service Descriptor
-	printer->Print(vars, "var $ServiceDesc$ = $grpc$.ServiceDesc{\n");
-	printer->Indent();
-	printer->Print(vars, "ServiceName: \"$ServicePrefix$.$Service$\",\n");
-	printer->Print(vars, "HandlerType: (*$Service$Server)(nil),\n");
-	printer->Print(vars, "Methods: []$grpc$.MethodDesc{\n");
-	printer->Indent();
-	for (int i = 0; i < service->method_count(); i++) {
-		auto method = service->method(i);
-		vars["Method"] = method->name();
-		vars["Handler"] = "_" + vars["Service"] + "_" + vars["Method"] + "_Handler";
-		if (method->NoStreaming()) {
-			printer->Print("{\n");
-			printer->Indent();
-			printer->Print(vars, "MethodName: \"$Method$\",\n");
-			printer->Print(vars, "Handler: $Handler$, \n");
-			printer->Outdent();
-			printer->Print("},\n");
-		}
-	}
-	printer->Outdent();
-	printer->Print("},\n");
-	printer->Print(vars, "Streams: []$grpc$.StreamDesc{\n");
-	printer->Indent();
-	for (int i = 0; i < service->method_count(); i++) {
-		auto method = service->method(i);
-		vars["Method"] = method->name();
-		vars["Handler"] = "_" + vars["Service"] + "_" + vars["Method"] + "_Handler";
-		if (!method->NoStreaming()) {
-			printer->Print("{\n");
-			printer->Indent();
-			printer->Print(vars, "StreamName: \"$Method$\",\n");
-			printer->Print(vars, "Handler: $Handler$, \n");
-			if (ClientOnlyStreaming(method.get())) {
-				printer->Print("ClientStreams: true,\n");
-			} else if (ServerOnlyStreaming(method.get())) {
-				printer->Print("ServerStreams: true,\n");
-			} else {
-				printer->Print("ServerStreams: true,\n");
-				printer->Print("ClientStreams: true,\n");
-			}
-			printer->Outdent();
-			printer->Print("},\n");
-		}
-	}
-	printer->Outdent();
-	printer->Print("},\n");
-	printer->Outdent();
-	printer->Print("}\n\n");
+  printer->Print(vars, "type Unsafe$Service$Server interface {\n");
+  printer->Indent();
+  printer->Print(vars, "mustEmbedUnimplemented$Service$Server()\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
+  // Server registration.
+  printer->Print(vars,
+                 "func Register$Service$Server(s $grpc$.ServiceRegistrar, srv "
+                 "$Service$Server) {\n");
+  printer->Indent();
+  printer->Print(vars, "s.RegisterService(&$ServiceDesc$, srv)\n");
+  printer->Outdent();
+  printer->Print("}\n\n");
 
+  for (int i = 0; i < service->method_count(); i++) {
+    GenerateServerMethod(service->method(i).get(), printer, vars);
+  }
+
+  // Service Descriptor
+  printer->Print(vars, "var $ServiceDesc$ = $grpc$.ServiceDesc{\n");
+  printer->Indent();
+  printer->Print(vars, "ServiceName: \"$ServicePrefix$$Service$\",\n");
+  printer->Print(vars, "HandlerType: (*$Service$Server)(nil),\n");
+  printer->Print(vars, "Methods: []$grpc$.MethodDesc{\n");
+  printer->Indent();
+  for (int i = 0; i < service->method_count(); i++) {
+    auto method = service->method(i);
+    vars["Method"] = exportName(method->name());
+    vars["Handler"] = "_" + vars["Service"] + "_" + vars["Method"] + "_Handler";
+    if (method->NoStreaming()) {
+      printer->Print("{\n");
+      printer->Indent();
+      printer->Print(vars, "MethodName: \"$Method$\",\n");
+      printer->Print(vars, "Handler:    $Handler$,\n");
+      printer->Outdent();
+      printer->Print("},\n");
+    }
+  }
+  printer->Outdent();
+  printer->Print("},\n");
+  printer->Print(vars, "Streams: []$grpc$.StreamDesc{\n");
+  printer->Indent();
+  for (int i = 0; i < service->method_count(); i++) {
+    auto method = service->method(i);
+    vars["Method"] = exportName(method->name());
+    vars["Handler"] = "_" + vars["Service"] + "_" + vars["Method"] + "_Handler";
+    if (!method->NoStreaming()) {
+      printer->Print("{\n");
+      printer->Indent();
+      printer->Print(vars, "StreamName:    \"$Method$\",\n");
+      printer->Print(vars, "Handler:       $Handler$,\n");
+      if (ClientOnlyStreaming(method.get())) {
+        printer->Print("ClientStreams: true,\n");
+      } else if (ServerOnlyStreaming(method.get())) {
+        printer->Print("ServerStreams: true,\n");
+      } else {
+        printer->Print("ServerStreams: true,\n");
+        printer->Print("ClientStreams: true,\n");
+      }
+      printer->Outdent();
+      printer->Print("},\n");
+    }
+  }
+  printer->Outdent();
+  printer->Print("},\n");
+  printer->Outdent();
+  printer->Print("}\n");
 }
 
-
 // Returns source for the service
 grpc::string GenerateServiceSource(grpc_generator::File *file,
                                    const grpc_generator::Service *service,
                                    grpc_go_generator::Parameters *parameters) {
-	grpc::string out;
-	auto p = file->CreatePrinter(&out);
-	auto printer = p.get();
-	std::map<grpc::string, grpc::string> vars;
-	vars["Package"] = parameters->package_name;
-	vars["ServicePrefix"] = parameters->service_prefix;
-	vars["grpc"] = "grpc";
-	vars["context"] = "context";
-	GenerateImports(file, printer, vars);
-	if (parameters->custom_method_io_type != "") {
-		vars["CustomMethodIO"] = parameters->custom_method_io_type;
-	}
-	GenerateService(service, printer, vars);
-	return out;
+  grpc::string out;
+  auto p = file->CreatePrinter(&out, '\t');
+  p->SetIndentationSize(1);
+  auto printer = p.get();
+  std::map<grpc::string, grpc::string> vars;
+  vars["Package"] = parameters->package_name;
+  vars["ServicePrefix"] = parameters->service_prefix;
+  if (!parameters->service_prefix.empty()) vars["ServicePrefix"].append(".");
+  vars["grpc"] = "grpc";
+  vars["context"] = "context";
+  GenerateImports(file, printer, vars);
+  if (parameters->custom_method_io_type != "") {
+    vars["CustomMethodIO"] = parameters->custom_method_io_type;
+  }
+  GenerateService(service, printer, vars);
+  return out;
 }
-}// Namespace grpc_go_generator
+}  // Namespace grpc_go_generator
diff --git a/grpc/src/compiler/go_generator.h b/grpc/src/compiler/go_generator.h
index baa94e0..766e100 100644
--- a/grpc/src/compiler/go_generator.h
+++ b/grpc/src/compiler/go_generator.h
@@ -1,40 +1,8 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
 #ifndef GRPC_INTERNAL_COMPILER_GO_GENERATOR_H
 #define GRPC_INTERNAL_COMPILER_GO_GENERATOR_H
 
-//go generator is used to generate GRPC code for serialization system, such as flatbuffers
+// go generator is used to generate GRPC code for serialization system, such as
+// flatbuffers
 #include <memory>
 #include <vector>
 
@@ -43,14 +11,15 @@
 namespace grpc_go_generator {
 
 struct Parameters {
-  //Defines the custom parameter types for methods
-  //eg: flatbuffers uses flatbuffers.Builder as input for the client and output for the server
+  // Defines the custom parameter types for methods
+  // eg: flatbuffers uses flatbuffers.Builder as input for the client and output
+  // for the server
   grpc::string custom_method_io_type;
 
-  //Package name for the service
+  // Package name for the service
   grpc::string package_name;
 
-  //Prefix for RPC Calls
+  // Prefix for RPC Calls
   grpc::string service_prefix;
 };
 
@@ -59,6 +28,6 @@
                                    const grpc_generator::Service *service,
                                    grpc_go_generator::Parameters *parameters);
 
-}
+}  // namespace grpc_go_generator
 
 #endif  // GRPC_INTERNAL_COMPILER_GO_GENERATOR_H
diff --git a/grpc/src/compiler/java_generator.cc b/grpc/src/compiler/java_generator.cc
index d2cf5cc..98f8788 100644
--- a/grpc/src/compiler/java_generator.cc
+++ b/grpc/src/compiler/java_generator.cc
@@ -23,21 +23,18 @@
 #include <utility>
 #include <vector>
 
-// just to get flatbuffer_version_string()
-#include <flatbuffers/flatbuffers.h>
-#include <flatbuffers/util.h>
+#include "flatbuffers/util.h"
 #define to_string flatbuffers::NumToString
 
 // Stringify helpers used solely to cast GRPC_VERSION
 #ifndef STR
-#define STR(s) #s
+#  define STR(s) #  s
 #endif
 
 #ifndef XSTR
-#define XSTR(s) STR(s)
+#  define XSTR(s) STR(s)
 #endif
 
-
 typedef grpc_generator::Printer Printer;
 typedef std::map<grpc::string, grpc::string> VARS;
 typedef grpc_generator::Service ServiceDescriptor;
@@ -48,12 +45,11 @@
 namespace grpc_java_generator {
 typedef std::string string;
 // Generates imports for the service
-void GenerateImports(grpc_generator::File* file,
-                     grpc_generator::Printer* printer, VARS& vars) {
+void GenerateImports(grpc_generator::File *file,
+                     grpc_generator::Printer *printer, VARS &vars) {
   vars["filename"] = file->filename();
-  printer->Print(
-      vars,
-      "//Generated by flatc compiler (version $flatc_version$)\n");
+  printer->Print(vars,
+                 "//Generated by flatc compiler (version $flatc_version$)\n");
   printer->Print("//If you make any local changes, they will be lost\n");
   printer->Print(vars, "//source: $filename$.fbs\n\n");
   printer->Print(vars, "package $Package$;\n\n");
@@ -67,7 +63,7 @@
 // Adjust a method name prefix identifier to follow the JavaBean spec:
 //   - decapitalize the first letter
 //   - remove embedded underscores & capitalize the following letter
-static string MixedLower(const string& word) {
+static string MixedLower(const string &word) {
   string w;
   w += static_cast<string::value_type>(tolower(word[0]));
   bool after_underscore = false;
@@ -87,7 +83,7 @@
 //   - An underscore is inserted where a lower case letter is followed by an
 //     upper case letter.
 //   - All letters are converted to upper case
-static string ToAllUpperCase(const string& word) {
+static string ToAllUpperCase(const string &word) {
   string w;
   for (size_t i = 0; i < word.length(); ++i) {
     w += static_cast<string::value_type>(toupper(word[i]));
@@ -98,47 +94,47 @@
   return w;
 }
 
-static inline string LowerMethodName(const MethodDescriptor* method) {
+static inline string LowerMethodName(const MethodDescriptor *method) {
   return MixedLower(method->name());
 }
 
-static inline string MethodPropertiesFieldName(const MethodDescriptor* method) {
+static inline string MethodPropertiesFieldName(const MethodDescriptor *method) {
   return "METHOD_" + ToAllUpperCase(method->name());
 }
 
 static inline string MethodPropertiesGetterName(
-    const MethodDescriptor* method) {
+    const MethodDescriptor *method) {
   return MixedLower("get_" + method->name() + "_method");
 }
 
-static inline string MethodIdFieldName(const MethodDescriptor* method) {
+static inline string MethodIdFieldName(const MethodDescriptor *method) {
   return "METHODID_" + ToAllUpperCase(method->name());
 }
 
-static inline string JavaClassName(VARS& vars, const string& name) {
+static inline string JavaClassName(VARS &vars, const string &name) {
   // string name = google::protobuf::compiler::java::ClassName(desc);
   return vars["Package"] + name;
 }
 
-static inline string ServiceClassName(const string& service_name) {
+static inline string ServiceClassName(const string &service_name) {
   return service_name + "Grpc";
 }
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in
 // distribution.
-template <typename ITR>
-static void GrpcSplitStringToIteratorUsing(const string& full,
-                                           const char* delim, ITR& result) {
+template<typename ITR>
+static void GrpcSplitStringToIteratorUsing(const string &full,
+                                           const char *delim, ITR &result) {
   // Optimize the common case where delim is a single character.
   if (delim[0] != '\0' && delim[1] == '\0') {
     char c = delim[0];
-    const char* p = full.data();
-    const char* end = p + full.size();
+    const char *p = full.data();
+    const char *end = p + full.size();
     while (p != end) {
       if (*p == c) {
         ++p;
       } else {
-        const char* start = p;
+        const char *start = p;
         while (++p != end && *p != c)
           ;
         *result++ = string(start, p - start);
@@ -160,13 +156,13 @@
   }
 }
 
-static void GrpcSplitStringUsing(const string& full, const char* delim,
-                                 std::vector<string>* result) {
+static void GrpcSplitStringUsing(const string &full, const char *delim,
+                                 std::vector<string> *result) {
   std::back_insert_iterator<std::vector<string>> it(*result);
   GrpcSplitStringToIteratorUsing(full, delim, it);
 }
 
-static std::vector<string> GrpcSplit(const string& full, const char* delim) {
+static std::vector<string> GrpcSplit(const string &full, const char *delim) {
   std::vector<string> result;
   GrpcSplitStringUsing(full, delim, &result);
   return result;
@@ -174,7 +170,7 @@
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in
 // distribution.
-static string GrpcEscapeJavadoc(const string& input) {
+static string GrpcEscapeJavadoc(const string &input) {
   string result;
   result.reserve(input.size() * 2);
 
@@ -221,9 +217,7 @@
         // Java interprets Unicode escape sequences anywhere!
         result.append("&#92;");
         break;
-      default:
-        result.push_back(c);
-        break;
+      default: result.push_back(c); break;
     }
 
     prev = c;
@@ -232,7 +226,7 @@
   return result;
 }
 
-static std::vector<string> GrpcGetDocLines(const string& comments) {
+static std::vector<string> GrpcGetDocLines(const string &comments) {
   if (!comments.empty()) {
     // TODO(kenton):  Ideally we should parse the comment text as Markdown and
     //   write it back as HTML, but this requires a Markdown parser.  For now
@@ -243,27 +237,23 @@
     string escapedComments = GrpcEscapeJavadoc(comments);
 
     std::vector<string> lines = GrpcSplit(escapedComments, "\n");
-    while (!lines.empty() && lines.back().empty()) {
-      lines.pop_back();
-    }
+    while (!lines.empty() && lines.back().empty()) { lines.pop_back(); }
     return lines;
   }
   return std::vector<string>();
 }
 
 static std::vector<string> GrpcGetDocLinesForDescriptor(
-    const DescriptorType* descriptor) {
+    const DescriptorType *descriptor) {
   return descriptor->GetAllComments();
   // return GrpcGetDocLines(descriptor->GetLeadingComments("///"));
 }
 
-static void GrpcWriteDocCommentBody(Printer* printer, VARS& vars,
-                                    const std::vector<string>& lines,
+static void GrpcWriteDocCommentBody(Printer *printer, VARS &vars,
+                                    const std::vector<string> &lines,
                                     bool surroundWithPreTag) {
   if (!lines.empty()) {
-    if (surroundWithPreTag) {
-      printer->Print(" * <pre>\n");
-    }
+    if (surroundWithPreTag) { printer->Print(" * <pre>\n"); }
 
     for (size_t i = 0; i < lines.size(); i++) {
       // Most lines should start with a space.  Watch out for lines that start
@@ -277,73 +267,72 @@
       }
     }
 
-    if (surroundWithPreTag) {
-      printer->Print(" * </pre>\n");
-    }
+    if (surroundWithPreTag) { printer->Print(" * </pre>\n"); }
   }
 }
 
-static void GrpcWriteDocComment(Printer* printer, VARS& vars,
-                                const string& comments) {
+static void GrpcWriteDocComment(Printer *printer, VARS &vars,
+                                const string &comments) {
   printer->Print("/**\n");
   std::vector<string> lines = GrpcGetDocLines(comments);
   GrpcWriteDocCommentBody(printer, vars, lines, false);
   printer->Print(" */\n");
 }
 
-static void GrpcWriteServiceDocComment(Printer* printer, VARS& vars,
-                                       const ServiceDescriptor* service) {
+static void GrpcWriteServiceDocComment(Printer *printer, VARS &vars,
+                                       const ServiceDescriptor *service) {
   printer->Print("/**\n");
   std::vector<string> lines = GrpcGetDocLinesForDescriptor(service);
   GrpcWriteDocCommentBody(printer, vars, lines, true);
   printer->Print(" */\n");
 }
 
-void GrpcWriteMethodDocComment(Printer* printer, VARS& vars,
-                               const MethodDescriptor* method) {
+void GrpcWriteMethodDocComment(Printer *printer, VARS &vars,
+                               const MethodDescriptor *method) {
   printer->Print("/**\n");
   std::vector<string> lines = GrpcGetDocLinesForDescriptor(method);
   GrpcWriteDocCommentBody(printer, vars, lines, true);
   printer->Print(" */\n");
 }
 
-//outputs static singleton extractor for type stored in "extr_type" and "extr_type_name" vars
-static void PrintTypeExtractor(Printer* p, VARS& vars) {
-  p->Print(
-    vars,
-    "private static volatile FlatbuffersUtils.FBExtactor<$extr_type$> "
-    "extractorOf$extr_type_name$;\n"
-    "private static FlatbuffersUtils.FBExtactor<$extr_type$> "
-    "getExtractorOf$extr_type_name$() {\n"
-    "    if (extractorOf$extr_type_name$ != null) return "
-    "extractorOf$extr_type_name$;\n"
-    "    synchronized ($service_class_name$.class) {\n"
-    "        if (extractorOf$extr_type_name$ != null) return "
-    "extractorOf$extr_type_name$;\n"
-    "        extractorOf$extr_type_name$ = new "
-    "FlatbuffersUtils.FBExtactor<$extr_type$>() {\n"
-    "            public $extr_type$ extract (ByteBuffer buffer) {\n"
-    "                return "
-    "$extr_type$.getRootAs$extr_type_name$(buffer);\n"
-    "            }\n"
-    "        };\n"
-    "        return extractorOf$extr_type_name$;\n"
-    "    }\n"
-    "}\n\n");
+// outputs static singleton extractor for type stored in "extr_type" and
+// "extr_type_name" vars
+static void PrintTypeExtractor(Printer *p, VARS &vars) {
+  p->Print(vars,
+           "private static volatile FlatbuffersUtils.FBExtactor<$extr_type$> "
+           "extractorOf$extr_type_name$;\n"
+           "private static FlatbuffersUtils.FBExtactor<$extr_type$> "
+           "getExtractorOf$extr_type_name$() {\n"
+           "    if (extractorOf$extr_type_name$ != null) return "
+           "extractorOf$extr_type_name$;\n"
+           "    synchronized ($service_class_name$.class) {\n"
+           "        if (extractorOf$extr_type_name$ != null) return "
+           "extractorOf$extr_type_name$;\n"
+           "        extractorOf$extr_type_name$ = new "
+           "FlatbuffersUtils.FBExtactor<$extr_type$>() {\n"
+           "            public $extr_type$ extract (ByteBuffer buffer) {\n"
+           "                return "
+           "$extr_type$.getRootAs$extr_type_name$(buffer);\n"
+           "            }\n"
+           "        };\n"
+           "        return extractorOf$extr_type_name$;\n"
+           "    }\n"
+           "}\n\n");
 }
-static void PrintMethodFields(Printer* p, VARS& vars,
-                              const ServiceDescriptor* service) {
+static void PrintMethodFields(Printer *p, VARS &vars,
+                              const ServiceDescriptor *service) {
   p->Print("// Static method descriptors that strictly reflect the proto.\n");
   vars["service_name"] = service->name();
 
-  //set of names of rpc input- and output- types that were already encountered.
-  //this is needed to avoid duplicating type extractor since it's possible that
-  //the same type is used as an input or output type of more than a single RPC method
+  // set of names of rpc input- and output- types that were already encountered.
+  // this is needed to avoid duplicating type extractor since it's possible that
+  // the same type is used as an input or output type of more than a single RPC
+  // method
   std::set<std::string> encounteredTypes;
 
   for (int i = 0; i < service->method_count(); ++i) {
     auto method = service->method(i);
-    vars["arg_in_id"] = to_string(2L * i); //trying to make msvc 10 happy
+    vars["arg_in_id"] = to_string(2L * i);  // trying to make msvc 10 happy
     vars["arg_out_id"] = to_string(2L * i + 1);
     vars["method_name"] = method->name();
     vars["input_type_name"] = method->get_input_type_name();
@@ -353,8 +342,10 @@
     vars["method_field_name"] = MethodPropertiesFieldName(method.get());
     vars["method_new_field_name"] = MethodPropertiesGetterName(method.get());
     vars["method_method_name"] = MethodPropertiesGetterName(method.get());
-    bool client_streaming = method->ClientStreaming() || method->BidiStreaming();
-    bool server_streaming = method->ServerStreaming() || method->BidiStreaming();
+    bool client_streaming =
+        method->ClientStreaming() || method->BidiStreaming();
+    bool server_streaming =
+        method->ServerStreaming() || method->BidiStreaming();
     if (client_streaming) {
       if (server_streaming) {
         vars["method_type"] = "BIDI_STREAMING";
@@ -394,32 +385,32 @@
     }
 
     p->Print(
-      vars,
-      "@$ExperimentalApi$(\"https://github.com/grpc/grpc-java/issues/"
-      "1901\")\n"
-      "public static $MethodDescriptor$<$input_type$,\n"
-      "    $output_type$> $method_method_name$() {\n"
-      "  $MethodDescriptor$<$input_type$, $output_type$> "
-      "$method_new_field_name$;\n"
-      "  if (($method_new_field_name$ = "
-      "$service_class_name$.$method_new_field_name$) == null) {\n"
-      "    synchronized ($service_class_name$.class) {\n"
-      "      if (($method_new_field_name$ = "
-      "$service_class_name$.$method_new_field_name$) == null) {\n"
-      "        $service_class_name$.$method_new_field_name$ = "
-      "$method_new_field_name$ = \n"
-      "            $MethodDescriptor$.<$input_type$, "
-      "$output_type$>newBuilder()\n"
-      "            .setType($MethodType$.$method_type$)\n"
-      "            .setFullMethodName(generateFullMethodName(\n"
-      "                \"$Package$$service_name$\", \"$method_name$\"))\n"
-      "            .setSampledToLocalTracing(true)\n"
-      "            .setRequestMarshaller(FlatbuffersUtils.marshaller(\n"
-      "                $input_type$.class, "
-      "getExtractorOf$input_type_name$()))\n"
-      "            .setResponseMarshaller(FlatbuffersUtils.marshaller(\n"
-      "                $output_type$.class, "
-      "getExtractorOf$output_type_name$()))\n");
+        vars,
+        "@$ExperimentalApi$(\"https://github.com/grpc/grpc-java/issues/"
+        "1901\")\n"
+        "public static $MethodDescriptor$<$input_type$,\n"
+        "    $output_type$> $method_method_name$() {\n"
+        "  $MethodDescriptor$<$input_type$, $output_type$> "
+        "$method_new_field_name$;\n"
+        "  if (($method_new_field_name$ = "
+        "$service_class_name$.$method_new_field_name$) == null) {\n"
+        "    synchronized ($service_class_name$.class) {\n"
+        "      if (($method_new_field_name$ = "
+        "$service_class_name$.$method_new_field_name$) == null) {\n"
+        "        $service_class_name$.$method_new_field_name$ = "
+        "$method_new_field_name$ = \n"
+        "            $MethodDescriptor$.<$input_type$, "
+        "$output_type$>newBuilder()\n"
+        "            .setType($MethodType$.$method_type$)\n"
+        "            .setFullMethodName(generateFullMethodName(\n"
+        "                \"$Package$$service_name$\", \"$method_name$\"))\n"
+        "            .setSampledToLocalTracing(true)\n"
+        "            .setRequestMarshaller(FlatbuffersUtils.marshaller(\n"
+        "                $input_type$.class, "
+        "getExtractorOf$input_type_name$()))\n"
+        "            .setResponseMarshaller(FlatbuffersUtils.marshaller(\n"
+        "                $output_type$.class, "
+        "getExtractorOf$output_type_name$()))\n");
 
     //            vars["proto_method_descriptor_supplier"] = service->name() +
     //            "MethodDescriptorSupplier";
@@ -451,11 +442,11 @@
 
 enum CallType { ASYNC_CALL = 0, BLOCKING_CALL = 1, FUTURE_CALL = 2 };
 
-static void PrintBindServiceMethodBody(Printer* p, VARS& vars,
-                                       const ServiceDescriptor* service);
+static void PrintBindServiceMethodBody(Printer *p, VARS &vars,
+                                       const ServiceDescriptor *service);
 
 // Prints a client interface or implementation class, or a server interface.
-static void PrintStub(Printer* p, VARS& vars, const ServiceDescriptor* service,
+static void PrintStub(Printer *p, VARS &vars, const ServiceDescriptor *service,
                       StubType type) {
   const string service_name = service->name();
   vars["service_name"] = service_name;
@@ -476,7 +467,7 @@
       break;
     case BLOCKING_CLIENT_INTERFACE:
       interface = true;
-      FLATBUFFERS_FALLTHROUGH(); // fall thru
+      FLATBUFFERS_FALLTHROUGH();  // fall thru
     case BLOCKING_CLIENT_IMPL:
       call_type = BLOCKING_CALL;
       stub_name += "BlockingStub";
@@ -484,7 +475,7 @@
       break;
     case FUTURE_CLIENT_INTERFACE:
       interface = true;
-      FLATBUFFERS_FALLTHROUGH(); // fall thru
+      FLATBUFFERS_FALLTHROUGH();  // fall thru
     case FUTURE_CLIENT_IMPL:
       call_type = FUTURE_CALL;
       stub_name += "FutureStub";
@@ -501,9 +492,7 @@
   vars["client_name"] = client_name;
 
   // Class head
-  if (!interface) {
-    GrpcWriteServiceDocComment(p, vars, service);
-  }
+  if (!interface) { GrpcWriteServiceDocComment(p, vars, service); }
   if (impl_base) {
     p->Print(vars,
              "public static abstract class $abstract_name$ implements "
@@ -546,8 +535,10 @@
     vars["output_type"] = JavaClassName(vars, method->get_output_type_name());
     vars["lower_method_name"] = LowerMethodName(&*method);
     vars["method_method_name"] = MethodPropertiesGetterName(&*method);
-    bool client_streaming = method->ClientStreaming() || method->BidiStreaming();
-    bool server_streaming = method->ServerStreaming() || method->BidiStreaming();
+    bool client_streaming =
+        method->ClientStreaming() || method->BidiStreaming();
+    bool server_streaming =
+        method->ServerStreaming() || method->BidiStreaming();
 
     if (call_type == BLOCKING_CALL && client_streaming) {
       // Blocking client interface with client streaming is not available
@@ -563,9 +554,7 @@
     p->Print("\n");
     // TODO(nmittler): Replace with WriteMethodDocComment once included by the
     // protobuf distro.
-    if (!interface) {
-      GrpcWriteMethodDocComment(p, vars, &*method);
-    }
+    if (!interface) { GrpcWriteMethodDocComment(p, vars, &*method); }
     p->Print("public ");
     switch (call_type) {
       case BLOCKING_CALL:
@@ -630,8 +619,7 @@
                      "responseObserver);\n");
           }
           break;
-        default:
-          break;
+        default: break;
       }
     } else if (!interface) {
       switch (call_type) {
@@ -706,15 +694,15 @@
 }
 
 static bool CompareMethodClientStreaming(
-    const std::unique_ptr<const grpc_generator::Method>& method1,
-    const std::unique_ptr<const grpc_generator::Method>& method2) {
+    const std::unique_ptr<const grpc_generator::Method> &method1,
+    const std::unique_ptr<const grpc_generator::Method> &method2) {
   return method1->ClientStreaming() < method2->ClientStreaming();
 }
 
 // Place all method invocations into a single class to reduce memory footprint
 // on Android.
-static void PrintMethodHandlerClass(Printer* p, VARS& vars,
-                                    const ServiceDescriptor* service) {
+static void PrintMethodHandlerClass(Printer *p, VARS &vars,
+                                    const ServiceDescriptor *service) {
   // Sort method ids based on ClientStreaming() so switch tables are compact.
   std::vector<std::unique_ptr<const grpc_generator::Method>> sorted_methods(
       service->method_count());
@@ -724,7 +712,7 @@
   stable_sort(sorted_methods.begin(), sorted_methods.end(),
               CompareMethodClientStreaming);
   for (size_t i = 0; i < sorted_methods.size(); i++) {
-    auto& method = sorted_methods[i];
+    auto &method = sorted_methods[i];
     vars["method_id"] = to_string(i);
     vars["method_id_name"] = MethodIdFieldName(&*method);
     p->Print(vars,
@@ -757,9 +745,7 @@
 
   for (int i = 0; i < service->method_count(); ++i) {
     auto method = service->method(i);
-    if (method->ClientStreaming() || method->BidiStreaming()) {
-      continue;
-    }
+    if (method->ClientStreaming() || method->BidiStreaming()) { continue; }
     vars["method_id_name"] = MethodIdFieldName(&*method);
     vars["lower_method_name"] = LowerMethodName(&*method);
     vars["input_type"] = JavaClassName(vars, method->get_input_type_name());
@@ -791,9 +777,7 @@
 
   for (int i = 0; i < service->method_count(); ++i) {
     auto method = service->method(i);
-    if (!(method->ClientStreaming() || method->BidiStreaming())) {
-      continue;
-    }
+    if (!(method->ClientStreaming() || method->BidiStreaming())) { continue; }
     vars["method_id_name"] = MethodIdFieldName(&*method);
     vars["lower_method_name"] = LowerMethodName(&*method);
     vars["input_type"] = JavaClassName(vars, method->get_input_type_name());
@@ -818,8 +802,8 @@
   p->Print("}\n\n");
 }
 
-static void PrintGetServiceDescriptorMethod(Printer* p, VARS& vars,
-                                            const ServiceDescriptor* service) {
+static void PrintGetServiceDescriptorMethod(Printer *p, VARS &vars,
+                                            const ServiceDescriptor *service) {
   vars["service_name"] = service->name();
   //        vars["proto_base_descriptor_supplier"] = service->name() +
   //        "BaseDescriptorSupplier"; vars["proto_file_descriptor_supplier"] =
@@ -911,8 +895,8 @@
   p->Print("}\n");
 }
 
-static void PrintBindServiceMethodBody(Printer* p, VARS& vars,
-                                       const ServiceDescriptor* service) {
+static void PrintBindServiceMethodBody(Printer *p, VARS &vars,
+                                       const ServiceDescriptor *service) {
   vars["service_name"] = service->name();
   p->Indent();
   p->Print(vars,
@@ -927,8 +911,10 @@
     vars["input_type"] = JavaClassName(vars, method->get_input_type_name());
     vars["output_type"] = JavaClassName(vars, method->get_output_type_name());
     vars["method_id_name"] = MethodIdFieldName(&*method);
-    bool client_streaming = method->ClientStreaming() || method->BidiStreaming();
-    bool server_streaming = method->ServerStreaming() || method->BidiStreaming();
+    bool client_streaming =
+        method->ClientStreaming() || method->BidiStreaming();
+    bool server_streaming =
+        method->ServerStreaming() || method->BidiStreaming();
     if (client_streaming) {
       if (server_streaming) {
         vars["calls_method"] = "asyncBidiStreamingCall";
@@ -962,8 +948,8 @@
   p->Outdent();
 }
 
-static void PrintService(Printer* p, VARS& vars,
-                         const ServiceDescriptor* service,
+static void PrintService(Printer *p, VARS &vars,
+                         const ServiceDescriptor *service,
                          bool disable_version) {
   vars["service_name"] = service->name();
   vars["service_class_name"] = ServiceClassName(service->name());
@@ -1043,7 +1029,7 @@
   p->Print("}\n");
 }
 
-void PrintStaticImports(Printer* p) {
+void PrintStaticImports(Printer *p) {
   p->Print(
       "import java.nio.ByteBuffer;\n"
       "import static "
@@ -1076,8 +1062,8 @@
       "io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;\n\n");
 }
 
-void GenerateService(const grpc_generator::Service* service,
-                     grpc_generator::Printer* printer, VARS& vars,
+void GenerateService(const grpc_generator::Service *service,
+                     grpc_generator::Printer *printer, VARS &vars,
                      bool disable_version) {
   // All non-generated classes must be referred by fully qualified names to
   // avoid collision with generated classes.
@@ -1113,8 +1099,8 @@
 }
 
 grpc::string GenerateServiceSource(
-    grpc_generator::File* file, const grpc_generator::Service* service,
-    grpc_java_generator::Parameters* parameters) {
+    grpc_generator::File *file, const grpc_generator::Service *service,
+    grpc_java_generator::Parameters *parameters) {
   grpc::string out;
   auto printer = file->CreatePrinter(&out);
   VARS vars;
diff --git a/grpc/src/compiler/python_generator.cc b/grpc/src/compiler/python_generator.cc
index 3fcf7ea..8108db4 100644
--- a/grpc/src/compiler/python_generator.cc
+++ b/grpc/src/compiler/python_generator.cc
@@ -16,608 +16,133 @@
  *
  */
 
-#include <algorithm>
-#include <cassert>
-#include <cctype>
-#include <cstring>
-#include <fstream>
-#include <iostream>
 #include <map>
-#include <memory>
-#include <ostream>
-#include <set>
 #include <sstream>
-#include <tuple>
-#include <vector>
 
 #include "flatbuffers/util.h"
 #include "src/compiler/python_generator.h"
-#include "src/compiler/python_private_generator.h"
-
-using std::make_pair;
-using std::map;
-using std::pair;
-using std::replace;
-using std::tuple;
-using std::vector;
-using std::set;
 
 namespace grpc_python_generator {
 
-grpc::string generator_file_name;
+grpc::string GenerateMethodType(const grpc_generator::Method *method) {
 
-typedef map<grpc::string, grpc::string> StringMap;
-typedef vector<grpc::string> StringVector;
-typedef tuple<grpc::string, grpc::string> StringPair;
-typedef set<StringPair> StringPairSet;
+  if (method->NoStreaming())
+    return "unary_unary";
 
-// Provides RAII indentation handling. Use as:
-// {
-//   IndentScope raii_my_indent_var_name_here(my_py_printer);
-//   // constructor indented my_py_printer
-//   ...
-//   // destructor called at end of scope, un-indenting my_py_printer
-// }
-class IndentScope {
- public:
-  explicit IndentScope(grpc_generator::Printer* printer) : printer_(printer) {
-    printer_->Indent();
+  if (method->ServerStreaming())
+    return "unary_stream";
+
+  if (method->ClientStreaming())
+    return "stream_unary";
+
+  return "stream_stream";
+}
+
+grpc::string GenerateMethodInput(const grpc_generator::Method *method) {
+
+  if (method->NoStreaming() || method->ServerStreaming())
+    return "self, request, context";
+
+  return "self, request_iterator, context";
+}
+
+void GenerateStub(const grpc_generator::Service *service,
+                  grpc_generator::Printer *printer,
+                  std::map<grpc::string, grpc::string> *dictonary) {
+  auto vars = *dictonary;
+  printer->Print(vars, "class $ServiceName$Stub(object):\n");
+  printer->Indent();
+  printer->Print("\"\"\" Interface exported by the server. \"\"\"");
+  printer->Print("\n\n");
+  printer->Print("def __init__(self, channel):\n");
+  printer->Indent();
+  printer->Print("\"\"\" Constructor. \n\n");
+  printer->Print("Args: \n");
+  printer->Print("channel: A grpc.Channel. \n");
+  printer->Print("\"\"\"\n\n");
+
+  for (int j = 0; j < service->method_count(); j++) {
+    auto method = service->method(j);
+    vars["MethodName"] = method->name();
+    vars["MethodType"] = GenerateMethodType(&*method);
+    printer->Print(vars, "self.$MethodName$ = channel.$MethodType$(\n");
+    printer->Indent();
+    printer->Print(vars, "\"/$PATH$$ServiceName$/$MethodName$\"\n");
+    printer->Print(")\n");
+    printer->Outdent();
+    printer->Print("\n");
   }
-
-  ~IndentScope() { printer_->Outdent(); }
-
- private:
-  grpc_generator::Printer* printer_;
-};
-
-inline grpc::string StringReplace(grpc::string str, const grpc::string& from,
-                                  const grpc::string& to, bool replace_all) {
-  size_t pos = 0;
-
-  do {
-    pos = str.find(from, pos);
-    if (pos == grpc::string::npos) {
-      break;
-    }
-    str.replace(pos, from.length(), to);
-    pos += to.length();
-  } while (replace_all);
-
-  return str;
+  printer->Outdent();
+  printer->Outdent();
+  printer->Print("\n");
 }
 
-inline grpc::string StringReplace(grpc::string str, const grpc::string& from,
-                                  const grpc::string& to) {
-  return StringReplace(str, from, to, true);
-}
+void GenerateServicer(const grpc_generator::Service *service,
+                      grpc_generator::Printer *printer,
+                      std::map<grpc::string, grpc::string> *dictonary) {
+  auto vars = *dictonary;
+  printer->Print(vars, "class $ServiceName$Servicer(object):\n");
+  printer->Indent();
+  printer->Print("\"\"\" Interface exported by the server. \"\"\"");
+  printer->Print("\n\n");
 
-grpc::string ModuleName(const grpc::string& filename,
-                        const grpc::string& import_prefix) {
-  grpc::string basename = flatbuffers::StripExtension(filename);
-  basename = StringReplace(basename, "-", "_");
-  basename = StringReplace(basename, "/", ".");
-  return import_prefix + basename + "_fb";
-}
-
-grpc::string ModuleAlias(const grpc::string& filename,
-                         const grpc::string& import_prefix) {
-  grpc::string module_name = ModuleName(filename, import_prefix);
-  // We can't have dots in the module name, so we replace each with _dot_.
-  // But that could lead to a collision between a.b and a_dot_b, so we also
-  // duplicate each underscore.
-  module_name = StringReplace(module_name, "_", "__");
-  module_name = StringReplace(module_name, ".", "_dot_");
-  return module_name;
-}
-
-PrivateGenerator::PrivateGenerator(const GeneratorConfiguration& config_,
-                                   const grpc_generator::File* file_)
-    : config(config_), file(file_) {}
-
-void PrivateGenerator::PrintBetaServicer(const grpc_generator::Service* service,
-                                         grpc_generator::Printer* out) {
-  StringMap service_dict;
-  service_dict["Service"] = service->name();
-  out->Print("\n\n");
-  out->Print(service_dict, "class Beta$Service$Servicer(object):\n");
-  {
-    IndentScope raii_class_indent(out);
-    out->Print(
-        "\"\"\"The Beta API is deprecated for 0.15.0 and later.\n"
-        "\nIt is recommended to use the GA API (classes and functions in this\n"
-        "file not marked beta) for all further purposes. This class was "
-        "generated\n"
-        "only to ease transition from grpcio<0.15.0 to "
-        "grpcio>=0.15.0.\"\"\"\n");
-    for (int i = 0; i < service->method_count(); ++i) {
-      auto method = service->method(i);
-      grpc::string arg_name =
-          method->ClientStreaming() ? "request_iterator" : "request";
-      StringMap method_dict;
-      method_dict["Method"] = method->name();
-      method_dict["ArgName"] = arg_name;
-      out->Print(method_dict, "def $Method$(self, $ArgName$, context):\n");
-      {
-        IndentScope raii_method_indent(out);
-        out->Print("context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)\n");
-      }
-    }
+  for (int j = 0; j < service->method_count(); j++) {
+    auto method = service->method(j);
+    vars["MethodName"] = method->name();
+    vars["MethodInput"] = GenerateMethodInput(&*method);
+    printer->Print(vars, "def $MethodName$($MethodInput$):\n");
+    printer->Indent();
+    printer->Print("context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n");
+    printer->Print("context.set_details('Method not implemented!')\n");
+    printer->Print("raise NotImplementedError('Method not implemented!')\n");
+    printer->Outdent();
+    printer->Print("\n\n");
   }
+  printer->Outdent();
+  printer->Print("\n");
+
 }
 
-void PrivateGenerator::PrintBetaStub(const grpc_generator::Service* service,
-                                     grpc_generator::Printer* out) {
-  StringMap service_dict;
-  service_dict["Service"] = service->name();
-  out->Print("\n\n");
-  out->Print(service_dict, "class Beta$Service$Stub(object):\n");
-  {
-    IndentScope raii_class_indent(out);
-    out->Print(
-        "\"\"\"The Beta API is deprecated for 0.15.0 and later.\n"
-        "\nIt is recommended to use the GA API (classes and functions in this\n"
-        "file not marked beta) for all further purposes. This class was "
-        "generated\n"
-        "only to ease transition from grpcio<0.15.0 to "
-        "grpcio>=0.15.0.\"\"\"\n");
-    for (int i = 0; i < service->method_count(); ++i) {
-      auto method = service->method(i);
-      grpc::string arg_name =
-          method->ClientStreaming() ? "request_iterator" : "request";
-      StringMap method_dict;
-      method_dict["Method"] = method->name();
-      method_dict["ArgName"] = arg_name;
-      out->Print(method_dict,
-                 "def $Method$(self, $ArgName$, timeout, metadata=None, "
-                 "with_call=False, protocol_options=None):\n");
-      {
-        IndentScope raii_method_indent(out);
-        out->Print("raise NotImplementedError()\n");
-      }
-      if (!method->ServerStreaming()) {
-        out->Print(method_dict, "$Method$.future = None\n");
-      }
-    }
+void GenerateRegister(const grpc_generator::Service *service,
+                      grpc_generator::Printer *printer,
+                      std::map<grpc::string, grpc::string> *dictonary) {
+  auto vars = *dictonary;
+  printer->Print(vars, "def add_$ServiceName$Servicer_to_server(servicer, server):\n");
+  printer->Indent();
+  printer->Print("rpc_method_handlers = {\n");
+  printer->Indent();
+  for (int j = 0; j < service->method_count(); j++) {
+    auto method = service->method(j);
+    vars["MethodName"] = method->name();
+    vars["MethodType"] = GenerateMethodType(&*method);
+    printer->Print(vars, "'$MethodName$': grpc.$MethodType$_rpc_method_handler(\n");
+    printer->Indent();
+    printer->Print(vars, "servicer.$MethodName$\n");
+    printer->Outdent();
+    printer->Print("),\n");
   }
+  printer->Outdent();
+  printer->Print("}\n");
+  printer->Print(vars, "generic_handler = grpc.method_handlers_generic_handler(\n");
+  printer->Indent();
+  printer->Print(vars, "'$PATH$$ServiceName$', rpc_method_handlers)\n");
+  printer->Outdent();
+  printer->Print("server.add_generic_rpc_handlers((generic_handler,))");
+  printer->Outdent();
+  printer->Print("\n");
 }
 
-void PrivateGenerator::PrintBetaServerFactory(
-    const grpc::string& package_qualified_service_name,
-    const grpc_generator::Service* service, grpc_generator::Printer* out) {
-  StringMap service_dict;
-  service_dict["Service"] = service->name();
-  out->Print("\n\n");
-  out->Print(service_dict,
-             "def beta_create_$Service$_server(servicer, pool=None, "
-             "pool_size=None, default_timeout=None, maximum_timeout=None):\n");
-  {
-    IndentScope raii_create_server_indent(out);
-    out->Print(
-        "\"\"\"The Beta API is deprecated for 0.15.0 and later.\n"
-        "\nIt is recommended to use the GA API (classes and functions in this\n"
-        "file not marked beta) for all further purposes. This function was\n"
-        "generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0"
-        "\"\"\"\n");
-    StringMap method_implementation_constructors;
-    StringMap input_message_modules_and_classes;
-    StringMap output_message_modules_and_classes;
-    for (int i = 0; i < service->method_count(); ++i) {
-      auto method = service->method(i);
-      const grpc::string method_implementation_constructor =
-          grpc::string(method->ClientStreaming() ? "stream_" : "unary_") +
-          grpc::string(method->ServerStreaming() ? "stream_" : "unary_") +
-          "inline";
-      grpc::string input_message_module_and_class = method->get_fb_builder();
-      grpc::string output_message_module_and_class = method->get_fb_builder();
-      method_implementation_constructors.insert(
-          make_pair(method->name(), method_implementation_constructor));
-      input_message_modules_and_classes.insert(
-          make_pair(method->name(), input_message_module_and_class));
-      output_message_modules_and_classes.insert(
-          make_pair(method->name(), output_message_module_and_class));
-    }
-    StringMap method_dict;
-    method_dict["PackageQualifiedServiceName"] = package_qualified_service_name;
-//    out->Print("request_deserializers = {\n");
-//    for (StringMap::iterator name_and_input_module_class_pair =
-//             input_message_modules_and_classes.begin();
-//         name_and_input_module_class_pair !=
-//         input_message_modules_and_classes.end();
-//         name_and_input_module_class_pair++) {
-//      method_dict["MethodName"] = name_and_input_module_class_pair->first;
-//      method_dict["InputTypeModuleAndClass"] =
-//          name_and_input_module_class_pair->second;
-//      IndentScope raii_indent(out);
-//      out->Print(method_dict,
-//                 "(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): "
-//                 "$InputTypeModuleAndClass$.FromString,\n");
-//    }
-//    out->Print("}\n");
-//    out->Print("response_serializers = {\n");
-//    for (StringMap::iterator name_and_output_module_class_pair =
-//             output_message_modules_and_classes.begin();
-//         name_and_output_module_class_pair !=
-//         output_message_modules_and_classes.end();
-//         name_and_output_module_class_pair++) {
-//      method_dict["MethodName"] = name_and_output_module_class_pair->first;
-//      method_dict["OutputTypeModuleAndClass"] =
-//          name_and_output_module_class_pair->second;
-//      IndentScope raii_indent(out);
-//      out->Print(method_dict,
-//                 "(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): "
-//                 "$OutputTypeModuleAndClass$.SerializeToString,\n");
-//    }
-//    out->Print("}\n");
-    out->Print("method_implementations = {\n");
-    for (StringMap::iterator name_and_implementation_constructor =
-             method_implementation_constructors.begin();
-         name_and_implementation_constructor !=
-         method_implementation_constructors.end();
-         name_and_implementation_constructor++) {
-      method_dict["Method"] = name_and_implementation_constructor->first;
-      method_dict["Constructor"] = name_and_implementation_constructor->second;
-      IndentScope raii_descriptions_indent(out);
-      const grpc::string method_name =
-          name_and_implementation_constructor->first;
-      out->Print(method_dict,
-                 "(\'$PackageQualifiedServiceName$\', \'$Method$\'): "
-                 "face_utilities.$Constructor$(servicer.$Method$),\n");
-    }
-    out->Print("}\n");
-    out->Print(
-        "server_options = beta_implementations.server_options("
-        "thread_pool=pool, thread_pool_size=pool_size, "
-        "default_timeout=default_timeout, "
-        "maximum_timeout=maximum_timeout)\n");
-    out->Print(
-        "return beta_implementations.server(method_implementations, "
-        "options=server_options)\n");
-        //"request_deserializers=request_deserializers, "
-        //"response_serializers=response_serializers, "
-  }
-}
-
-void PrivateGenerator::PrintBetaStubFactory(
-    const grpc::string& package_qualified_service_name,
-    const grpc_generator::Service* service, grpc_generator::Printer* out) {
-  StringMap dict;
-  dict["Service"] = service->name();
-  out->Print("\n\n");
-  out->Print(dict,
-             "def beta_create_$Service$_stub(channel, host=None,"
-             " metadata_transformer=None, pool=None, pool_size=None):\n");
-  {
-    IndentScope raii_create_server_indent(out);
-    out->Print(
-        "\"\"\"The Beta API is deprecated for 0.15.0 and later.\n"
-        "\nIt is recommended to use the GA API (classes and functions in this\n"
-        "file not marked beta) for all further purposes. This function was\n"
-        "generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0"
-        "\"\"\"\n");
-    StringMap method_cardinalities;
-    StringMap input_message_modules_and_classes;
-    StringMap output_message_modules_and_classes;
-    for (int i = 0; i < service->method_count(); ++i) {
-      auto method = service->method(i);
-      const grpc::string method_cardinality =
-          grpc::string(method->ClientStreaming() ? "STREAM" : "UNARY") +
-          "_" +
-          grpc::string(method->ServerStreaming() ? "STREAM" : "UNARY");
-      grpc::string input_message_module_and_class = method->get_fb_builder();
-      grpc::string output_message_module_and_class = method->get_fb_builder();
-      method_cardinalities.insert(
-          make_pair(method->name(), method_cardinality));
-      input_message_modules_and_classes.insert(
-          make_pair(method->name(), input_message_module_and_class));
-      output_message_modules_and_classes.insert(
-          make_pair(method->name(), output_message_module_and_class));
-    }
-    StringMap method_dict;
-    method_dict["PackageQualifiedServiceName"] = package_qualified_service_name;
-//    out->Print("request_serializers = {\n");
-//    for (StringMap::iterator name_and_input_module_class_pair =
-//             input_message_modules_and_classes.begin();
-//         name_and_input_module_class_pair !=
-//         input_message_modules_and_classes.end();
-//         name_and_input_module_class_pair++) {
-//      method_dict["MethodName"] = name_and_input_module_class_pair->first;
-//      method_dict["InputTypeModuleAndClass"] =
-//          name_and_input_module_class_pair->second;
-//      IndentScope raii_indent(out);
-//      out->Print(method_dict,
-//                 "(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): "
-//                 "$InputTypeModuleAndClass$.SerializeToString,\n");
-//    }
-//    out->Print("}\n");
-//    out->Print("response_deserializers = {\n");
-//    for (StringMap::iterator name_and_output_module_class_pair =
-//             output_message_modules_and_classes.begin();
-//         name_and_output_module_class_pair !=
-//         output_message_modules_and_classes.end();
-//         name_and_output_module_class_pair++) {
-//      method_dict["MethodName"] = name_and_output_module_class_pair->first;
-//      method_dict["OutputTypeModuleAndClass"] =
-//          name_and_output_module_class_pair->second;
-//      IndentScope raii_indent(out);
-//      out->Print(method_dict,
-//                 "(\'$PackageQualifiedServiceName$\', \'$MethodName$\'): "
-//                 "$OutputTypeModuleAndClass$.FromString,\n");
-//    }
-//    out->Print("}\n");
-    out->Print("cardinalities = {\n");
-    for (StringMap::iterator name_and_cardinality =
-             method_cardinalities.begin();
-         name_and_cardinality != method_cardinalities.end();
-         name_and_cardinality++) {
-      method_dict["Method"] = name_and_cardinality->first;
-      method_dict["Cardinality"] = name_and_cardinality->second;
-      IndentScope raii_descriptions_indent(out);
-      out->Print(method_dict,
-                 "\'$Method$\': cardinality.Cardinality.$Cardinality$,\n");
-    }
-    out->Print("}\n");
-    out->Print(
-        "stub_options = beta_implementations.stub_options("
-        "host=host, metadata_transformer=metadata_transformer, "
-        "thread_pool=pool, thread_pool_size=pool_size)\n");
-    out->Print(method_dict,
-               "return beta_implementations.dynamic_stub(channel, "
-               "\'$PackageQualifiedServiceName$\', "
-               "cardinalities, options=stub_options)\n");
-        // "request_serializers=request_serializers, "
-        //"response_deserializers=response_deserializers, "
-  }
-}
-
-void PrivateGenerator::PrintStub(
-    const grpc::string& package_qualified_service_name,
-    const grpc_generator::Service* service, grpc_generator::Printer* out) {
-  StringMap dict;
-  dict["Service"] = service->name();
-  out->Print("\n\n");
-  out->Print(dict, "class $Service$Stub(object):\n");
-  {
-    IndentScope raii_class_indent(out);
-    out->Print("\n");
-    out->Print("def __init__(self, channel):\n");
-    {
-      IndentScope raii_init_indent(out);
-      out->Print("\"\"\"Constructor.\n");
-      out->Print("\n");
-      out->Print("Args:\n");
-      {
-        IndentScope raii_args_indent(out);
-        out->Print("channel: A grpc.Channel.\n");
-      }
-      out->Print("\"\"\"\n");
-      for (int i = 0; i < service->method_count(); ++i) {
-        auto method = service->method(i);
-        grpc::string multi_callable_constructor =
-            grpc::string(method->ClientStreaming() ? "stream" : "unary") +
-            "_" +
-            grpc::string(method->ServerStreaming() ? "stream" : "unary");
-        grpc::string request_module_and_class = method->get_fb_builder();
-        grpc::string response_module_and_class = method->get_fb_builder();
-        StringMap method_dict;
-        method_dict["Method"] = method->name();
-        method_dict["MultiCallableConstructor"] = multi_callable_constructor;
-        out->Print(method_dict,
-                   "self.$Method$ = channel.$MultiCallableConstructor$(\n");
-        {
-          method_dict["PackageQualifiedService"] =
-              package_qualified_service_name;
-          method_dict["RequestModuleAndClass"] = request_module_and_class;
-          method_dict["ResponseModuleAndClass"] = response_module_and_class;
-          IndentScope raii_first_attribute_indent(out);
-          IndentScope raii_second_attribute_indent(out);
-          out->Print(method_dict, "'/$PackageQualifiedService$/$Method$',\n");
-          out->Print(method_dict,"\n");
-          out->Print(
-              method_dict,"\n");
-          out->Print(")\n");
-        }
-      }
-    }
-  }
-}
-
-void PrivateGenerator::PrintServicer(const grpc_generator::Service* service,
-                                     grpc_generator::Printer* out) {
-  StringMap service_dict;
-  service_dict["Service"] = service->name();
-  out->Print("\n\n");
-  out->Print(service_dict, "class $Service$Servicer(object):\n");
-  {
-    IndentScope raii_class_indent(out);
-    for (int i = 0; i < service->method_count(); ++i) {
-      auto method = service->method(i);
-      grpc::string arg_name =
-          method->ClientStreaming() ? "request_iterator" : "request";
-      StringMap method_dict;
-      method_dict["Method"] = method->name();
-      method_dict["ArgName"] = arg_name;
-      out->Print("\n");
-      out->Print(method_dict, "def $Method$(self, $ArgName$, context):\n");
-      {
-        IndentScope raii_method_indent(out);
-        out->Print("context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n");
-        out->Print("context.set_details('Method not implemented!')\n");
-        out->Print("raise NotImplementedError('Method not implemented!')\n");
-      }
-    }
-  }
-}
-
-void PrivateGenerator::PrintAddServicerToServer(
-    const grpc::string& package_qualified_service_name,
-    const grpc_generator::Service* service, grpc_generator::Printer* out) {
-  StringMap service_dict;
-  service_dict["Service"] = service->name();
-  out->Print("\n\n");
-  out->Print(service_dict,
-             "def add_$Service$Servicer_to_server(servicer, server):\n");
-  {
-    IndentScope raii_class_indent(out);
-    out->Print("rpc_method_handlers = {\n");
-    {
-      IndentScope raii_dict_first_indent(out);
-      IndentScope raii_dict_second_indent(out);
-      for (int i = 0; i < service->method_count(); ++i) {
-        auto method = service->method(i);
-        grpc::string method_handler_constructor =
-            grpc::string(method->ClientStreaming() ? "stream" : "unary") +
-            "_" +
-            grpc::string(method->ServerStreaming() ? "stream" : "unary") +
-            "_rpc_method_handler";
-        grpc::string request_module_and_class = method->get_fb_builder();
-        grpc::string response_module_and_class = method->get_fb_builder();
-        StringMap method_dict;
-        method_dict["Method"] = method->name();
-        method_dict["MethodHandlerConstructor"] = method_handler_constructor;
-        method_dict["RequestModuleAndClass"] = request_module_and_class;
-        method_dict["ResponseModuleAndClass"] = response_module_and_class;
-        out->Print(method_dict,
-                   "'$Method$': grpc.$MethodHandlerConstructor$(\n");
-        {
-          IndentScope raii_call_first_indent(out);
-          IndentScope raii_call_second_indent(out);
-          out->Print(method_dict, "servicer.$Method$,\n");
-          out->Print(
-              method_dict,"\n");
-          out->Print(
-              method_dict,
-              "\n");
-        }
-        out->Print("),\n");
-      }
-    }
-    StringMap method_dict;
-    method_dict["PackageQualifiedServiceName"] = package_qualified_service_name;
-    out->Print("}\n");
-    out->Print("generic_handler = grpc.method_handlers_generic_handler(\n");
-    {
-      IndentScope raii_call_first_indent(out);
-      IndentScope raii_call_second_indent(out);
-      out->Print(method_dict,
-                 "'$PackageQualifiedServiceName$', rpc_method_handlers)\n");
-    }
-    out->Print("server.add_generic_rpc_handlers((generic_handler,))\n");
-  }
-}
-
-void PrivateGenerator::PrintBetaPreamble(grpc_generator::Printer* out) {
-  StringMap var;
-  var["Package"] = config.beta_package_root;
-  out->Print(var,
-             "from $Package$ import implementations as beta_implementations\n");
-  out->Print(var, "from $Package$ import interfaces as beta_interfaces\n");
-  out->Print("from grpc.framework.common import cardinality\n");
-  out->Print(
-      "from grpc.framework.interfaces.face import utilities as "
-      "face_utilities\n");
-}
-
-void PrivateGenerator::PrintPreamble(grpc_generator::Printer* out) {
-  StringMap var;
-  var["Package"] = config.grpc_package_root;
-  out->Print(var, "import $Package$\n");
-  out->Print("\n");
-  StringPairSet imports_set;
-  for (int i = 0; i < file->service_count(); ++i) {
-    auto service = file->service(i);
-    for (int j = 0; j < service->method_count(); ++j) {
-      auto method = service.get()->method(j);
-
-      grpc::string input_type_file_name = method->get_fb_builder();
-      grpc::string input_module_name =
-          ModuleName(input_type_file_name, config.import_prefix);
-      grpc::string input_module_alias =
-          ModuleAlias(input_type_file_name, config.import_prefix);
-      imports_set.insert(
-          std::make_tuple(input_module_name, input_module_alias));
-
-      grpc::string output_type_file_name = method->get_fb_builder();
-      grpc::string output_module_name =
-          ModuleName(output_type_file_name, config.import_prefix);
-      grpc::string output_module_alias =
-          ModuleAlias(output_type_file_name, config.import_prefix);
-      imports_set.insert(
-          std::make_tuple(output_module_name, output_module_alias));
-    }
-  }
-
-  for (StringPairSet::iterator it = imports_set.begin();
-       it != imports_set.end(); ++it) {
-    var["ModuleName"] = std::get<0>(*it);
-    var["ModuleAlias"] = std::get<1>(*it);
-    out->Print(var, "import $ModuleName$ as $ModuleAlias$\n");
-  }
-}
-
-void PrivateGenerator::PrintGAServices(grpc_generator::Printer* out) {
-  grpc::string package = file->package();
-  if (!package.empty()) {
-    package = package.append(".");
-  }
-
-  out->Print(file->additional_headers().c_str());
-
-  for (int i = 0; i < file->service_count(); ++i) {
-    auto service = file->service(i);
-
-    grpc::string package_qualified_service_name = package + service->name();
-    PrintStub(package_qualified_service_name, service.get(), out);
-    PrintServicer(service.get(), out);
-    PrintAddServicerToServer(package_qualified_service_name, service.get(),
-                             out);
-  }
-}
-
-void PrivateGenerator::PrintBetaServices(grpc_generator::Printer* out) {
-  grpc::string package = file->package();
-  if (!package.empty()) {
-    package = package.append(".");
-  }
-  for (int i = 0; i < file->service_count(); ++i) {
-    auto service = file->service(i);
-
-    grpc::string package_qualified_service_name = package + service->name();
-    PrintBetaServicer(service.get(), out);
-    PrintBetaStub(service.get(), out);
-    PrintBetaServerFactory(package_qualified_service_name, service.get(), out);
-    PrintBetaStubFactory(package_qualified_service_name, service.get(), out);
-  }
-}
-
-grpc::string PrivateGenerator::GetGrpcServices() {
+grpc::string Generate(grpc_generator::File *file,
+                      const grpc_generator::Service *service) {
   grpc::string output;
-  {
-    // Scope the output stream so it closes and finalizes output to the string.
-    auto out = file->CreatePrinter(&output);
-    out->Print(
-        "# Generated by the gRPC Python protocol compiler plugin. "
-        "DO NOT EDIT!\n");
-    StringMap var;
-    var["Package"] = config.grpc_package_root;
-    out->Print(var, "import $Package$\n");
-    PrintGAServices(out.get());
-    out->Print("try:\n");
-    {
-      IndentScope raii_dict_try_indent(out.get());
-      out->Print(
-          "# THESE ELEMENTS WILL BE DEPRECATED.\n"
-          "# Please use the generated *_pb2_grpc.py files instead.\n");
-      out->Print(var, "import $Package$\n");
-      PrintBetaPreamble(out.get());
-      PrintGAServices(out.get());
-      PrintBetaServices(out.get());
-    }
-    out->Print("except ImportError:\n");
-    {
-      IndentScope raii_dict_except_indent(out.get());
-      out->Print("pass");
-    }
-  }
+  std::map<grpc::string, grpc::string> vars;
+  vars["PATH"] = file->package();
+  if (!file->package().empty()) { vars["PATH"].append("."); }
+  vars["ServiceName"] = service->name();
+  auto printer = file->CreatePrinter(&output);
+  GenerateStub(service, &*printer, &vars);
+  GenerateServicer(service, &*printer, &vars);
+  GenerateRegister(service, &*printer, &vars);
   return output;
 }
 
diff --git a/grpc/src/compiler/python_generator.h b/grpc/src/compiler/python_generator.h
index d92cb02..40d29aa 100644
--- a/grpc/src/compiler/python_generator.h
+++ b/grpc/src/compiler/python_generator.h
@@ -25,16 +25,8 @@
 
 namespace grpc_python_generator {
 
-// Data pertaining to configuration of the generator with respect to anything
-// that may be used internally at Google.
-struct GeneratorConfiguration {
-  grpc::string grpc_package_root;
-  // TODO(https://github.com/grpc/grpc/issues/8622): Drop this.
-  grpc::string beta_package_root;
-  // TODO(https://github.com/google/protobuf/issues/888): Drop this.
-  grpc::string import_prefix;
-};
-
+grpc::string Generate(grpc_generator::File *file,
+                      const grpc_generator::Service *service);
 }  // namespace grpc_python_generator
 
 #endif  // GRPC_INTERNAL_COMPILER_PYTHON_GENERATOR_H
diff --git a/grpc/src/compiler/python_private_generator.h b/grpc/src/compiler/python_private_generator.h
deleted file mode 100644
index 30ba0d7..0000000
--- a/grpc/src/compiler/python_private_generator.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_INTERNAL_COMPILER_PYTHON_PRIVATE_GENERATOR_H
-#define GRPC_INTERNAL_COMPILER_PYTHON_PRIVATE_GENERATOR_H
-
-#include <iostream>
-#include <vector>
-
-#include "src/compiler/python_generator.h"
-#include "src/compiler/schema_interface.h"
-
-namespace grpc_python_generator {
-
-// Tucks all generator state in an anonymous namespace away from
-// PythonGrpcGenerator and the header file, mostly to encourage future changes
-// to not require updates to the grpcio-tools C++ code part. Assumes that it is
-// only ever used from a single thread.
-struct PrivateGenerator {
-  const GeneratorConfiguration& config;
-  const grpc_generator::File* file;
-
-  PrivateGenerator(const GeneratorConfiguration& config,
-                   const grpc_generator::File* file);
-
-  grpc::string GetGrpcServices();
-
- private:
-  void PrintPreamble(grpc_generator::Printer* out);
-  void PrintBetaPreamble(grpc_generator::Printer* out);
-  void PrintGAServices(grpc_generator::Printer* out);
-  void PrintBetaServices(grpc_generator::Printer* out);
-
-  void PrintAddServicerToServer(
-      const grpc::string& package_qualified_service_name,
-      const grpc_generator::Service* service, grpc_generator::Printer* out);
-  void PrintServicer(const grpc_generator::Service* service,
-                     grpc_generator::Printer* out);
-  void PrintStub(const grpc::string& package_qualified_service_name,
-                 const grpc_generator::Service* service,
-                 grpc_generator::Printer* out);
-
-  void PrintBetaServicer(const grpc_generator::Service* service,
-                         grpc_generator::Printer* out);
-  void PrintBetaServerFactory(
-      const grpc::string& package_qualified_service_name,
-      const grpc_generator::Service* service, grpc_generator::Printer* out);
-  void PrintBetaStub(const grpc_generator::Service* service,
-                     grpc_generator::Printer* out);
-  void PrintBetaStubFactory(const grpc::string& package_qualified_service_name,
-                            const grpc_generator::Service* service,
-                            grpc_generator::Printer* out);
-};
-
-}  // namespace grpc_python_generator
-
-#endif  // GRPC_INTERNAL_COMPILER_PYTHON_PRIVATE_GENERATOR_H
diff --git a/grpc/src/compiler/schema_interface.h b/grpc/src/compiler/schema_interface.h
index c03ffe7..e42e3e3 100644
--- a/grpc/src/compiler/schema_interface.h
+++ b/grpc/src/compiler/schema_interface.h
@@ -19,11 +19,10 @@
 #ifndef GRPC_INTERNAL_COMPILER_SCHEMA_INTERFACE_H
 #define GRPC_INTERNAL_COMPILER_SCHEMA_INTERFACE_H
 
+#include <map>
 #include <memory>
 #include <vector>
 
-#include "src/compiler/config.h"
-
 #ifndef GRPC_CUSTOM_STRING
 #  include <string>
 #  define GRPC_CUSTOM_STRING std::string
@@ -93,6 +92,7 @@
   virtual void Print(const std::map<grpc::string, grpc::string> &vars,
                      const char *template_string) = 0;
   virtual void Print(const char *string) = 0;
+  virtual void SetIndentationSize(const size_t size) = 0;
   virtual void Indent() = 0;
   virtual void Outdent() = 0;
 };
@@ -107,11 +107,14 @@
   virtual grpc::string package() const = 0;
   virtual std::vector<grpc::string> package_parts() const = 0;
   virtual grpc::string additional_headers() const = 0;
+  virtual std::string message_header_ext() const = 0;
+  virtual std::string service_header_ext() const = 0;
 
   virtual int service_count() const = 0;
   virtual std::unique_ptr<const Service> service(int i) const = 0;
 
-  virtual std::unique_ptr<Printer> CreatePrinter(grpc::string *str) const = 0;
+  virtual std::unique_ptr<Printer> CreatePrinter(
+      grpc::string *str, const char indentation_type = ' ') const = 0;
 };
 }  // namespace grpc_generator
 
diff --git a/grpc/src/compiler/swift_generator.cc b/grpc/src/compiler/swift_generator.cc
index 95e8858..403a803 100644
--- a/grpc/src/compiler/swift_generator.cc
+++ b/grpc/src/compiler/swift_generator.cc
@@ -29,118 +29,208 @@
 
 namespace grpc_swift_generator {
 
-std::string WrapInNameSpace(const std::vector<std::string> &components, const grpc::string &name) {
+std::string WrapInNameSpace(const std::vector<std::string> &components,
+                            const grpc::string &name) {
   std::string qualified_name;
   for (auto it = components.begin(); it != components.end(); ++it)
     qualified_name += *it + "_";
   return qualified_name + name;
 }
 
-grpc::string GenerateMessage(const std::vector<std::string> &components, const grpc::string &name) {
+grpc::string GenerateMessage(const std::vector<std::string> &components,
+                             const grpc::string &name) {
   return "Message<" + WrapInNameSpace(components, name) + ">";
 }
 
 // MARK: - Client
 
-grpc::string GenerateClientFuncName(const grpc_generator::Method *method) {
+void GenerateClientFuncName(const grpc_generator::Method *method,
+                            grpc_generator::Printer *printer,
+                            std::map<grpc::string, grpc::string> *dictonary) {
+  auto vars = *dictonary;
   if (method->NoStreaming()) {
-    return "$GenAccess$ func $MethodName$(_ request: $Input$"
-           ", callOptions: CallOptions?$isNil$) -> UnaryCall<$Input$,$Output$>";
-  }
-
-  if (method->ClientStreaming()) {
-    return "$GenAccess$ func $MethodName$"
-           "(callOptions: CallOptions?$isNil$) -> "
-           "ClientStreamingCall<$Input$,$Output$>";
+    printer->Print(vars,
+                   "  $GenAccess$func $MethodName$(\n"
+                   "    _ request: $Input$\n"
+                   "    , callOptions: CallOptions?$isNil$\n"
+                   "  ) -> UnaryCall<$Input$, $Output$>");
+    return;
   }
 
   if (method->ServerStreaming()) {
-    return "$GenAccess$ func $MethodName$(_ request: $Input$"
-           ", callOptions: CallOptions?$isNil$, handler: @escaping ($Output$"
-           ") -> Void) -> ServerStreamingCall<$Input$, $Output$>";
+    printer->Print(vars,
+                   "  $GenAccess$func $MethodName$(\n"
+                   "    _ request: $Input$\n"
+                   "    , callOptions: CallOptions?$isNil$,\n"
+                   "    handler: @escaping ($Output$) -> Void\n"
+                   "  ) -> ServerStreamingCall<$Input$, $Output$>");
+    return;
   }
-  return "$GenAccess$ func $MethodName$"
-         "(callOptions: CallOptions?$isNil$, handler: @escaping ($Output$"
-         ") -> Void) -> BidirectionalStreamingCall<$Input$, $Output$>";
+
+  if (method->ClientStreaming()) {
+    printer->Print(vars,
+                   "  $GenAccess$func $MethodName$(\n"
+                   "    callOptions: CallOptions?$isNil$\n"
+                   "  ) -> ClientStreamingCall<$Input$, $Output$>");
+    return;
+  }
+
+  printer->Print(vars,
+                 "  $GenAccess$func $MethodName$(\n"
+                 "    callOptions: CallOptions?$isNil$,\n"
+                 "    handler: @escaping ($Output$ ) -> Void\n"
+                 "  ) -> BidirectionalStreamingCall<$Input$, $Output$>");
 }
 
-grpc::string GenerateClientFuncBody(const grpc_generator::Method *method) {
+void GenerateClientFuncBody(const grpc_generator::Method *method,
+                            grpc_generator::Printer *printer,
+                            std::map<grpc::string, grpc::string> *dictonary) {
+  auto vars = *dictonary;
+  vars["Interceptor"] =
+      "interceptors: self.interceptors?.make$MethodName$Interceptors() ?? []";
   if (method->NoStreaming()) {
-    return "return self.makeUnaryCall(path: "
-           "\"/$PATH$$ServiceName$/$MethodName$\", request: request, "
-           "callOptions: callOptions ?? self.defaultCallOptions)";
-  }
-
-  if (method->ClientStreaming()) {
-    return "return self.makeClientStreamingCall(path: "
-           "\"/$PATH$$ServiceName$/$MethodName$\", callOptions: callOptions ?? "
-           "self.defaultCallOptions)";
+    printer->Print(
+        vars,
+        "    return self.makeUnaryCall(\n"
+        "      path: \"/$PATH$$ServiceName$/$MethodName$\",\n"
+        "      request: request,\n"
+        "      callOptions: callOptions ?? self.defaultCallOptions,\n"
+        "      $Interceptor$\n"
+        "    )\n");
+    return;
   }
 
   if (method->ServerStreaming()) {
-    return "return self.makeServerStreamingCall(path: "
-           "\"/$PATH$$ServiceName$/$MethodName$\", request: request, "
-           "callOptions: callOptions ?? self.defaultCallOptions, handler: "
-           "handler)";
+    printer->Print(
+        vars,
+        "    return self.makeServerStreamingCall(\n"
+        "      path: \"/$PATH$$ServiceName$/$MethodName$\",\n"
+        "      request: request,\n"
+        "      callOptions: callOptions ?? self.defaultCallOptions,\n"
+        "      $Interceptor$,\n"
+        "      handler: handler\n"
+        "    )\n");
+    return;
   }
-  return "return self.makeBidirectionalStreamingCall(path: "
-         "\"/$PATH$$ServiceName$/$MethodName$\", callOptions: callOptions ?? "
-         "self.defaultCallOptions, handler: handler)";
+
+  if (method->ClientStreaming()) {
+    printer->Print(
+        vars,
+        "    return self.makeClientStreamingCall(\n"
+        "      path: \"/$PATH$$ServiceName$/$MethodName$\",\n"
+        "      callOptions: callOptions ?? self.defaultCallOptions,\n"
+        "      $Interceptor$\n"
+        "    )\n");
+    return;
+  }
+  printer->Print(vars,
+                 "    return self.makeBidirectionalStreamingCall(\n"
+                 "      path: \"/$PATH$$ServiceName$/$MethodName$\",\n"
+                 "      callOptions: callOptions ?? self.defaultCallOptions,\n"
+                 "      $Interceptor$,\n"
+                 "      handler: handler\n"
+                 "    )\n");
 }
 
 void GenerateClientProtocol(const grpc_generator::Service *service,
                             grpc_generator::Printer *printer,
                             std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
-  printer->Print(vars, "$ACCESS$ protocol $ServiceQualifiedName$Service {\n");
+  printer->Print(
+      vars,
+      "$ACCESS$ protocol $ServiceQualifiedName$ClientProtocol: GRPCClient {");
+  printer->Print("\n\n");
+  printer->Print("  var serviceName: String { get }");
+  printer->Print("\n\n");
+  printer->Print(
+      vars,
+      "  var interceptors: "
+      "$ServiceQualifiedName$ClientInterceptorFactoryProtocol? { get }");
+  printer->Print("\n\n");
+
   vars["GenAccess"] = "";
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
-    vars["Input"] = GenerateMessage(method->get_input_namespace_parts(), method->get_input_type_name());
-    vars["Output"] = GenerateMessage(method->get_output_namespace_parts(), method->get_output_type_name());
+    vars["Input"] = GenerateMessage(method->get_input_namespace_parts(),
+                                    method->get_input_type_name());
+    vars["Output"] = GenerateMessage(method->get_output_namespace_parts(),
+                                     method->get_output_type_name());
     vars["MethodName"] = method->name();
     vars["isNil"] = "";
-    printer->Print("  ");
-    auto func = GenerateClientFuncName(method.get());
-    printer->Print(vars, func.c_str());
+    GenerateClientFuncName(method.get(), &*printer, &vars);
+    printer->Print("\n\n");
+  }
+  printer->Print("}\n\n");
+
+  printer->Print(vars, "extension $ServiceQualifiedName$ClientProtocol {");
+  printer->Print("\n\n");
+  printer->Print(vars,
+                 "  $ACCESS$ var serviceName: String { "
+                 "\"$PATH$$ServiceName$\" }\n");
+
+  vars["GenAccess"] = service->is_internal() ? "internal " : "public ";
+  for (auto it = 0; it < service->method_count(); it++) {
+    auto method = service->method(it);
+    vars["Input"] = GenerateMessage(method->get_input_namespace_parts(),
+                                    method->get_input_type_name());
+    vars["Output"] = GenerateMessage(method->get_output_namespace_parts(),
+                                     method->get_output_type_name());
+    vars["MethodName"] = method->name();
+    vars["isNil"] = " = nil";
     printer->Print("\n");
+    GenerateClientFuncName(method.get(), &*printer, &vars);
+    printer->Print(" {\n");
+    GenerateClientFuncBody(method.get(), &*printer, &vars);
+    printer->Print("  }\n");
+  }
+  printer->Print("}\n\n");
+
+  printer->Print(vars,
+                 "$ACCESS$ protocol "
+                 "$ServiceQualifiedName$ClientInterceptorFactoryProtocol {\n");
+
+  for (auto it = 0; it < service->method_count(); it++) {
+    auto method = service->method(it);
+    vars["Input"] = GenerateMessage(method->get_input_namespace_parts(),
+                                    method->get_input_type_name());
+    vars["Output"] = GenerateMessage(method->get_output_namespace_parts(),
+                                     method->get_output_type_name());
+    vars["MethodName"] = method->name();
+    printer->Print(
+        vars,
+        "  /// - Returns: Interceptors to use when invoking '$MethodName$'.\n");
+    printer->Print(vars,
+                   "  func make$MethodName$Interceptors() -> "
+                   "[ClientInterceptor<$Input$, $Output$>]\n\n");
   }
   printer->Print("}\n\n");
 }
 
-void GenerateClientClass(const grpc_generator::Service *service,
-                         grpc_generator::Printer *printer,
+void GenerateClientClass(grpc_generator::Printer *printer,
                          std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   printer->Print(vars,
-                 "$ACCESS$ final class $ServiceQualifiedName$ServiceClient: GRPCClient, "
-                 "$ServiceQualifiedName$Service {\n");
+                 "$ACCESS$ final class $ServiceQualifiedName$ServiceClient: "
+                 "$ServiceQualifiedName$ClientProtocol {\n");
   printer->Print(vars, "  $ACCESS$ let channel: GRPCChannel\n");
   printer->Print(vars, "  $ACCESS$ var defaultCallOptions: CallOptions\n");
-  printer->Print("\n");
   printer->Print(vars,
-                 "  $ACCESS$ init(channel: GRPCChannel, "
-                 "defaultCallOptions: CallOptions = CallOptions()) {\n");
+                 "  $ACCESS$ var interceptors: "
+                 "$ServiceQualifiedName$ClientInterceptorFactoryProtocol?\n");
+  printer->Print("\n");
+  printer->Print(
+      vars,
+      "  $ACCESS$ init(\n"
+      "    channel: GRPCChannel,\n"
+      "    defaultCallOptions: CallOptions = CallOptions(),\n"
+      "    interceptors: "
+      "$ServiceQualifiedName$ClientInterceptorFactoryProtocol? = nil\n"
+      "  ) {\n");
   printer->Print("    self.channel = channel\n");
   printer->Print("    self.defaultCallOptions = defaultCallOptions\n");
+  printer->Print("    self.interceptors = interceptors\n");
   printer->Print("  }");
   printer->Print("\n");
-  vars["GenAccess"] = service->is_internal() ? "internal" : "public";
-  for (auto it = 0; it < service->method_count(); it++) {
-    auto method = service->method(it);
-    vars["Input"] = GenerateMessage(method->get_input_namespace_parts(), method->get_input_type_name());
-    vars["Output"] = GenerateMessage(method->get_output_namespace_parts(), method->get_output_type_name());
-    vars["MethodName"] = method->name();
-    vars["isNil"] = " = nil";
-    printer->Print("\n  ");
-    auto func = GenerateClientFuncName(method.get());
-    printer->Print(vars, func.c_str());
-    printer->Print(" {\n");
-    auto body = GenerateClientFuncBody(method.get());
-    printer->Print("    ");
-    printer->Print(vars, body.c_str());
-    printer->Print("\n  }\n");
-  }
   printer->Print("}\n");
 }
 
@@ -148,7 +238,7 @@
 
 grpc::string GenerateServerFuncName(const grpc_generator::Method *method) {
   if (method->NoStreaming()) {
-    return "func $MethodName$(_ request: $Input$"
+    return "func $MethodName$(request: $Input$"
            ", context: StatusOnlyCallContext) -> EventLoopFuture<$Output$>";
   }
 
@@ -169,43 +259,44 @@
 
 grpc::string GenerateServerExtensionBody(const grpc_generator::Method *method) {
   grpc::string start = "    case \"$MethodName$\":\n    ";
+  grpc::string interceptors =
+      "      interceptors: self.interceptors?.make$MethodName$Interceptors() "
+      "?? [],\n";
   if (method->NoStreaming()) {
     return start +
-           "return CallHandlerFactory.makeUnary(callHandlerContext: callHandlerContext) { "
-           "context in"
-           "\n      "
-           "return { request in"
-           "\n        "
-           "self.$MethodName$(request, context: context)"
-           "\n      }"
-           "\n    }";
-  }
-  if (method->ClientStreaming()) {
-    return start +
-           "return CallHandlerFactory.makeClientStreaming(callHandlerContext: "
-           "callHandlerContext) { context in"
-           "\n      "
-           "self.$MethodName$(context: context)"
-           "\n    }";
+           "return UnaryServerHandler(\n"
+           "      context: context,\n"
+           "      requestDeserializer: GRPCPayloadDeserializer<$Input$>(),\n"
+           "      responseSerializer: GRPCPayloadSerializer<$Output$>(),\n" +
+           interceptors +
+           "      userFunction: self.$MethodName$(request:context:))\n";
   }
   if (method->ServerStreaming()) {
     return start +
-           "return CallHandlerFactory.makeServerStreaming(callHandlerContext: "
-           "callHandlerContext) { context in"
-           "\n      "
-           "return { request in"
-           "\n        "
-           "self.$MethodName$(request: request, context: context)"
-           "\n      }"
-           "\n    }";
+           "return ServerStreamingServerHandler(\n"
+           "      context: context,\n"
+           "      requestDeserializer: GRPCPayloadDeserializer<$Input$>(),\n"
+           "      responseSerializer: GRPCPayloadSerializer<$Output$>(),\n" +
+           interceptors +
+           "      userFunction: self.$MethodName$(request:context:))\n";
+  }
+  if (method->ClientStreaming()) {
+    return start +
+           "return ClientStreamingServerHandler(\n"
+           "      context: context,\n"
+           "      requestDeserializer: GRPCPayloadDeserializer<$Input$>(),\n"
+           "      responseSerializer: GRPCPayloadSerializer<$Output$>(),\n" +
+           interceptors +
+           "      observerFactory: self.$MethodName$(context:))\n";
   }
   if (method->BidiStreaming()) {
     return start +
-           "return CallHandlerFactory.makeBidirectionalStreaming(callHandlerContext: "
-           "callHandlerContext) { context in"
-           "\n      "
-           "self.$MethodName$(context: context)"
-           "\n    }";
+           "return BidirectionalStreamingServerHandler(\n"
+           "      context: context,\n"
+           "      requestDeserializer: GRPCPayloadDeserializer<$Input$>(),\n"
+           "      responseSerializer: GRPCPayloadSerializer<$Output$>(),\n" +
+           interceptors +
+           "      observerFactory: self.$MethodName$(context:))\n";
   }
   return "";
 }
@@ -214,12 +305,19 @@
                             grpc_generator::Printer *printer,
                             std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
+  printer->Print(vars,
+                 "$ACCESS$ protocol $ServiceQualifiedName$Provider: "
+                 "CallHandlerProvider {\n");
   printer->Print(
-      vars, "$ACCESS$ protocol $ServiceQualifiedName$Provider: CallHandlerProvider {\n");
+      vars,
+      "  var interceptors: "
+      "$ServiceQualifiedName$ServerInterceptorFactoryProtocol? { get }\n");
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
-    vars["Input"] = GenerateMessage(method->get_input_namespace_parts(), method->get_input_type_name());
-    vars["Output"] = GenerateMessage(method->get_output_namespace_parts(), method->get_output_type_name());
+    vars["Input"] = GenerateMessage(method->get_input_namespace_parts(),
+                                    method->get_input_type_name());
+    vars["Output"] = GenerateMessage(method->get_output_namespace_parts(),
+                                     method->get_output_type_name());
     vars["MethodName"] = method->name();
     printer->Print("  ");
     auto func = GenerateServerFuncName(method.get());
@@ -235,13 +333,15 @@
                  "\"$PATH$$ServiceName$\" }\n");
   printer->Print("\n");
   printer->Print(
-      "  func handleMethod(_ methodName: Substring, callHandlerContext: "
-      "CallHandlerContext) -> GRPCCallHandler? {\n");
-  printer->Print("    switch methodName {\n");
+      "  func handle(method name: Substring, context: "
+      "CallHandlerContext) -> GRPCServerHandlerProtocol? {\n");
+  printer->Print("    switch name {\n");
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
-    vars["Input"] = GenerateMessage(method->get_input_namespace_parts(), method->get_input_type_name());
-    vars["Output"] = GenerateMessage(method->get_output_namespace_parts(), method->get_output_type_name());
+    vars["Input"] = GenerateMessage(method->get_input_namespace_parts(),
+                                    method->get_input_type_name());
+    vars["Output"] = GenerateMessage(method->get_output_namespace_parts(),
+                                     method->get_output_type_name());
     vars["MethodName"] = method->name();
     auto body = GenerateServerExtensionBody(method.get());
     printer->Print(vars, body.c_str());
@@ -250,6 +350,26 @@
   printer->Print("    default: return nil;\n");
   printer->Print("    }\n");
   printer->Print("  }\n\n");
+  printer->Print("}\n\n");
+
+  printer->Print(vars,
+                 "$ACCESS$ protocol "
+                 "$ServiceQualifiedName$ServerInterceptorFactoryProtocol {\n");
+  for (auto it = 0; it < service->method_count(); it++) {
+    auto method = service->method(it);
+    vars["Input"] = GenerateMessage(method->get_input_namespace_parts(),
+                                    method->get_input_type_name());
+    vars["Output"] = GenerateMessage(method->get_output_namespace_parts(),
+                                     method->get_output_type_name());
+    vars["MethodName"] = method->name();
+    printer->Print(
+        vars,
+        "  /// - Returns: Interceptors to use when handling '$MethodName$'.\n"
+        "  ///   Defaults to calling `self.makeInterceptors()`.\n");
+    printer->Print(vars,
+                   "  func make$MethodName$Interceptors() -> "
+                   "[ServerInterceptor<$Input$, $Output$>]\n\n");
+  }
   printer->Print("}");
 }
 
@@ -259,15 +379,17 @@
   std::map<grpc::string, grpc::string> vars;
   vars["PATH"] = file->package();
   if (!file->package().empty()) { vars["PATH"].append("."); }
-  vars["ServiceQualifiedName"] = WrapInNameSpace(service->namespace_parts(), service->name());
+  vars["ServiceQualifiedName"] =
+      WrapInNameSpace(service->namespace_parts(), service->name());
   vars["ServiceName"] = service->name();
   vars["ACCESS"] = service->is_internal() ? "internal" : "public";
   auto printer = file->CreatePrinter(&output);
-  printer->Print(vars,
-                 "/// Usage: instantiate $ServiceQualifiedName$ServiceClient, then call "
-                 "methods of this protocol to make API calls.\n");
+  printer->Print(
+      vars,
+      "/// Usage: instantiate $ServiceQualifiedName$ServiceClient, then call "
+      "methods of this protocol to make API calls.\n");
   GenerateClientProtocol(service, &*printer, &vars);
-  GenerateClientClass(service, &*printer, &vars);
+  GenerateClientClass(&*printer, &vars);
   printer->Print("\n");
   GenerateServerProtocol(service, &*printer, &vars);
   return output;
diff --git a/grpc/src/compiler/swift_generator.h b/grpc/src/compiler/swift_generator.h
index 1639cb0..2a226fa 100644
--- a/grpc/src/compiler/swift_generator.h
+++ b/grpc/src/compiler/swift_generator.h
@@ -1,40 +1,22 @@
 /*
+ * Copyright 2020 Google Inc. All rights reserved.
  *
- * Copyright 2020, Google Inc.
- * All rights reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
 #include <memory>
 #include <vector>
 
-#include "src/compiler/config.h"
 #include "src/compiler/schema_interface.h"
 
 #ifndef GRPC_CUSTOM_STRING
diff --git a/grpc/src/compiler/ts_generator.cc b/grpc/src/compiler/ts_generator.cc
index fe9731d..3c3daf0 100644
--- a/grpc/src/compiler/ts_generator.cc
+++ b/grpc/src/compiler/ts_generator.cc
@@ -21,31 +21,84 @@
  * be maintained according to the Swift-grpc repository
  */
 
+#include "src/compiler/ts_generator.h"
+
 #include <map>
 #include <sstream>
 
 #include "flatbuffers/util.h"
 #include "src/compiler/schema_interface.h"
-#include "src/compiler/ts_generator.h"
 
 namespace grpc_ts_generator {
 
+grpc::string GenerateNamespace(const std::vector<std::string> ns,
+                               const std::string filename,
+                               const bool include_separator) {
+  grpc::string path = "";
+  if (include_separator) path += ".";
+
+  for (auto it = ns.begin(); it < ns.end(); it++) {
+    if (include_separator) path += "/";
+    path += include_separator
+                ? flatbuffers::ConvertCase(*it, flatbuffers::Case::kDasher,
+                                           flatbuffers::Case::kUpperCamel)
+                : *it + "_";
+  }
+
+  if (include_separator) path += "/";
+  path += include_separator
+              ? flatbuffers::ConvertCase(filename, flatbuffers::Case::kDasher,
+                                         flatbuffers::Case::kUpperCamel)
+              : filename;
+  return path;
+}
+
 // MARK: - Shared code
 
-void GenerateImports(grpc_generator::Printer *printer,
+void GenerateImports(const grpc_generator::Service *service,
+                     grpc_generator::Printer *printer,
                      std::map<grpc::string, grpc::string> *dictonary,
                      const bool grpc_var_import) {
   auto vars = *dictonary;
   printer->Print(
       "// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***\n");
-  printer->Print("import { flatbuffers } from 'flatbuffers';\n");
-  printer->Print(vars,
-                 "import *  as $FBSFile$ from './$Filename$_generated';\n");
+  printer->Print("import * as flatbuffers from 'flatbuffers';\n");
+
+  std::set<grpc::string> generated_imports;
+
+  for (auto it = 0; it < service->method_count(); it++) {
+    auto method = service->method(it);
+    auto output = method->get_output_type_name();
+    auto input = method->get_input_type_name();
+    auto input_namespace = method->get_input_namespace_parts();
+
+    vars["OUTPUT"] = output;
+    vars["INPUT"] = input;
+
+    if (generated_imports.find(output) == generated_imports.end()) {
+      generated_imports.insert(output);
+      vars["OUTPUT_DIR"] =
+          GenerateNamespace(method->get_output_namespace_parts(), output, true);
+      vars["Output_alias"] = GenerateNamespace(
+          method->get_output_namespace_parts(), output, false);
+      printer->Print(
+          vars, "import { $OUTPUT$ as $Output_alias$ } from '$OUTPUT_DIR$';\n");
+    }
+    if (generated_imports.find(input) == generated_imports.end()) {
+      generated_imports.insert(input);
+      vars["INPUT_DIR"] =
+          GenerateNamespace(method->get_output_namespace_parts(), input, true);
+      vars["Input_alias"] =
+          GenerateNamespace(method->get_output_namespace_parts(), input, false);
+      printer->Print(
+          vars, "import { $INPUT$ as $Input_alias$ } from '$INPUT_DIR$';\n");
+    }
+  }
   printer->Print("\n");
   if (grpc_var_import)
-    printer->Print("var grpc = require('grpc');\n");
+    printer->Print("var grpc = require('@grpc/grpc-js');\n");
   else
-    printer->Print("import * as grpc from 'grpc';\n");
+    printer->Print("import * as grpc from '@grpc/grpc-js';\n");
   printer->Print("\n");
 }
 
@@ -68,13 +121,13 @@
   auto vars = *dictonary;
   printer->Print(vars, "function serialize_$Type$(buffer_args) {\n");
   printer->Indent();
-  printer->Print(vars, "if (!(buffer_args instanceof $FBSFile$.$Type$)) {\n");
+  printer->Print(vars, "if (!(buffer_args instanceof $Type$)) {\n");
   printer->Indent();
-  printer->Print(
-      vars, "throw new Error('Expected argument of type $FBSFile$.$Type$');\n");
+  printer->Print(vars,
+                 "throw new Error('Expected argument of type $VALUE$');\n");
   printer->Outdent();
   printer->Print("}\n");
-  printer->Print(vars, "return buffer_args.serialize();\n");
+  printer->Print(vars, "return Buffer.from(buffer_args.serialize());\n");
   printer->Outdent();
   printer->Print("}\n\n");
 }
@@ -86,7 +139,7 @@
   printer->Print(vars, "function deserialize_$Type$(buffer) {\n");
   printer->Indent();
   printer->Print(vars,
-                 "return $FBSFile$.$Type$.getRootAs$Type$(new "
+                 "return $Type$.getRootAs$VALUE$(new "
                  "flatbuffers.ByteBuffer(buffer))\n");
   printer->Outdent();
   printer->Print("}\n\n");
@@ -106,14 +159,18 @@
 
     if (generated_functions.find(output) == generated_functions.end()) {
       generated_functions.insert(output);
-      vars["Type"] = output;
+      vars["VALUE"] = output;
+      vars["Type"] = GenerateNamespace(method->get_output_namespace_parts(),
+                                       output, false);
       GenerateSerializeMethod(printer, &vars);
       GenerateDeserializeMethod(printer, &vars);
     }
     printer->Print("\n");
     if (generated_functions.find(input) == generated_functions.end()) {
       generated_functions.insert(input);
-      vars["Type"] = input;
+      vars["VALUE"] = input;
+      vars["Type"] =
+          GenerateNamespace(method->get_input_namespace_parts(), input, false);
       GenerateSerializeMethod(printer, &vars);
       GenerateDeserializeMethod(printer, &vars);
     }
@@ -131,18 +188,20 @@
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     vars["MethodName"] = method->name();
-    vars["Output"] = method->get_output_type_name();
-    vars["Input"] = method->get_input_type_name();
+    vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
+                                       method->get_output_type_name(), false);
+    vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
+                                      method->get_input_type_name(), false);
     printer->Print(vars, "$MethodName$: {\n");
     printer->Indent();
     printer->Print(vars, "path: '/$PATH$$ServiceName$/$MethodName$',\n");
     GetStreamType(printer, &*method, &vars);
     printer->Print(vars, "requestType: flatbuffers.ByteBuffer,\n");
-    printer->Print(vars, "responseType: $FBSFile$.$Output$,\n");
-    printer->Print(vars, "requestSerialize: serialize_$Input$,\n");
-    printer->Print(vars, "requestDeserialize: deserialize_$Input$,\n");
-    printer->Print(vars, "responseSerialize: serialize_$Output$,\n");
-    printer->Print(vars, "responseDeserialize: deserialize_$Output$,\n");
+    printer->Print(vars, "responseType: $OUTPUT$,\n");
+    printer->Print(vars, "requestSerialize: serialize_$INPUT$,\n");
+    printer->Print(vars, "requestDeserialize: deserialize_$INPUT$,\n");
+    printer->Print(vars, "responseSerialize: serialize_$OUTPUT$,\n");
+    printer->Print(vars, "responseDeserialize: deserialize_$OUTPUT$,\n");
     printer->Outdent();
     printer->Print("},\n");
   }
@@ -168,7 +227,7 @@
   vars["Filename"] = filename;
   auto printer = file->CreatePrinter(&output);
 
-  GenerateImports(&*printer, &vars, true);
+  GenerateImports(service, &*printer, &vars, true);
   GenerateMethods(service, &*printer, &vars);
   GenerateService(service, &*printer, &vars);
   return output;
@@ -179,22 +238,17 @@
 void FillInterface(grpc_generator::Printer *printer,
                    std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
-  printer->Print(
-      vars,
-      "interface I$ServiceName$Service_I$MethodName$ extends "
-      "grpc.MethodDefinition<$FBSFile$.$INPUT$, $FBSFile$.$OUTPUT$> {\n");
+  printer->Print(vars,
+                 "interface I$ServiceName$Service_I$MethodName$ extends "
+                 "grpc.MethodDefinition<$INPUT$, $OUTPUT$> {\n");
   printer->Indent();
   printer->Print(vars, "path: string; // /$PATH$$ServiceName$/$MethodName$\n");
   printer->Print(vars, "requestStream: boolean; // $ClientStreaming$\n");
   printer->Print(vars, "responseStream: boolean; // $ServerStreaming$\n");
-  printer->Print(vars,
-                 "requestSerialize: grpc.serialize<$FBSFile$.$INPUT$>;\n");
-  printer->Print(vars,
-                 "requestDeserialize: grpc.deserialize<$FBSFile$.$INPUT$>;\n");
-  printer->Print(vars,
-                 "responseSerialize: grpc.serialize<$FBSFile$.$OUTPUT$>;\n");
-  printer->Print(
-      vars, "responseDeserialize: grpc.deserialize<$FBSFile$.$OUTPUT$>;\n");
+  printer->Print(vars, "requestSerialize: grpc.serialize<$INPUT$>;\n");
+  printer->Print(vars, "requestDeserialize: grpc.deserialize<$INPUT$>;\n");
+  printer->Print(vars, "responseSerialize: grpc.serialize<$OUTPUT$>;\n");
+  printer->Print(vars, "responseDeserialize: grpc.deserialize<$OUTPUT$>;\n");
   printer->Outdent();
   printer->Print("}\n");
 }
@@ -212,8 +266,10 @@
     vars["ClientStreaming"] = client_streaming ? "true" : "false";
     vars["ServerStreaming"] = server_streaming ? "true" : "false";
     vars["MethodName"] = method->name();
-    vars["INPUT"] = method->get_input_type_name();
-    vars["OUTPUT"] = method->get_output_type_name();
+    vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
+                                       method->get_output_type_name(), false);
+    vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
+                                      method->get_input_type_name(), false);
     FillInterface(printer, &vars);
     printer->Print("\n");
   }
@@ -223,37 +279,39 @@
     const grpc_generator::Service *service, grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
-  printer->Print(vars, "export interface I$ServiceName$Server {\n");
+  printer->Print(vars,
+                 "export interface I$ServiceName$Server extends "
+                 "grpc.UntypedServiceImplementation {\n");
   printer->Indent();
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     vars["Name"] = method->name();
-    vars["INPUT"] = method->get_input_type_name();
-    vars["OUTPUT"] = method->get_output_type_name();
+    vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
+                                       method->get_output_type_name(), false);
+    vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
+                                      method->get_input_type_name(), false);
     if (method->BidiStreaming()) {
       printer->Print(vars,
-                     "$Name$: grpc.handleBidiStreamingCall<$FBSFile$.$INPUT$, "
-                     "$FBSFile$.$OUTPUT$>;\n");
+                     "$Name$: grpc.handleBidiStreamingCall<$INPUT$, "
+                     "$OUTPUT$>;\n");
       continue;
     }
     if (method->NoStreaming()) {
       printer->Print(vars,
-                     "$Name$: grpc.handleUnaryCall<$FBSFile$.$INPUT$, "
-                     "$FBSFile$.$OUTPUT$>;\n");
+                     "$Name$: grpc.handleUnaryCall<$INPUT$, "
+                     "$OUTPUT$>;\n");
       continue;
     }
     if (method->ClientStreaming()) {
-      printer->Print(
-          vars,
-          "$Name$: grpc.handleClientStreamingCall<$FBSFile$.$INPUT$, "
-          "$FBSFile$.$OUTPUT$>;\n");
+      printer->Print(vars,
+                     "$Name$: grpc.handleClientStreamingCall<$INPUT$, "
+                     "$OUTPUT$>;\n");
       continue;
     }
     if (method->ServerStreaming()) {
-      printer->Print(
-          vars,
-          "$Name$: grpc.handleServerStreamingCall<$FBSFile$.$INPUT$, "
-          "$FBSFile$.$OUTPUT$>;\n");
+      printer->Print(vars,
+                     "$Name$: grpc.handleServerStreamingCall<$INPUT$, "
+                     "$OUTPUT$>;\n");
       continue;
     }
   }
@@ -294,10 +352,10 @@
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
-  grpc::string main = "$ISPUBLIC$$MethodName$(request: $FBSFile$.$INPUT$, ";
+  grpc::string main = "$ISPUBLIC$$MethodName$(request: $INPUT$, ";
   grpc::string callback =
       "callback: (error: grpc.ServiceError | null, response: "
-      "$FBSFile$.$OUTPUT$) => void): grpc.ClientUnaryCall;\n";
+      "$OUTPUT$) => void): grpc.ClientUnaryCall;\n";
   auto meta_data = GenerateMetaData() + ", ";
   auto options = GenerateOptions() + ", ";
   printer->Print(vars, (main + callback).c_str());
@@ -312,8 +370,8 @@
   grpc::string main = "$ISPUBLIC$$MethodName$(";
   grpc::string callback =
       "callback: (error: grpc.ServiceError | null, response: "
-      "$FBSFile$.$INPUT$) => void): "
-      "grpc.ClientWritableStream<$FBSFile$.$OUTPUT$>;\n";
+      "$INPUT$) => void): "
+      "grpc.ClientWritableStream<$OUTPUT$>;\n";
   auto meta_data = GenerateMetaData() + ", ";
   auto options = GenerateOptions() + ", ";
   printer->Print(vars, (main + callback).c_str());
@@ -326,9 +384,8 @@
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
-  grpc::string main = "$ISPUBLIC$$MethodName$(request: $FBSFile$.$INPUT$, ";
-  grpc::string end_function =
-      "): grpc.ClientReadableStream<$FBSFile$.$OUTPUT$>;\n";
+  grpc::string main = "$ISPUBLIC$$MethodName$(request: $INPUT$, ";
+  grpc::string end_function = "): grpc.ClientReadableStream<$OUTPUT$>;\n";
   auto meta_data = GenerateMetaData();
   auto options = GenerateOptions();
   printer->Print(vars, (main + meta_data + end_function).c_str());
@@ -341,7 +398,7 @@
   auto vars = *dictonary;
   grpc::string main = "$ISPUBLIC$$MethodName$(";
   grpc::string end_function =
-      "): grpc.ClientDuplexStream<$FBSFile$.$INPUT$, $FBSFile$.$OUTPUT$>;\n";
+      "): grpc.ClientDuplexStream<$INPUT$, $OUTPUT$>;\n";
   auto meta_data = GenerateMetaData();
   auto options = GenerateOptions();
   printer->Print(vars, (main + end_function).c_str());
@@ -360,8 +417,10 @@
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     vars["MethodName"] = method->name();
-    vars["INPUT"] = method->get_input_type_name();
-    vars["OUTPUT"] = method->get_output_type_name();
+    vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
+                                       method->get_output_type_name(), false);
+    vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
+                                      method->get_input_type_name(), false);
     vars["ISPUBLIC"] = "";
 
     if (method->NoStreaming()) {
@@ -397,12 +456,14 @@
   printer->Indent();
   printer->Print(
       "constructor(address: string, credentials: grpc.ChannelCredentials, "
-      "options?: object);");
+      "options?: object);\n");
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     vars["MethodName"] = method->name();
-    vars["INPUT"] = method->get_input_type_name();
-    vars["OUTPUT"] = method->get_output_type_name();
+    vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
+                                       method->get_output_type_name(), false);
+    vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
+                                      method->get_input_type_name(), false);
     vars["ISPUBLIC"] = "public ";
     if (method->NoStreaming()) {
       GenerateUnaryClientInterface(printer, &vars);
@@ -444,7 +505,7 @@
   vars["Filename"] = filename;
   auto printer = file->CreatePrinter(&output);
 
-  GenerateImports(&*printer, &vars, false);
+  GenerateImports(service, &*printer, &vars, false);
   GenerateMainInterface(service, &*printer, &vars);
   printer->Print("\n");
   GenerateClientInterface(service, &*printer, &vars);
diff --git a/grpc/src/compiler/ts_generator.h b/grpc/src/compiler/ts_generator.h
index a33bb3c..a356659 100644
--- a/grpc/src/compiler/ts_generator.h
+++ b/grpc/src/compiler/ts_generator.h
@@ -1,41 +1,7 @@
-/*
- *
- * Copyright 2020, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
 #include <memory>
-#include <vector>
 #include <set>
+#include <vector>
 
-#include "src/compiler/config.h"
 #include "src/compiler/schema_interface.h"
 
 #ifndef GRPC_CUSTOM_STRING
@@ -58,4 +24,3 @@
                                const grpc_generator::Service *service,
                                const grpc::string &filename);
 }  // namespace grpc_ts_generator
-