Mojo bindings: support generating identifers using different style rules for different target langu…

mojo/public/tools/bindings/generators/js_templates/union_definition.tmpl

 {%- macro union_def(union) %}
-function {{union.name}}(value) {
+function {{union.stylized_name}}(value) {
   this.initDefault_();
   this.initValue_(value);
 }
 
 {{tags(union)}}
 
-{{union.name}}.prototype.initDefault_ = function() {
+{{union.stylized_name}}.prototype.initDefault_ = function() {
   this.$data = null;
   this.$tag = undefined;
 }
 
-{{union.name}}.prototype.initValue_ = function(value) {
+{{union.stylized_name}}.prototype.initValue_ = function(value) {
   if (value == undefined) {
     return;
   }
 
   var keys = Object.keys(value);
   if (keys.length == 0) {
     return;
   }
 
   if (keys.length > 1) {
     throw new TypeError("You may set only one member on a union.");
   }
 
   var fields = [
 {%-   for field in union.fields %}
-      "{{field.name}}",
+      "{{field.stylized_name}}",
 {%-   endfor %}
   ];
 
   if (fields.indexOf(keys[0]) < 0) {
-    throw new ReferenceError(keys[0] + " is not a {{union.name}} member.");
+    throw new ReferenceError(
+        keys[0] + " is not a {{union.stylized_name}} member.");
 
   }
 
   this[keys[0]] = value[keys[0]];
 }
 
 {%-   for field in union.fields %}
-Object.defineProperty({{union.name}}.prototype, "{{field.name}}", {
+Object.defineProperty({{union.stylized_name}}.prototype,
+                      "{{field.stylized_name}}", {
   get: function() {
-    if (this.$tag != {{union.name}}.Tags.{{field.name}}) {
+    if (this.$tag != {{union.stylized_name}}.Tags.{{field.stylized_name}}) {
       throw new ReferenceError(
-          "{{union.name}}.{{field.name}} is not currently set.");
+          "{{union.stylized_name}}.{{field.stylized_name}} is not currently set.");
     }
     return this.$data;
   },
 
   set: function(value) {
-    this.$tag = {{union.name}}.Tags.{{field.name}};
+    this.$tag = {{union.stylized_name}}.Tags.{{field.stylized_name}};
     this.$data = value;
   }
 });
 {%-   endfor %}
 
 {{encode(union)|indent(2)}}
 
 {{decode(union)|indent(2)}}
 
 {{validate(union)|indent(2)}}
 
-{{union.name}}.encodedSize = 16;
+{{union.stylized_name}}.encodedSize = 16;
 {%- endmacro %}
 
 {%- macro tags(union) %}
-{{union.name}}.Tags = {
+{{union.stylized_name}}.Tags = {
 {%-   for field in union.fields %}
-  {{field.name}}: {{field.ordinal}},
+  {{field.stylized_name}}: {{field.ordinal}},
 {%-   endfor %}
 };
 {%- endmacro %}
 
 {%- macro encode(union) %}
-{{union.name}}.encode = function(encoder, val) {
+{{union.stylized_name}}.encode = function(encoder, val) {
   if (val == null) {
     encoder.writeUint64(0);
     encoder.writeUint64(0);
     return;
   }
   if (val.$tag == undefined) {
     throw new TypeError("Cannot encode unions with an unknown member set.");
   }
 
   encoder.writeUint32(16);
   encoder.writeUint32(val.$tag);
   switch (val.$tag) {
 {%-   for field in union.fields %}
-    case {{union.name}}.Tags.{{field.name}}:
+    case {{union.stylized_name}}.Tags.{{field.stylized_name}}:
 {%-     if field|is_bool_field %}
-      encoder.writeUint8(val.{{field.name}} ? 1 : 0);
+      encoder.writeUint8(val.{{field.stylized_name}} ? 1 : 0);
 {%-     else %}
-      encoder.{{field.kind|union_encode_snippet}}val.{{field.name}});
+      encoder.{{field.kind|union_encode_snippet}}val.{{field.stylized_name}});
 {%-     endif %}
       break;
 {%-   endfor %}
   }
   encoder.align();
 };
 {%- endmacro %}
 
 {%- macro decode(union) %}
-{{union.name}}.decode = function(decoder) {
+{{union.stylized_name}}.decode = function(decoder) {
   var size = decoder.readUint32();
   if (size == 0) {
     decoder.readUint32();
     decoder.readUint64();
     return null;
   }
 
-  var result = new {{union.name}}();
+  var result = new {{union.stylized_name}}();
   var tag = decoder.readUint32();
   switch (tag) {
 {%-   for field in union.fields %}
-    case {{union.name}}.Tags.{{field.name}}:
+    case {{union.stylized_name}}.Tags.{{field.stylized_name}}:
 {%-     if field|is_bool_field %}
-      result.{{field.name}} = decoder.readUint8() ? true : false;
+      result.{{field.stylized_name}} = decoder.readUint8() ? true : false;
 {%-     else %}
-      result.{{field.name}} = decoder.{{field.kind|union_decode_snippet}};
+      result.{{field.stylized_name}} =
+          decoder.{{field.kind|union_decode_snippet}};
 {%-     endif %}
       break;
 {%-   endfor %}
   }
   decoder.align();
 
   return result;
 };
 {%- endmacro %}
 
 {%- from "validation_macros.tmpl" import validate_union_field %}
 {%- macro validate(union) %}
-{{union.name}}.validate = function(messageValidator, offset) {
+{{union.stylized_name}}.validate = function(messageValidator, offset) {
   var size = messageValidator.decodeUnionSize(offset);
   if (size != 16) {
     return validator.validationError.INVALID_UNION_SIZE;
   }
 
   var tag = messageValidator.decodeUnionTag(offset);
   var data_offset = offset + 8;
   var err;
   switch (tag) {
 {%-   for field in union.fields %}
-{%-     set name = union.name ~ '.' ~ field.name %}
-    case {{union.name}}.Tags.{{field.name}}:
+{%-     set name = union.stylized_name ~ '.' ~ field.stylized_name %}
+    case {{union.stylized_name}}.Tags.{{field.stylized_name}}:
       {{validate_union_field(field, "data_offset", name)}}
       break;
 {%-   endfor %}
   }
 
   return validator.validationError.NONE;
 };
 {%- endmacro %}