`super::bool` not found in `super`

[pronebird]

Bug Report

Version

│   │   ├── tonic v0.14.1
│   ├── tonic v0.14.1 (*)
│   ├── tonic-prost v0.14.1
│   │   └── tonic v0.14.1 (*)
│   └── tonic-prost-build v0.14.1
│       └── tonic-build v0.14.1
├── tonic v0.14.1 (*)

Platform

Darwin foxmulder.local 23.6.0 Darwin Kernel Version 23.6.0: Thu Dec 19 20:47:53 PST 2024; root:xnu-10063.141.1.703.2~1/RELEASE_ARM64_T6030 arm64

Description

pub mod proto { 
  tonic::include_proto!("myproto") 
}

Lotta compilation errors related to referencing boolean types via super::bool which errors until I add use std::primitive::bool into the mod

[LucioFranco]

If possible can you provide a minimal reproducer for this with the config items you have set. That would make this easier to debug, thanks.

[pronebird]

Maybe pull nymtech/nym-vpn-client@289acb8 and try cargo build -p nym-vpn-proto. See what tonic::include_proto! expands to. To me it looked like all bool were prefixed with super::

[LucioFranco]

I am not able to pull your project down, I would recommend if you're having this issue to produce a minimal reproducer that is easier to debug.

[zhaohaiyun9]

@LucioFranco Hello! I encounter this problem too. It's simple to reproduce it. In the examples/proto/helloworld/helloworld.proto, add a method using google well known wrapper types:

import "google/protobuf/wrappers.proto";

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}

  rpc Echo (google.protobuf.BoolValue) returns (google.protobuf.BoolValue) {}
}

In the generated rust code, google.protobuf.BoolValue is converted to "super::bool".

I think the fix is in tonic-prost-build/src/lib.rs, as follows:

diff --git a/tonic-prost-build/src/lib.rs b/tonic-prost-build/src/lib.rs
index 3fcc9ac..448f2ef 100644
--- a/tonic-prost-build/src/lib.rs
+++ b/tonic-prost-build/src/lib.rs
@@ -107,9 +107,6 @@ pub fn compile_fds(fds: prost_types::FileDescriptorSet) -> io::Result<()> {
     self::configure().compile_fds(fds)
 }
 
-/// Non-path Rust types allowed for request/response types.
-const NON_PATH_TYPE_ALLOWLIST: &[&str] = &["()"];
-
 /// Newtype wrapper for prost to add tonic-specific extensions
 struct TonicBuildService {
     prost_service: Service,
@@ -192,18 +189,25 @@ impl tonic_build::Method for TonicBuildMethod {
         proto_path: &str,
         compile_well_known_types: bool,
     ) -> (TokenStream, TokenStream) {
-        let request = if is_google_type(&self.prost_method.input_type) && !compile_well_known_types
+        let request = if is_google_type(&self.prost_method.input_proto_type) && !compile_well_known_types
         {
             // For well-known types, map to absolute paths that will work with super::
-            match self.prost_method.input_type.as_str() {
+            match self.prost_method.input_proto_type.as_str() {
+                ".google.protobuf.BoolValue" => quote!(bool),
+                ".google.protobuf.BytesValue" => quote!(::prost::alloc::vec::Vec<u8>),
+                ".google.protobuf.DoubleValue" => quote!(f64),
                 ".google.protobuf.Empty" => quote!(()),
-                ".google.protobuf.Any" => quote!(::prost_types::Any),
+                ".google.protobuf.FloatValue" => quote!(f32),
+                ".google.protobuf.Int32Value" => quote!(i32),
+                ".google.protobuf.Int64Value" => quote!(i64),
                 ".google.protobuf.StringValue" => quote!(::prost::alloc::string::String),
+                ".google.protobuf.UInt32Value" => quote!(u32),
+                ".google.protobuf.UInt64Value" => quote!(u64),
                 _ => {
                     // For other google types, assume they're in prost_types
                     let type_name = self
                         .prost_method
-                        .input_type
+                        .input_proto_type
                         .trim_start_matches(".google.protobuf.")
                         .to_string();
                     syn::parse_str::<syn::Path>(&format!("::prost_types::{type_name}"))
@@ -211,11 +215,6 @@ impl tonic_build::Method for TonicBuildMethod {
                         .to_token_stream()
                 }
             }
-        } else if NON_PATH_TYPE_ALLOWLIST
-            .iter()
-            .any(|ty| self.prost_method.input_type.ends_with(ty))
-        {
-            self.prost_method.input_type.parse::<TokenStream>().unwrap()
         } else {
             // Check if this is an extern type that starts with :: or crate::
             if self.prost_method.input_type.starts_with("::")
@@ -235,17 +234,24 @@ impl tonic_build::Method for TonicBuildMethod {
         };
 
         let response =
-            if is_google_type(&self.prost_method.output_type) && !compile_well_known_types {
+            if is_google_type(&self.prost_method.output_proto_type) && !compile_well_known_types {
                 // For well-known types, map to absolute paths that will work with super::
-                match self.prost_method.output_type.as_str() {
+                match self.prost_method.output_proto_type.as_str() {
+                    ".google.protobuf.BoolValue" => quote!(bool),
+                    ".google.protobuf.BytesValue" => quote!(::prost::alloc::vec::Vec<u8>),
+                    ".google.protobuf.DoubleValue" => quote!(f64),
                     ".google.protobuf.Empty" => quote!(()),
-                    ".google.protobuf.Any" => quote!(::prost_types::Any),
+                    ".google.protobuf.FloatValue" => quote!(f32),
+                    ".google.protobuf.Int32Value" => quote!(i32),
+                    ".google.protobuf.Int64Value" => quote!(i64),
                     ".google.protobuf.StringValue" => quote!(::prost::alloc::string::String),
+                    ".google.protobuf.UInt32Value" => quote!(u32),
+                    ".google.protobuf.UInt64Value" => quote!(u64),
                     _ => {
                         // For other google types, assume they're in prost_types
                         let type_name = self
                             .prost_method
-                            .output_type
+                            .output_proto_type
                             .trim_start_matches(".google.protobuf.")
                             .to_string();
                         syn::parse_str::<syn::Path>(&format!("::prost_types::{type_name}"))
@@ -253,14 +259,6 @@ impl tonic_build::Method for TonicBuildMethod {
                             .to_token_stream()
                     }
                 }
-            } else if NON_PATH_TYPE_ALLOWLIST
-                .iter()
-                .any(|ty| self.prost_method.output_type.ends_with(ty))
-            {
-                self.prost_method
-                    .output_type
-                    .parse::<TokenStream>()
-                    .unwrap()
             } else {
                 // Check if this is an extern type that starts with :: or crate::
                 if self.prost_method.output_type.starts_with("::")

Some google.protobuf.*Value wrapper types are mapped to rust primitive types. I removed the 'if NON_PATH_TYPE_ALLOWLIST' branch, maybe it's for the '.google.protobuf.Empty' case?