Generate Mojom Types in Go

mojo/public/tools/bindings/generators/go_templates/source.tmpl

Index: mojo/public/tools/bindings/generators/go_templates/source.tmpl
diff --git a/mojo/public/tools/bindings/generators/go_templates/source.tmpl b/mojo/public/tools/bindings/generators/go_templates/source.tmpl
index e864d67ca8b3e220e173691ce6df5f71a56d66fe..495bc4054402d0d48d439ddb1f324dc8b94da53c 100644
--- a/mojo/public/tools/bindings/generators/go_templates/source.tmpl
+++ b/mojo/public/tools/bindings/generators/go_templates/source.tmpl
@@ -20,23 +20,80 @@ import (
 {% import "interface.tmpl" as interface_macros %}
 {% import "struct.tmpl" as struct_macros %}
 {% import "union.tmpl" as union_macros %}
+{% import "mojom_reference_macros.tmpl" as mojom_reference_macros %}
 
-{#- Enum definitions #}
+{#- This init function initializes a mapping between identifiers and their
+    corresponding user-defined type. This could have been a MojomDescriptor,
+    but since it allows Types to be unresolved, it is more complex than is
+    necessary. It's simpler to resolve everything in codegen.
+    It is also difficult to insert changes to the description during the
+    process of generating each type, so this mapping is computed in Python.
+    Note: While we may register items into the map multiple times, this is okay
+    because the keys will match.
+-#}
+
+{%- if should_gen_mojom_types -%}
+// These IDs are the Mojom Identifiers / Type Keys.
+// Mojom libraries importing this one will use these identifiers when building
+// TypeReference objects.
 {% for enum in enums %}
-{{enum_macros.define(enum)}}
+var ID_{{enum|mojom_type_identifier}} string = "{{enum|mojom_type_identifier}}"
+{% endfor %}
+{% for struct in structs %}
+var ID_{{struct|mojom_type_identifier}} string = "{{struct|mojom_type_identifier}}"
+{% endfor %}
+{% for union in unions %}
+var ID_{{union|mojom_type_identifier}} string = "{{union|mojom_type_identifier}}"
+{% endfor %}
+{% for interface in interfaces %}
+var ID_{{interface|mojom_type_identifier}} string = "{{interface|mojom_type_identifier}}"
+{% endfor %}
+
+{% set mapping = package|qualified(None, true) ~ 'Desc__' %}
+var {{mapping}} = make(map[string]{{typepkg}}UserDefinedType)
+func init() {
+  {% for enum in enums %}
+  {{mojom_reference_macros.registerType(mapping, typepkg, package, enum)}}
+  {%- endfor %}
+  {% for struct in structs %}
+  {{mojom_reference_macros.registerType(mapping, typepkg, package, struct)}}
+  {%- endfor %}
+  {% for union in unions %}
+  {{mojom_reference_macros.registerType(mapping, typepkg, package, union)}}
+  {%- endfor %}
+  {% for interface in interfaces %}
+  {{mojom_reference_macros.registerType(mapping, typepkg, package, interface)}}
+  {%- endfor %}
+
+  {% for mi in mojom_imports.values() %}
+  {%- if mi ~ '.' != typepkg and mi ~ '.' != descpkg %}
+  for s, udt := range {{mi}}.Descriptor() {
+    {{mapping}}[s] = udt
+  }
+  {% endif -%}
+  {% endfor %}
+}
+func Descriptor() map[string]{{typepkg}}UserDefinedType {

[rudominer, 2015/10/22 21:28:48]

I don't understand why you want this function. You already are providing some
standard ways for application developers to access the type information, namely
to use the ServiceDescription() functions on ServiceRequest or ServiceFactory.
So who is this function for? It is exported (name begins with a capital 'D') and
also the name is not obfuscated (name does not begin or end with "__" for
example.) For use within your own generated code (as opposed to an application
developer calling it) you could directly access the global map variable. For
example looking in the generated file echo.mojom.go I see that Descriptor() is
implemented as:
func Descriptor() map[string]mojom_types.UserDefinedType {
  return EchoDesc__
}
so instead of this the code that you are generating could access EchoDesc__
directly, no?

Can we get rid of this function if it is not really needed?

If there is some good reason to have this function in addition to the
ServiceDescription() functions mentioned above, should we change its name to be
less simple to avoid any possible conflicts? For example looking at the
generated file echo.mojom.go I see that we have a function called
"CreateMessagePipeForEcho()". We could call this method
GetServiceDescriptionForEcho() and have it return a ServiceDescription.

[alexfandrianto, 2015/10/22 22:58:11]

My reason for having Descriptor() is so that the map[string]UserDefinedType can
be computed when importing other mojom files.

If A imports B, which imports C, then A will have a hard time getting complete
type information unless it is able to access the information publicly from B
(who in turn grabbed it from C).

It's easier to call a fixed, common exported function name rather than a varying
variable name, so I chose Descriptor(). I don't really intend for users to call
Descriptor() directly though, so I take your point about naming it differently.
I will name it GetAllMojomTypeDefinitions().

The capitalized EchoDesc__ is an oversight. It should be lowercased instead.

+  return {{mapping}}
+}
+{% endif %}
+
+{# Enum definitions #}
+{%- for enum in enums %}
+{{enum_macros.define(enum, typepkg, package)}}
 {%- endfor %}
 
 {#- Interface definitions #}
 {% for interface in interfaces %}
-{{interface_macros.define(interface)}}
+{{interface_macros.define(interface, descpkg, typepkg, package)}}
 {%- endfor %}
 
 {#- Struct definitions #}
 {% for struct in structs %}
-{{struct_macros.define(struct)}}
+{{struct_macros.define(struct, typepkg, package)}}
 {%- endfor %}
 
 {#- Union definitions #}
 {% for union in unions %}
-{{union_macros.define(union)}}
+{{union_macros.define(union, typepkg, package)}}
 {%- endfor %}