fix(prost-build): Avoid OneOf type collision with enums and keyword names (#1341)

* Avoids OneOf type collision with enums and some nested types

When detecting if a oneof type will clash with other types we only
compare against nested types, and for those only the snake_case version
is validated against the oneof name. This allow room for conflicts when:
 - The collision would happen with an enum type.
 - The oneof name is a reserved word that when snaked gets sanitized as
   r#<word>.

In this change the check for collisions is updated to consider enum
types and compered against their capitalized camel case version which

* PR feedback

* Fix clippy

Author: jknovi

prost-build/src/code_generator.rs

@@ -76,10 +76,11 @@ impl OneofField {
         fields: Vec<Field>,
         path_index: i32,
     ) -> Self {
-        let has_type_name_conflict = parent
-            .nested_type
-            .iter()
-            .any(|nested| to_snake(nested.name()) == descriptor.name());
+        let nested_type_names = parent.nested_type.iter().map(DescriptorProto::name);
+        let nested_enum_names = parent.enum_type.iter().map(EnumDescriptorProto::name);
+        let has_type_name_conflict = nested_type_names
+            .chain(nested_enum_names)
+            .any(|type_name| to_upper_camel(type_name) == to_upper_camel(descriptor.name()));
 
         Self {
             descriptor,

tests/src/oneof_name_conflict.proto

@@ -12,3 +12,50 @@ message Bakery {
     Bread b = 2;
   }
 }
+
+message EnumAndOneofConflict {
+  enum Type {
+    TYPE_1 = 0;
+    TYPE_2 = 1;
+  }
+
+  message TypeOne {
+    string field = 1;
+  }
+  message TypeTwo {
+    int32 field = 1;
+  }
+  message TypeThree {
+    Type field = 1;
+  }
+
+  oneof type {
+    TypeOne one = 1;
+    TypeTwo two = 2;
+    TypeThree three = 3;
+  }
+}
+
+message NestedTypeWithReservedKeyword {
+  // abstract is a reserved keyword of the languange
+  // so it will be escaped as r#abstract.
+  message Abstract {
+    string field = 1;
+  }
+  message TypeOne {
+    string field = 1;
+  }
+  message TypeTwo {
+    int32 field = 1;
+  }
+  message TypeThree {
+    Abstract field = 1;
+  }
+
+  oneof abstract {
+    Abstract abstract_ = 1;
+    TypeOne type_one = 2;
+    TypeTwo type_two = 3;
+    TypeThree type_three = 4;
+  }
+}

tests/src/oneof_name_conflict.rs

@@ -10,4 +10,24 @@ fn test_creation() {
             oneof_name_conflict::bakery::Bread { weight: 12 },
         )),
     };
+
+    let _ = oneof_name_conflict::EnumAndOneofConflict {
+        r#type: Some(
+            oneof_name_conflict::enum_and_oneof_conflict::TypeOneOf::Three(
+                oneof_name_conflict::enum_and_oneof_conflict::TypeThree {
+                    field: oneof_name_conflict::enum_and_oneof_conflict::Type::Type1.into(),
+                },
+            ),
+        ),
+    };
+
+    let _ = oneof_name_conflict::NestedTypeWithReservedKeyword {
+        r#abstract: Some(
+            oneof_name_conflict::nested_type_with_reserved_keyword::AbstractOneOf::Abstract(
+                oneof_name_conflict::nested_type_with_reserved_keyword::Abstract {
+                    field: "field".into(),
+                },
+            ),
+        ),
+    };
 }