Add constant code generation to C# generator

Summary:
Add constant support to the C# code generator:
- make_prototype_for_const with csharp_const_name, csharp_type, csharp_value
- const.mustache template generating a static Constants class
- Update module.mustache to conditionally include constants block

Update golden fixture output for basic test.

Reviewed By: vitaut

Differential Revision: D94439323

fbshipit-source-id: db11f444d280ec58301334e82c02b30146f25743

Author: abrady

third-party/thrift/src/thrift/compiler/generate/t_mstch_csharp_generator.cc

@@ -106,6 +106,61 @@ class t_csharp_EXPERIMENTAL_generator : public t_whisker_generator {
 
     return std::move(def).make();
   }
+
+  prototype<t_const>::ptr make_prototype_for_const(
+      const prototype_database& proto) const override {
+    auto base = t_whisker_generator::make_prototype_for_const(proto);
+    auto def = whisker::dsl::prototype_builder<h_const>::extends(base);
+    return std::move(def).make();
+  }
+
+  prototype<t_const_value>::ptr make_prototype_for_const_value(
+      const prototype_database& proto) const override {
+    auto base = t_whisker_generator::make_prototype_for_const_value(proto);
+    auto def = whisker::dsl::prototype_builder<h_const_value>::extends(base);
+
+    // Override string_value to use C#-specific escaping
+    // The base generator uses get_escaped_string() which outputs octal escapes
+    // that C# doesn't understand. We need \t, \n, \r, etc.
+    def.property("string_value", [](const t_const_value& self) {
+      return self.kind() == t_const_value::CV_STRING
+          ? w::string(csharp::escape_csharp_string(self.get_string()))
+          : w::null;
+    });
+
+    // Returns the string value as a comma-separated list of byte values.
+    // For binary default values like "7", returns "55" (ASCII code for '7').
+    // Used in templates for generating C# byte array initializers.
+    def.property("byte_array_elements", [](const t_const_value& self) {
+      if (self.kind() != t_const_value::CV_STRING) {
+        return w::null;
+      }
+      const std::string& str = self.get_string();
+      whisker::array::raw result;
+      result.reserve(str.size());
+      for (unsigned char c : str) {
+        result.emplace_back(w::i64(static_cast<int64_t>(c)));
+      }
+      return w::array(std::move(result));
+    });
+
+    // Whisker's strict_printable_types only allows i64 and string to be
+    // printed via {{...}} interpolation. f64, bool, and null require
+    // explicit string conversion with language-specific formatting.
+    def.property("bool_string", [](const t_const_value& self) {
+      return self.kind() == t_const_value::CV_BOOL
+          ? w::string(self.get_bool() ? "true" : "false")
+          : w::null;
+    });
+
+    def.property("double_string", [](const t_const_value& self) {
+      return self.kind() == t_const_value::CV_DOUBLE
+          ? w::string(fmt::format("{}", self.get_double()))
+          : w::null;
+    });
+
+    return std::move(def).make();
+  }
 };
 
 } // namespace

third-party/thrift/src/thrift/compiler/generate/templates/csharp/common/constants.mustache

@@ -35,11 +35,11 @@
   {{#else if value.type.double?}}
 {{#if value.double?}}{{value.double_string}}{{#else}}{{value.integer_value}}.0{{/if}}
   {{#else if value.type.string?}}
-{{value.csharp_quoted_value}}
+"{{value.string_value}}"
   {{#else if value.type.binary?}}
 new byte[] { {{#each (array.enumerate value.byte_array_elements with_first=true) as |i elem first?|}}{{#if (not first?)}} {{/if}}{{elem}},{{/each}} }
   {{#else if value.type.enum?}}
-({{#partial types.csharp_type type=value.type}}){{value.integer_value}}
+{{#if value.enum_value?}}{{#partial types.csharp_type type=value.type}}.{{value.enum_value.csharp_name}}{{#else}}({{#partial types.csharp_type type=value.type}}){{value.integer_value}}{{/if value.enum_value?}}
   {{/if value.type.bool?}}
 {{/let partial}}
 
@@ -65,11 +65,11 @@ new byte[] { {{#each (array.enumerate value.byte_array_elements with_first=true)
 }}{{#else if value.type.structured?}}
 new {{#partial types.csharp_type type=value.type}}()
 {
-  {{#if (object.notnull? value.structured_elements)}}
-    {{#each value.structured_elements as |elem|}}
-  {{elem.field.csharp_property_name}} = {{#partial csharp_const_value value=elem.value}},
+  {{#if (object.notnull? value.map_elements)}}
+    {{#each value.map_elements as |entry|}}
+  {{entry.key.string_value}} = {{#partial csharp_const_value value=entry.value}},
     {{/each}}
-  {{/if (object.notnull? value.structured_elements)}}
+  {{/if (object.notnull? value.map_elements)}}
 }{{!
 }}{{#else if value.type.map?}}
 new {{#partial types.csharp_type type=value.type}}()

third-party/thrift/src/thrift/compiler/generate/templates/csharp/common/file_header.mustache

@@ -30,4 +30,5 @@
 // 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.
+
 using System.Collections.Generic;

third-party/thrift/src/thrift/compiler/generate/templates/csharp/common/typedef_types.mustache

@@ -18,10 +18,19 @@
 
 {{! Renders a C# type name for a given Thrift type.
     Uses short/keyword type names (e.g. "int", "string", "bool").
-    Container types recurse to build generic syntax. }}
+    Container types recurse to build generic syntax.
+    For typedefs resolving to binary/primitive, we use the resolved type directly
+    because C# using aliases don't support these (byte[], keyword types). }}
 {{#let export partial csharp_type |type|}}
   {{#pragma ignore-newlines}}
-{{#if type.typedef?}}{{type.csharp_qualified_name}}
+{{#if type.typedef?}}
+{{! If typedef resolves to binary or primitive, use the resolved type instead of the typedef name
+    because C# can't create using aliases for byte[] or keyword types like float/double }}
+{{#if (or type.resolved.binary? type.resolved.primitive?)}}
+{{#partial csharp_type type=type.resolved}} /* {{type.name}} */
+{{#else}}
+{{type.csharp_qualified_name}}
+{{/if (or type.resolved.binary? type.resolved.primitive?)}}
 {{#else if type.void?}}void
 {{#else if type.bool?}}bool
 {{#else if type.byte?}}sbyte

third-party/thrift/src/thrift/compiler/generate/templates/csharp/common/types.mustache

@@ -14,18 +14,34 @@
   limitations under the License.
 
 }}
+{{#import "common/types" as types}}
 {{#import "types/enum" as enum_tmpl}}
 {{> common/file_header}}
+
 {{#each root_program.includes_for_codegen as |inc|}}
 {{#if inc.is_useful_alias?}}
 using {{inc.alias}} = {{inc.csharp_namespace}};
 {{/if inc.is_useful_alias?}}
 {{/each}}
+{{! Generate typedef aliases - maps Thrift typedefs to C# using aliases.
+    NOTE: Skip typedefs that resolve to types incompatible with C# using aliases:
+    - binary -> byte[] (arrays not allowed in using aliases until C# 12 / .NET 8+)
+    - float/double -> C# keywords can't be used directly in using aliases
+    - other primitives -> same issue with keyword types (int, bool, etc.)
+    Once we upgrade to .NET 8+, we can use C# 12's "alias any type" feature. }}
+{{#each root_program.typedefs as |td|}}
+{{#if (and (not td.resolved.binary?) (not td.resolved.primitive?))}}
+using {{td.csharp_name}} = {{#partial types.csharp_type type=td.resolved}};
+{{/if (and (not td.resolved.binary?) (not td.resolved.primitive?))}}
+{{/each}}
 
 namespace {{root_program.csharp_namespace}}
 {
 {{#each root_program.enums as |enum|}}
     {{#partial enum_tmpl.enum_type enum=enum}}
 
 {{/each}}
+{{#if root_program.constants?}}
+{{> types/const}}
+{{/if root_program.constants?}}
 }

third-party/thrift/src/thrift/compiler/generate/templates/csharp/module.mustache

@@ -0,0 +1,28 @@
+{{!
+  Copyright (c) Meta Platforms, Inc. and affiliates.
+
+  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.
+
+}}
+{{#import "common/types" as types}}
+{{#import "common/constants" as constants}}
+
+    /// <summary>
+    /// Auto-generated constants
+    /// </summary>
+    public static class Constants
+    {
+{{#each root_program.consts as |constant|}}
+        public static readonly {{#partial types.csharp_type type=constant.type}} {{constant.csharp_name}} = {{#partial constants.csharp_const_value value=constant.value}};
+{{/each}}
+    }

third-party/thrift/src/thrift/compiler/generate/templates/csharp/types/const.mustache

@@ -1,4 +1,5 @@
 android: android src/module.thrift
+csharp: csharp_EXPERIMENTAL src/module.thrift
 py: py src/module.thrift
 hack: hack:typedef,hack_collections=1 src/module.thrift
 cpp2: mstch_cpp2 src/module.thrift

third-party/thrift/src/thrift/compiler/test/fixtures/constants/cmd

@@ -338,13 +338,13 @@ ::std::set<::std::int32_t> const& set_map_initializer() {
 }
 
 
-::std::string_view _fbthrift_schema_e1bb5b11caac6d65() {
+::std::string_view _fbthrift_schema_11d69176884858b4() {
   return "";
 }
-::folly::Range<const ::std::string_view*> _fbthrift_schema_e1bb5b11caac6d65_includes() {
+::folly::Range<const ::std::string_view*> _fbthrift_schema_11d69176884858b4_includes() {
   return {};
 }
-::folly::Range<const ::std::string_view*> _fbthrift_schema_e1bb5b11caac6d65_uris() {
+::folly::Range<const ::std::string_view*> _fbthrift_schema_11d69176884858b4_uris() {
   return {};
 }
 

third-party/thrift/src/thrift/compiler/test/fixtures/constants/out/cpp2/gen-cpp2/module_constants.cpp

@@ -471,9 +471,9 @@ namespace module_constants {
   /** Glean {"constant": "set_map_initializer"} */
   ::std::set<::std::int32_t> const& set_map_initializer();
 
-  FOLLY_EXPORT ::std::string_view _fbthrift_schema_e1bb5b11caac6d65();
-  FOLLY_EXPORT ::folly::Range<const ::std::string_view*> _fbthrift_schema_e1bb5b11caac6d65_includes();
-  FOLLY_EXPORT ::folly::Range<const ::std::string_view*> _fbthrift_schema_e1bb5b11caac6d65_uris();
+  FOLLY_EXPORT ::std::string_view _fbthrift_schema_11d69176884858b4();
+  FOLLY_EXPORT ::folly::Range<const ::std::string_view*> _fbthrift_schema_11d69176884858b4_includes();
+  FOLLY_EXPORT ::folly::Range<const ::std::string_view*> _fbthrift_schema_11d69176884858b4_uris();
 
 } // namespace module_constants
 } // namespace cpp2