Improve C# handling of Any JSON serialization/deserialization

An Any without a type URL is now serialized to JSON as an empty object.
A JSON object without a type URL is now deserialized as an empty Any.
A JSON object with an invalid type URL now throws InvalidProtocolBufferException.

PiperOrigin-RevId: 753147779

Author: protobuf-github-bot

conformance/failure_list_csharp.txt

@@ -33,7 +33,4 @@ Recommended.Editions_Proto3.ValueRejectInfNumberValue.JsonOutput
 Recommended.Editions_Proto3.ValueRejectNanNumberValue.JsonOutput
 Required.Editions_Proto2.ProtobufInput.UnknownOrdering.ProtobufOutput
 Required.Editions_Proto3.ProtobufInput.UnknownOrdering.ProtobufOutput
-Required.*.JsonInput.AnyWithNoType.* # Failed to parse input or produce output.
-Required.*.JsonInput.AnyWktRepresentationWithEmptyTypeAndValue # Should have failed to parse, but didn't.
-Required.*.JsonInput.AnyWktRepresentationWithBadType # Should have failed to parse, but didn't.
 

csharp/src/Google.Protobuf.Test/JsonFormatterTest.cs

@@ -591,6 +591,13 @@ public void AnyUnknownType()
             Assert.Throws<InvalidOperationException>(() => JsonFormatter.Default.Format(any));
         }
 
+        [Test]
+        public void AnyEmpty()
+        {
+            var any = new Any();
+            AssertJson("{ }", JsonFormatter.Default.Format(any));
+        }
+
         [Test]
         [TestCase(typeof(BoolValue), true, "true")]
         [TestCase(typeof(Int32Value), 32, "32")]

csharp/src/Google.Protobuf.Test/JsonParserTest.cs

@@ -840,7 +840,17 @@ public void Any_UnknownType()
         [Test]
         public void Any_NoTypeUrl()
         {
+            // Currently if we're missing the type URL (@type) we return an empty Any message
+            // regardless of other fields. In the future we could potentially fail if there's no
+            // type URL but other fields are present.
             string json = "{ \"foo\": \"bar\" }";
+            Assert.AreEqual(new Any(), Any.Parser.ParseJson(json));
+        }
+
+        [Test]
+        public void Any_BadTypeUrl()
+        {
+            string json = "{ \"@type\": \"no-slash\" }";
             Assert.Throws<InvalidProtocolBufferException>(() => Any.Parser.ParseJson(json));
         }
 

csharp/src/Google.Protobuf/JsonFormatter.cs

@@ -471,6 +471,13 @@ private void WriteAny(TextWriter writer, IMessage value, int indentationLevel) {
 
       string typeUrl =
           (string)value.Descriptor.Fields[Any.TypeUrlFieldNumber].Accessor.GetValue(value);
+      // If no type URL has been specified, just return an empty JSON object.
+      if (typeUrl == "") {
+        WriteBracketOpen(writer, ObjectOpenBracket);
+        WriteBracketClose(writer, ObjectCloseBracket, false, indentationLevel);
+        return;
+      }
+
       ByteString data =
           (ByteString)value.Descriptor.Fields[Any.ValueFieldNumber].Accessor.GetValue(value);
       string typeName = Any.GetTypeName(typeUrl);

csharp/src/Google.Protobuf/JsonParser.cs

@@ -516,9 +516,13 @@ private void MergeAny(IMessage message, JsonTokenizer tokenizer)
                 tokens.Add(token);
                 token = tokenizer.Next();
 
+                // If we get to the end of the object and haven't seen a type URL, just return.
+                // (The message will be empty at this point.)
+                // We could potentially make this more conservative, failing if there are
+                // other properties but no type URL.
                 if (tokenizer.ObjectDepth < typeUrlObjectDepth)
                 {
-                    throw new InvalidProtocolBufferException("Any message with no @type");
+                    return;
                 }
             }
 
@@ -530,6 +534,15 @@ private void MergeAny(IMessage message, JsonTokenizer tokenizer)
             }
             string typeUrl = token.StringValue;
             string typeName = Any.GetTypeName(typeUrl);
+            // If we don't find a slash, GetTypeName returns an empty string. An empty string can
+            // never be a valid type name (whether that was through @type="", @type="blah" or
+            // @type="blah/") so we fail. This is InvalidProtocolBufferException rather than
+            // the InvalidOperationException used below, as it's the data that's invalid rather than
+            // the context in which we're parsing it.
+            if (typeName == "")
+            {
+                throw new InvalidProtocolBufferException("Invalid Any.@type value");
+            }
 
             MessageDescriptor descriptor = settings.TypeRegistry.Find(typeName);
             if (descriptor == null)