Replaced ToDasherCase with ConvertCase (#7131)

grpc/src/compiler/ts_generator.cc

@@ -21,32 +21,16 @@
  * 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 ToDasherizedCase(const grpc::string pascal_case) {
-  std::string dasherized_case;
-  char p = 0;
-  for (size_t i = 0; i < pascal_case.length(); i++) {
-    char const &c = pascal_case[i];
-    if (flatbuffers::is_alpha_upper(c)) {
-      if (i > 0 && p != flatbuffers::kPathSeparator) dasherized_case += "-";
-      dasherized_case += flatbuffers::CharToLower(c);
-    } else {
-      dasherized_case += c;
-    }
-    p = c;
-  }
-  return dasherized_case;
-}
-
-
 grpc::string GenerateNamespace(const std::vector<std::string> ns,
                                const std::string filename,
                                const bool include_separator) {
@@ -55,11 +39,17 @@ grpc::string GenerateNamespace(const std::vector<std::string> ns,
 
   for (auto it = ns.begin(); it < ns.end(); it++) {
     if (include_separator) path += "/";
-    path += include_separator ? ToDasherizedCase(*it) : *it + "_";
+    path += include_separator
+                ? flatbuffers::ConvertCase(*it, flatbuffers::Case::kDasher,
+                                           flatbuffers::Case::kUpperCamel)
+                : *it + "_";
   }
 
   if (include_separator) path += "/";
-  path += include_separator ? ToDasherizedCase(filename) : filename;
+  path += include_separator
+              ? flatbuffers::ConvertCase(filename, flatbuffers::Case::kDasher,
+                                         flatbuffers::Case::kUpperCamel)
+              : filename;
   return path;
 }
 

include/flatbuffers/code_generators.h

@@ -97,8 +97,6 @@ class BaseGenerator {
                                   const Namespace &ns,
                                   const bool dasherize = false);
 
-  static std::string ToDasherizedCase(const std::string pascal_case);
-
   std::string GeneratedFileName(const std::string &path,
                                 const std::string &file_name,
                                 const IDLOptions &options) const;

include/flatbuffers/util.h

@@ -699,6 +699,8 @@ enum class Case {
   kAllUpper = 5,
   // thequickbrownfox
   kAllLower = 6,
+  // the-quick-brown-fox
+  kDasher = 7,
 };
 
 // Convert the `input` string of case `input_case` to the specified `output_case`.

src/code_generators.cpp

@@ -91,7 +91,8 @@ std::string BaseGenerator::NamespaceDir(const Parser &parser,
   std::string namespace_dir = path;  // Either empty or ends in separator.
   auto &namespaces = ns.components;
   for (auto it = namespaces.begin(); it != namespaces.end(); ++it) {
-    namespace_dir += !dasherize ? *it : ToDasherizedCase(*it);
+    namespace_dir +=
+        !dasherize ? *it : ConvertCase(*it, Case::kDasher, Case::kUpperCamel);
     namespace_dir += kPathSeparator;
     EnsureDirExists(namespace_dir);
   }
@@ -103,22 +104,6 @@ std::string BaseGenerator::NamespaceDir(const Namespace &ns,
   return BaseGenerator::NamespaceDir(parser_, path_, ns, dasherize);
 }
 
-std::string BaseGenerator::ToDasherizedCase(const std::string pascal_case) {
-  std::string dasherized_case;
-  char p = 0;
-  for (size_t i = 0; i < pascal_case.length(); i++) {
-    char const &c = pascal_case[i];
-    if (is_alpha_upper(c)) {
-      if (i > 0 && p != kPathSeparator) dasherized_case += "-";
-      dasherized_case += CharToLower(c);
-    } else {
-      dasherized_case += c;
-    }
-    p = c;
-  }
-  return dasherized_case;
-}
-
 std::string BaseGenerator::FullNamespace(const char *separator,
                                          const Namespace &ns) {
   std::string namespace_name;

src/idl_gen_ts.cpp

@@ -134,8 +134,9 @@ class TsGenerator : public BaseGenerator {
     if (!imports.empty()) code += "\n\n";
 
     code += classcode;
-    auto filename = NamespaceDir(*definition.defined_namespace, true) +
-                    ToDasherizedCase(definition.name) + ".ts";
+    auto filename =
+        NamespaceDir(*definition.defined_namespace, true) +
+        ConvertCase(definition.name, Case::kDasher, Case::kUpperCamel) + ".ts";
     return SaveFile(filename.c_str(), code, false);
   }
 
@@ -566,8 +567,11 @@ class TsGenerator : public BaseGenerator {
       rel_file_path += i == 0 ? ".." : (kPathSeparator + std::string(".."));
     if (dep_comps.size() == 0) rel_file_path += ".";
     for (auto it = depc_comps.begin(); it != depc_comps.end(); it++)
-      bare_file_path += kPathSeparator + ToDasherizedCase(*it);
-    bare_file_path += kPathSeparator + ToDasherizedCase(dependency.name);
+      bare_file_path +=
+          kPathSeparator + ConvertCase(*it, Case::kDasher, Case::kUpperCamel);
+    bare_file_path +=
+        kPathSeparator +
+        ConvertCase(dependency.name, Case::kDasher, Case::kUpperCamel);
     rel_file_path += bare_file_path;
     import_statement += rel_file_path + "';";
     export_statement += "." + bare_file_path + "';";
@@ -623,8 +627,11 @@ class TsGenerator : public BaseGenerator {
       rel_file_path += i == 0 ? ".." : (kPathSeparator + std::string(".."));
     if (dep_comps.size() == 0) rel_file_path += ".";
     for (auto it = depc_comps.begin(); it != depc_comps.end(); it++)
-      bare_file_path += kPathSeparator + ToDasherizedCase(*it);
-    bare_file_path += kPathSeparator + ToDasherizedCase(dependency.name);
+      bare_file_path +=
+          kPathSeparator + ConvertCase(*it, Case::kDasher, Case::kUpperCamel);
+    bare_file_path +=
+        kPathSeparator +
+        ConvertCase(dependency.name, Case::kDasher, Case::kUpperCamel);
     rel_file_path += bare_file_path;
     import_statement += rel_file_path + "';";
     export_statement += "." + bare_file_path + "';";

src/util.cpp

@@ -379,6 +379,39 @@ static std::string CamelToSnake(const std::string &input) {
   return s;
 }
 
+static std::string DasherToSnake(const std::string &input) {
+  std::string s;
+  for (size_t i = 0; i < input.length(); i++) {
+    if (input[i] == '-') {
+      s += "_";
+    } else {
+      s += input[i];
+    }
+  }
+  return s;
+}
+
+static std::string ToDasher(const std::string &input) {
+  std::string s;
+  char p = 0;
+  for (size_t i = 0; i < input.length(); i++) {
+    char const &c = input[i];
+    if (c == '_') {
+      if (i > 0 && p != kPathSeparator &&
+          // The following is a special case to ignore digits after a _. This is
+          // because ThisExample3 would be converted to this_example_3 in the
+          // CamelToSnake conversion, and then dasher would do this-example-3,
+          // but it expects this-example3.
+          !(i + 1 < input.length() && isdigit(input[i + 1])))
+        s += "-";
+    } else {
+      s += c;
+    }
+    p = c;
+  }
+  return s;
+}
+
 }  // namespace
 
 std::string ConvertCase(const std::string &input, Case output_case,
@@ -389,7 +422,7 @@ std::string ConvertCase(const std::string &input, Case output_case,
     case Case::kLowerCamel:
     case Case::kUpperCamel:
       return ConvertCase(CamelToSnake(input), output_case);
-
+    case Case::kDasher: return ConvertCase(DasherToSnake(input), output_case);
     default:
     case Case::kSnake:
     case Case::kScreamingSnake:
@@ -404,6 +437,7 @@ std::string ConvertCase(const std::string &input, Case output_case,
     case Case::kScreamingSnake: return ToSnakeCase(input, true);
     case Case::kAllUpper: return ToAll(input, CharToUpper);
     case Case::kAllLower: return ToAll(input, CharToLower);
+    case Case::kDasher: return ToDasher(input);
     default:
     case Case::kUnknown: return input;
   }

tests/optional-scalars/optional-byte.ts

@@ -0,0 +1,8 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+export enum OptionalByte{
+  None = 0,
+  One = 1,
+  Two = 2
+}
+

tests/optional-scalars/scalar-stuff.ts

@@ -0,0 +1,423 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+import * as flatbuffers from 'flatbuffers';
+
+import { OptionalByte } from '../optional-scalars/optional-byte';
+
+
+export class ScalarStuff {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+__init(i:number, bb:flatbuffers.ByteBuffer):ScalarStuff {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsScalarStuff(bb:flatbuffers.ByteBuffer, obj?:ScalarStuff):ScalarStuff {
+  return (obj || new ScalarStuff()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsScalarStuff(bb:flatbuffers.ByteBuffer, obj?:ScalarStuff):ScalarStuff {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new ScalarStuff()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean {
+  return bb.__has_identifier('NULL');
+}
+
+justI8():number {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readInt8(this.bb_pos + offset) : 0;
+}
+
+maybeI8():number|null {
+  const offset = this.bb!.__offset(this.bb_pos, 6);
+  return offset ? this.bb!.readInt8(this.bb_pos + offset) : null;
+}
+
+defaultI8():number {
+  const offset = this.bb!.__offset(this.bb_pos, 8);
+  return offset ? this.bb!.readInt8(this.bb_pos + offset) : 42;
+}
+
+justU8():number {
+  const offset = this.bb!.__offset(this.bb_pos, 10);
+  return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0;
+}
+
+maybeU8():number|null {
+  const offset = this.bb!.__offset(this.bb_pos, 12);
+  return offset ? this.bb!.readUint8(this.bb_pos + offset) : null;
+}
+
+defaultU8():number {
+  const offset = this.bb!.__offset(this.bb_pos, 14);
+  return offset ? this.bb!.readUint8(this.bb_pos + offset) : 42;
+}
+
+justI16():number {
+  const offset = this.bb!.__offset(this.bb_pos, 16);
+  return offset ? this.bb!.readInt16(this.bb_pos + offset) : 0;
+}
+
+maybeI16():number|null {
+  const offset = this.bb!.__offset(this.bb_pos, 18);
+  return offset ? this.bb!.readInt16(this.bb_pos + offset) : null;
+}
+
+defaultI16():number {
+  const offset = this.bb!.__offset(this.bb_pos, 20);
+  return offset ? this.bb!.readInt16(this.bb_pos + offset) : 42;
+}
+
+justU16():number {
+  const offset = this.bb!.__offset(this.bb_pos, 22);
+  return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0;
+}
+
+maybeU16():number|null {
+  const offset = this.bb!.__offset(this.bb_pos, 24);
+  return offset ? this.bb!.readUint16(this.bb_pos + offset) : null;
+}
+
+defaultU16():number {
+  const offset = this.bb!.__offset(this.bb_pos, 26);
+  return offset ? this.bb!.readUint16(this.bb_pos + offset) : 42;
+}
+
+justI32():number {
+  const offset = this.bb!.__offset(this.bb_pos, 28);
+  return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;
+}
+
+maybeI32():number|null {
+  const offset = this.bb!.__offset(this.bb_pos, 30);
+  return offset ? this.bb!.readInt32(this.bb_pos + offset) : null;
+}
+
+defaultI32():number {
+  const offset = this.bb!.__offset(this.bb_pos, 32);
+  return offset ? this.bb!.readInt32(this.bb_pos + offset) : 42;
+}
+
+justU32():number {
+  const offset = this.bb!.__offset(this.bb_pos, 34);
+  return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
+}
+
+maybeU32():number|null {
+  const offset = this.bb!.__offset(this.bb_pos, 36);
+  return offset ? this.bb!.readUint32(this.bb_pos + offset) : null;
+}
+
+defaultU32():number {
+  const offset = this.bb!.__offset(this.bb_pos, 38);
+  return offset ? this.bb!.readUint32(this.bb_pos + offset) : 42;
+}
+
+justI64():bigint {
+  const offset = this.bb!.__offset(this.bb_pos, 40);
+  return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');
+}
+
+maybeI64():bigint|null {
+  const offset = this.bb!.__offset(this.bb_pos, 42);
+  return offset ? this.bb!.readInt64(this.bb_pos + offset) : null;
+}
+
+defaultI64():bigint {
+  const offset = this.bb!.__offset(this.bb_pos, 44);
+  return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('42');
+}
+
+justU64():bigint {
+  const offset = this.bb!.__offset(this.bb_pos, 46);
+  return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('0');
+}
+
+maybeU64():bigint|null {
+  const offset = this.bb!.__offset(this.bb_pos, 48);
+  return offset ? this.bb!.readUint64(this.bb_pos + offset) : null;
+}
+
+defaultU64():bigint {
+  const offset = this.bb!.__offset(this.bb_pos, 50);
+  return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('42');
+}
+
+justF32():number {
+  const offset = this.bb!.__offset(this.bb_pos, 52);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0;
+}
+
+maybeF32():number|null {
+  const offset = this.bb!.__offset(this.bb_pos, 54);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null;
+}
+
+defaultF32():number {
+  const offset = this.bb!.__offset(this.bb_pos, 56);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 42.0;
+}
+
+justF64():number {
+  const offset = this.bb!.__offset(this.bb_pos, 58);
+  return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 0.0;
+}
+
+maybeF64():number|null {
+  const offset = this.bb!.__offset(this.bb_pos, 60);
+  return offset ? this.bb!.readFloat64(this.bb_pos + offset) : null;
+}
+
+defaultF64():number {
+  const offset = this.bb!.__offset(this.bb_pos, 62);
+  return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 42.0;
+}
+
+justBool():boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 64);
+  return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;
+}
+
+maybeBool():boolean|null {
+  const offset = this.bb!.__offset(this.bb_pos, 66);
+  return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null;
+}
+
+defaultBool():boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 68);
+  return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : true;
+}
+
+justEnum():OptionalByte {
+  const offset = this.bb!.__offset(this.bb_pos, 70);
+  return offset ? this.bb!.readInt8(this.bb_pos + offset) : OptionalByte.None;
+}
+
+maybeEnum():OptionalByte|null {
+  const offset = this.bb!.__offset(this.bb_pos, 72);
+  return offset ? this.bb!.readInt8(this.bb_pos + offset) : null;
+}
+
+defaultEnum():OptionalByte {
+  const offset = this.bb!.__offset(this.bb_pos, 74);
+  return offset ? this.bb!.readInt8(this.bb_pos + offset) : OptionalByte.One;
+}
+
+static startScalarStuff(builder:flatbuffers.Builder) {
+  builder.startObject(36);
+}
+
+static addJustI8(builder:flatbuffers.Builder, justI8:number) {
+  builder.addFieldInt8(0, justI8, 0);
+}
+
+static addMaybeI8(builder:flatbuffers.Builder, maybeI8:number) {
+  builder.addFieldInt8(1, maybeI8, 0);
+}
+
+static addDefaultI8(builder:flatbuffers.Builder, defaultI8:number) {
+  builder.addFieldInt8(2, defaultI8, 42);
+}
+
+static addJustU8(builder:flatbuffers.Builder, justU8:number) {
+  builder.addFieldInt8(3, justU8, 0);
+}
+
+static addMaybeU8(builder:flatbuffers.Builder, maybeU8:number) {
+  builder.addFieldInt8(4, maybeU8, 0);
+}
+
+static addDefaultU8(builder:flatbuffers.Builder, defaultU8:number) {
+  builder.addFieldInt8(5, defaultU8, 42);
+}
+
+static addJustI16(builder:flatbuffers.Builder, justI16:number) {
+  builder.addFieldInt16(6, justI16, 0);
+}
+
+static addMaybeI16(builder:flatbuffers.Builder, maybeI16:number) {
+  builder.addFieldInt16(7, maybeI16, 0);
+}
+
+static addDefaultI16(builder:flatbuffers.Builder, defaultI16:number) {
+  builder.addFieldInt16(8, defaultI16, 42);
+}
+
+static addJustU16(builder:flatbuffers.Builder, justU16:number) {
+  builder.addFieldInt16(9, justU16, 0);
+}
+
+static addMaybeU16(builder:flatbuffers.Builder, maybeU16:number) {
+  builder.addFieldInt16(10, maybeU16, 0);
+}
+
+static addDefaultU16(builder:flatbuffers.Builder, defaultU16:number) {
+  builder.addFieldInt16(11, defaultU16, 42);
+}
+
+static addJustI32(builder:flatbuffers.Builder, justI32:number) {
+  builder.addFieldInt32(12, justI32, 0);
+}
+
+static addMaybeI32(builder:flatbuffers.Builder, maybeI32:number) {
+  builder.addFieldInt32(13, maybeI32, 0);
+}
+
+static addDefaultI32(builder:flatbuffers.Builder, defaultI32:number) {
+  builder.addFieldInt32(14, defaultI32, 42);
+}
+
+static addJustU32(builder:flatbuffers.Builder, justU32:number) {
+  builder.addFieldInt32(15, justU32, 0);
+}
+
+static addMaybeU32(builder:flatbuffers.Builder, maybeU32:number) {
+  builder.addFieldInt32(16, maybeU32, 0);
+}
+
+static addDefaultU32(builder:flatbuffers.Builder, defaultU32:number) {
+  builder.addFieldInt32(17, defaultU32, 42);
+}
+
+static addJustI64(builder:flatbuffers.Builder, justI64:bigint) {
+  builder.addFieldInt64(18, justI64, BigInt('0'));
+}
+
+static addMaybeI64(builder:flatbuffers.Builder, maybeI64:bigint) {
+  builder.addFieldInt64(19, maybeI64, BigInt(0));
+}
+
+static addDefaultI64(builder:flatbuffers.Builder, defaultI64:bigint) {
+  builder.addFieldInt64(20, defaultI64, BigInt('42'));
+}
+
+static addJustU64(builder:flatbuffers.Builder, justU64:bigint) {
+  builder.addFieldInt64(21, justU64, BigInt('0'));
+}
+
+static addMaybeU64(builder:flatbuffers.Builder, maybeU64:bigint) {
+  builder.addFieldInt64(22, maybeU64, BigInt(0));
+}
+
+static addDefaultU64(builder:flatbuffers.Builder, defaultU64:bigint) {
+  builder.addFieldInt64(23, defaultU64, BigInt('42'));
+}
+
+static addJustF32(builder:flatbuffers.Builder, justF32:number) {
+  builder.addFieldFloat32(24, justF32, 0.0);
+}
+
+static addMaybeF32(builder:flatbuffers.Builder, maybeF32:number) {
+  builder.addFieldFloat32(25, maybeF32, 0);
+}
+
+static addDefaultF32(builder:flatbuffers.Builder, defaultF32:number) {
+  builder.addFieldFloat32(26, defaultF32, 42.0);
+}
+
+static addJustF64(builder:flatbuffers.Builder, justF64:number) {
+  builder.addFieldFloat64(27, justF64, 0.0);
+}
+
+static addMaybeF64(builder:flatbuffers.Builder, maybeF64:number) {
+  builder.addFieldFloat64(28, maybeF64, 0);
+}
+
+static addDefaultF64(builder:flatbuffers.Builder, defaultF64:number) {
+  builder.addFieldFloat64(29, defaultF64, 42.0);
+}
+
+static addJustBool(builder:flatbuffers.Builder, justBool:boolean) {
+  builder.addFieldInt8(30, +justBool, +false);
+}
+
+static addMaybeBool(builder:flatbuffers.Builder, maybeBool:boolean) {
+  builder.addFieldInt8(31, +maybeBool, 0);
+}
+
+static addDefaultBool(builder:flatbuffers.Builder, defaultBool:boolean) {
+  builder.addFieldInt8(32, +defaultBool, +true);
+}
+
+static addJustEnum(builder:flatbuffers.Builder, justEnum:OptionalByte) {
+  builder.addFieldInt8(33, justEnum, OptionalByte.None);
+}
+
+static addMaybeEnum(builder:flatbuffers.Builder, maybeEnum:OptionalByte) {
+  builder.addFieldInt8(34, maybeEnum, 0);
+}
+
+static addDefaultEnum(builder:flatbuffers.Builder, defaultEnum:OptionalByte) {
+  builder.addFieldInt8(35, defaultEnum, OptionalByte.One);
+}
+
+static endScalarStuff(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static finishScalarStuffBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {
+  builder.finish(offset, 'NULL');
+}
+
+static finishSizePrefixedScalarStuffBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {
+  builder.finish(offset, 'NULL', true);
+}
+
+static createScalarStuff(builder:flatbuffers.Builder, justI8:number, maybeI8:number|null, defaultI8:number, justU8:number, maybeU8:number|null, defaultU8:number, justI16:number, maybeI16:number|null, defaultI16:number, justU16:number, maybeU16:number|null, defaultU16:number, justI32:number, maybeI32:number|null, defaultI32:number, justU32:number, maybeU32:number|null, defaultU32:number, justI64:bigint, maybeI64:bigint|null, defaultI64:bigint, justU64:bigint, maybeU64:bigint|null, defaultU64:bigint, justF32:number, maybeF32:number|null, defaultF32:number, justF64:number, maybeF64:number|null, defaultF64:number, justBool:boolean, maybeBool:boolean|null, defaultBool:boolean, justEnum:OptionalByte, maybeEnum:OptionalByte|null, defaultEnum:OptionalByte):flatbuffers.Offset {
+  ScalarStuff.startScalarStuff(builder);
+  ScalarStuff.addJustI8(builder, justI8);
+  if (maybeI8 !== null)
+    ScalarStuff.addMaybeI8(builder, maybeI8);
+  ScalarStuff.addDefaultI8(builder, defaultI8);
+  ScalarStuff.addJustU8(builder, justU8);
+  if (maybeU8 !== null)
+    ScalarStuff.addMaybeU8(builder, maybeU8);
+  ScalarStuff.addDefaultU8(builder, defaultU8);
+  ScalarStuff.addJustI16(builder, justI16);
+  if (maybeI16 !== null)
+    ScalarStuff.addMaybeI16(builder, maybeI16);
+  ScalarStuff.addDefaultI16(builder, defaultI16);
+  ScalarStuff.addJustU16(builder, justU16);
+  if (maybeU16 !== null)
+    ScalarStuff.addMaybeU16(builder, maybeU16);
+  ScalarStuff.addDefaultU16(builder, defaultU16);
+  ScalarStuff.addJustI32(builder, justI32);
+  if (maybeI32 !== null)
+    ScalarStuff.addMaybeI32(builder, maybeI32);
+  ScalarStuff.addDefaultI32(builder, defaultI32);
+  ScalarStuff.addJustU32(builder, justU32);
+  if (maybeU32 !== null)
+    ScalarStuff.addMaybeU32(builder, maybeU32);
+  ScalarStuff.addDefaultU32(builder, defaultU32);
+  ScalarStuff.addJustI64(builder, justI64);
+  if (maybeI64 !== null)
+    ScalarStuff.addMaybeI64(builder, maybeI64);
+  ScalarStuff.addDefaultI64(builder, defaultI64);
+  ScalarStuff.addJustU64(builder, justU64);
+  if (maybeU64 !== null)
+    ScalarStuff.addMaybeU64(builder, maybeU64);
+  ScalarStuff.addDefaultU64(builder, defaultU64);
+  ScalarStuff.addJustF32(builder, justF32);
+  if (maybeF32 !== null)
+    ScalarStuff.addMaybeF32(builder, maybeF32);
+  ScalarStuff.addDefaultF32(builder, defaultF32);
+  ScalarStuff.addJustF64(builder, justF64);
+  if (maybeF64 !== null)
+    ScalarStuff.addMaybeF64(builder, maybeF64);
+  ScalarStuff.addDefaultF64(builder, defaultF64);
+  ScalarStuff.addJustBool(builder, justBool);
+  if (maybeBool !== null)
+    ScalarStuff.addMaybeBool(builder, maybeBool);
+  ScalarStuff.addDefaultBool(builder, defaultBool);
+  ScalarStuff.addJustEnum(builder, justEnum);
+  if (maybeEnum !== null)
+    ScalarStuff.addMaybeEnum(builder, maybeEnum);
+  ScalarStuff.addDefaultEnum(builder, defaultEnum);
+  return ScalarStuff.endScalarStuff(builder);
+}
+}

tests/optional_scalars.ts

@@ -1 +1 @@
-export { OptionalByte } from './optional_scalars/optional-byte';
+export { OptionalByte } from './optional-scalars/optional-byte';