DevTools: Protocol handler generator for content

content/browser/devtools/protocol/devtools_protocol_handler_generator.py

+#!/usr/bin/env python
+# Copyright 2014 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import sys
+import string
+import json
+
+input_json_path = sys.argv[1]
+output_h_path = sys.argv[2]
+output_cc_path = sys.argv[3]
+
+header = """\
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// THIS FILE IS AUTOGENERATED. DO NOT EDIT.
+// Generated by
+//  content/public/browser/devtools_protocol_handler_generator.py from
+//  third_party/WebKit/Source/devtools/protocol.json
+"""
+
+template_h = string.Template(header + """\
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_
+#define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_
+
+#include "content/browser/devtools/devtools_protocol.h"
+#include "content/browser/devtools/protocol/devtools_protocol_frontend.h"
+
+namespace content {
+
+class RenderViewHostImpl;
+class DevToolsProtocolHandlerImpl;
+
+namespace devtools {
+
+${types}\
+
+${handlers}\
+
+${frontends}\
+
+}  // namespace devtools
+
+class DevToolsProtocolHandlerImpl : public DevToolsProtocol::Handler {
+ public:
+  typedef DevToolsProtocolFrontend::Response Response;
+  typedef DevToolsProtocolFrontend::ResponseStatus ResponseStatus;
+
+  DevToolsProtocolHandlerImpl();
+  virtual ~DevToolsProtocolHandlerImpl();
+  void OnClientDetached();
+  void SetRenderViewHost(RenderViewHostImpl* host);
+
+${getters}\
+
+ private:
+${friends}\
+
+${callbacks}\
+
+${to_value}\
+
+${fields}\
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_
+""")
+
+tmpl_typedef = string.Template("""\
+namespace ${domain} {
+typedef ${param_type} ${declared_name};
+}  // namespace ${domain}
+""")
+
+tmpl_struct = string.Template("""\
+namespace ${domain} {
+struct ${declared_name} {
+ public:
+  ${declared_name}();
+
+${setters}\
+
+ private:
+  friend class ::content::DevToolsProtocolHandlerImpl;
+
+${fields}\
+};
+}  // namespace ${domain}
+""")
+
+tmpl_struct_setter = string.Template("""\
+  void set_${param}(${pass_type} ${param});
+""")
+
+tmpl_struct_field = string.Template("""\
+  ${param_type} ${param}_;
+  bool has_${param}_;
+""")
+
+tmpl_handler = string.Template("""\
+namespace ${domain} {
+class ${Domain}Handler;
+}  // namespace domain
+""")
+
+tmpl_frontend = string.Template("""\
+namespace ${domain} {
+class Frontend : public DevToolsProtocolFrontend {
+ public:
+  Frontend(const EventCallback& event_callback);
+  virtual ~Frontend();
+
+${events}\
+};
+}  // namespace ${domain}
+""")
+
+tmpl_event = string.Template("""\
+  void ${Event}($params);
+""")
+
+tmpl_event_param = string.Template("${pass_type} ${param}")
+
+tmpl_getter = string.Template("""\
+  devtools::${domain}::${Domain}Handler* ${domain}();
+""")
+
+tmpl_friend = string.Template("""\
+  friend class devtools::${domain}::Frontend;
+""")
+
+tmpl_callback = string.Template("""\
+  scoped_refptr<DevToolsProtocol::Response> On${Domain}${Command}(
+      scoped_refptr<DevToolsProtocol::Command> command);
+""")
+
+tmpl_to_value = string.Template("""\
+  static base::Value* ToValue(${pass_type} src);
+""")
+
+tmpl_field = string.Template("""\
+  scoped_ptr<devtools::${domain}::${Domain}Handler> ${domain}_handler_;
+""")
+
+template_cc = string.Template(header + """\
+
+#include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
+
+#include "base/bind.h"
+${includes}\
+
+namespace content {
+
+DevToolsProtocolHandlerImpl::DevToolsProtocolHandlerImpl() {
+${initializations}\
+}
+
+DevToolsProtocolHandlerImpl::~DevToolsProtocolHandlerImpl() {
+}
+
+void DevToolsProtocolHandlerImpl::OnClientDetached() {
+${client_detached}\
+}
+
+void DevToolsProtocolHandlerImpl::SetRenderViewHost(RenderViewHostImpl* host) {
+${set_rvh}\
+}
+
+${getters}\
+
+${callbacks}\
+
+${to_value}\
+
+namespace devtools {
+
+${types}\
+
+${frontends}\
+
+}  // namespace devtools
+
+}  // namespace content
+""")
+
+tmpl_include = string.Template("""\
+#include "content/browser/devtools/protocol/${domain}_handler.h"
+""")
+
+tmpl_register = string.Template("""\
+  RegisterCommandHandler(
+      "${Domain}.${command}",
+      base::Bind(&DevToolsProtocolHandlerImpl::On${Domain}${Command},
+                 base::Unretained(this)));
+""")
+
+tmpl_init_handler = string.Template("""\
+  ${domain}_handler_.reset(new devtools::${domain}::${Domain}Handler());
+""")
+
+tmpl_init_frontend = string.Template("""\
+  ${domain}_handler_->SetFrontend(make_scoped_ptr(
+      new devtools::${domain}::Frontend(
+          base::Bind(&DevToolsProtocolHandlerImpl::SendNotification,
+                     base::Unretained(this)))));
+""")
+
+tmpl_client_detached = string.Template("""\
+  ${domain}_handler_->OnClientDetached();
+""")
+
+tmpl_set_rvh = string.Template("""\
+  ${domain}_handler_->SetRenderViewHost(host);
+""")
+
+tmpl_getter_impl = string.Template("""\
+devtools::${domain}::${Domain}Handler*
+DevToolsProtocolHandlerImpl::${domain}() {
+  return ${domain}_handler_.get();
+}
+""")
+
+tmpl_callback_impl = string.Template("""\
+scoped_refptr<DevToolsProtocol::Response>
+DevToolsProtocolHandlerImpl::On${Domain}${Command}(
+    scoped_refptr<DevToolsProtocol::Command> command) {
+${prep}\
+  Response response = ${domain}_handler_->${Command}(${args});
+  switch (response.status()) {
+    case ResponseStatus::RESPONSE_STATUS_FALLTHROUGH:
+      return NULL;
+    case ResponseStatus::RESPONSE_STATUS_OK:
+      break;
+    case ResponseStatus::RESPONSE_STATUS_INVALID_PARAMS:
+      return command->InvalidParamResponse(response.message());
+    case ResponseStatus::RESPONSE_STATUS_INTERNAL_ERROR:
+      return command->InternalErrorResponse(response.message());
+    case ResponseStatus::RESPONSE_STATUS_SERVER_ERROR:
+      return command->ServerErrorResponse(response.message());
+  }
+  base::DictionaryValue* dict = new base::DictionaryValue();
+${wrap}\
+  return command->SuccessResponse(dict);
+}
+""")
+
+params_prep = """\
+  base::DictionaryValue* params = command->params();
+  if (!params)
+    return command->NoSuchMethodErrorResponse();
+"""
+
+tmpl_prep_req = string.Template("""\
+  ${param_type} in_${param}${init};
+  if (!params->Get${Type}("${proto_param}", &in_${param}))
+    return command->InvalidParamResponse("${proto_param}");
+""")
+
+tmpl_prep_req_list = string.Template("""\
+  base::ListValue* list_${param} = NULL;
+  if (!params->GetList("${proto_param}", &list_${param}))
+    return command->InvalidParamResponse("${proto_param}");
+  ${param_type} in_${param};
+  for (base::ListValue::const_iterator it = list_${param}->begin();
+      it != list_${param}->end(); ++it) {
+    ${item_type} item${item_init};
+    if (!(*it)->GetAs${ItemType}(&item))
+      return command->InvalidParamResponse("${proto_param}");
+    in_${param}.push_back(item);
+  }
+""")
+
+tmpl_prep_opt = string.Template("""\
+  ${param_type} in_${param}${init};
+  bool ${param}_found = params->Get${Type}("${proto_param}", &in_${param});
+""")
+
+tmpl_prep_output = string.Template("""\
+  ${param_type} out_${param}${init};
+""")
+
+tmpl_arg_req = string.Template("in_${param}")
+
+tmpl_arg_opt = string.Template("${param}_found ? &in_${param} : NULL")
+
+tmpl_arg_output = string.Template("&out_${param}")
+
+tmpl_to_value_impl = string.Template("""\
+// static
+base::Value* DevToolsProtocolHandlerImpl::ToValue(${pass_type} src) {
+  base::DictionaryValue* dict = new base::DictionaryValue();
+${dchecks}\
+${wrap}\
+  return dict;
+}
+""")
+
+tmpl_dcheck = string.Template("""\
+  DCHECK(src.has_${param}_);
+""")
+
+tmpl_struct_impl = string.Template("""\
+namespace ${domain} {
+
+${declared_name}::${declared_name}()
+    : ${fields} {
+}
+
+${setters}\
+
+}  // namespace ${domain}
+""")
+
+tmpl_struct_field_init = string.Template("has_${param}_(false)")
+
+tmpl_struct_setter_impl = string.Template("""\
+void ${declared_name}::set_${param}(${pass_type} ${param}) {
+  ${param}_ = ${param};
+  has_${param}_ = true;
+}
+""")
+
+tmpl_frontend_impl = string.Template("""\
+namespace ${domain} {
+
+Frontend::Frontend(const EventCallback& event_callback)
+    : DevToolsProtocolFrontend(event_callback) {
+}
+
+Frontend::~Frontend() {
+}
+
+${events}\
+
+}  // namespace ${domain}
+""")
+
+tmpl_event_impl = string.Template("""\
+void Frontend::${Event}(${params}) {
+  base::DictionaryValue* dict = new base::DictionaryValue();
+${wrap}\
+  SendNotification("${Domain}.${event}", dict);
+}
+""")
+
+tmpl_wrap = string.Template("""\
+  dict->Set${Type}("${proto_param}", ${var_name});
+""")
+
+tmpl_wrap_dict = string.Template("""\
+  dict->Set("${proto_param}",
+      DevToolsProtocolHandlerImpl::ToValue(${var_name}));
+""")
+
+tmpl_wrap_obj = string.Template("""\
+  dict->Set("${proto_param}", ${var_name});
+""")
+
+tmpl_wrap_list = string.Template("""\
+  base::ListValue* list_${param} = new base::ListValue();
+  for (${param_type}::const_iterator it = ${var_name}.begin();
+      it != ${var_name}.end(); ++it) {
+${append}\
+  }
+  dict->Set("${proto_param}", list_${param});
+""")
+
+tmpl_append = string.Template("""\
+    list_${param}->Append${Type}(*it);
+""")
+
+tmpl_append_dict = string.Template("""\
+    list_${param}->Append(DevToolsProtocolHandlerImpl::ToValue(*it));
+""")
+
+tmpl_append_obj = string.Template("""\
+    list_${param}->Append(*it);
+""")
+
+tmpl_wrap_opt = string.Template("""\
+  if (${cond_name})
+    dict->Set${Type}("${proto_param}", ${var_name});
+""")
+
+tmpl_typename = string.Template("devtools::${domain}::${declared_name}")
+
+def Capitalize(s):
+  return s[:1].upper() + s[1:]
+
+def Decapitalize(s):
+  return s.lower()
+
+def Uncamelcase(s):
+  result = ""
+  for i, c in enumerate(s):
+    if c.isupper():
+      if (i < len(s)-1) and s[i+1].islower() or (i > 0) and s[i-1].islower():

[dgozman, 2014/09/11 13:43:22]

Does this work for "ContentOfHTMLFile"? We should convert acronyms to lower case
as well.

[vkuzkokov, 2014/09/11 17:19:20]

_content_of_html_file. Fixed to remove underscore in the beginning.

+        result += "_"
+      result += c.lower()
+    else:
+      result += c
+  return result
+
+types = {}
+json_api = json.loads(open(input_json_path, "r").read())
+type_decls = []
+type_impls = []
+to_value = []
+to_value_impls = []
+
+for json_domain in json_api["domains"]:
+  if "types" in json_domain:
+    for json_type in json_domain["types"]:
+      types["%s.%s" % (json_domain["domain"], json_type["id"])] = json_type
+
+def DeclareStruct(json, mapping):
+  setters = []
+  fields = []
+  fields_init = []
+  setter_impls = []
+  dchecks = []
+  wrap = []
+  if "properties" in json:

[dgozman, 2014/09/11 13:43:22]

How there may be no "properties" here?

[vkuzkokov, 2014/09/11 17:19:20]

API changed. No I pass json["properties"] for types.

+    for json_prop in json["properties"]:
+      prop_map = mapping.copy()
+      prop_map.pop("append", None)
+      prop_map.pop("wrap", None)
+      prop_map.pop("prep_req", None)
+      prop_map.pop("pass_type", None)
+      prop_map["proto_param"] = json_prop["name"]
+      prop_map["param"] = Uncamelcase(json_prop["name"])
+      prop_map["var_name"] = "src.%s_" % prop_map["param"]
+      ResolveType(json_prop, prop_map)
+      prop_map["declared_name"] = mapping["declared_name"]
+      setters.append(tmpl_struct_setter.substitute(prop_map))
+      fields.append(tmpl_struct_field.substitute(prop_map))
+      fields_init.append(tmpl_struct_field_init.substitute(prop_map))
+      setter_impls.append(tmpl_struct_setter_impl.substitute(prop_map))
+      if json_prop.get("optional"):
+        wrap.append(tmpl_wrap_opt.substitute(prop_map,
+            cond_name = "src.has_%s_" % prop_map["param"]))
+      else:
+        dchecks.append(tmpl_dcheck.substitute(prop_map));
+        wrap.append(prop_map["wrap"])
+  type_decls.append(tmpl_struct.substitute(mapping,
+      setters = "".join(setters),
+      fields = "".join(fields)))
+  type_impls.append(tmpl_struct_impl.substitute(mapping,
+      fields = ",\n      ".join(fields_init),
+      setters = "\n".join(setter_impls)))
+  to_value.append(tmpl_to_value.substitute(mapping))
+  to_value_impls.append(tmpl_to_value_impl.substitute(mapping,
+      dchecks = "".join(dchecks),
+      wrap = "".join(wrap)))
+
+def ResolveType(json, mapping):
+  mapping["init"] = ""
+  if "$ref" in json:
+    dot_pos = json["$ref"].find(".")
+    if dot_pos == -1:
+      domain_name = mapping["Domain"]
+      type_name = json["$ref"]
+    else:
+      domain_name = json["$ref"][:dot_pos]
+      type_name = json["$ref"][dot_pos + 1:]
+    json_type = types["%s.%s" % (domain_name, type_name)]
+    mapping["declared_name"] = Capitalize(type_name)
+    mapping["param_type"] = tmpl_typename.substitute(mapping)
+    ResolveType(json_type, mapping)
+    if not "___mark" in json_type:
+      json_type["___mark"] = True;
+      if (json_type.get("type") == "object") and ("properties" in json_type):
+        DeclareStruct(json_type, mapping)
+      else:
+        type_decls.append(tmpl_typedef.substitute(mapping))
+    mapping["param_type"] = tmpl_typename.substitute(mapping)
+  elif "type" in json:

[dgozman, 2014/09/11 13:43:22]

I'd split this function into ResolveRef, ResolveArray, ResolveObject and
ResolvePrimitive.

[vkuzkokov, 2014/09/11 17:19:20]

Done.

+    json_type = json["type"]
+    if json_type == "array":
+      items_map = mapping.copy()
+      ResolveType(json["items"], items_map)
+      mapping["param_type"] = "std::vector<%s>" % items_map["param_type"]
+      mapping["Type"] = "List"
+      mapping["wrap"] = tmpl_wrap_list.substitute(mapping,
+          append = items_map["append"])
+      mapping["prep_req"] = tmpl_prep_req_list.substitute(mapping,
+          item_type = items_map["param_type"],
+          item_init = items_map["init"],
+          ItemType = items_map["Type"])
+    elif json_type == "boolean":
+      mapping["param_type"] = "bool"
+      mapping["Type"] = "Boolean"
+      mapping["init"] = " = false"
+    elif json_type == "integer":
+      mapping["param_type"] = "int"
+      mapping["Type"] = "Integer"
+      mapping["init"] = " = 0"
+    elif json_type == "number":
+      mapping["param_type"] = "double"
+      mapping["Type"] = "Double"
+      mapping["init"] = " = 0.0"
+    elif json_type == "object":
+      mapping["Type"] = "Dictionary"
+      if "properties" in json:
+        if not "declared_name" in mapping:
+          if "Command" in mapping:
+            subdomain = mapping["Command"]
+          elif "Event" in mapping:
+            subdomain = mapping["Event"]
+          else:
+            raise Exception("Unrecognized subdomain")
+          mapping["declared_name"] = ("%s%s" %
+              (subdomain, Capitalize(mapping["proto_param"])))
+          mapping["param_type"] = tmpl_typename.substitute(mapping)
+          DeclareStruct(json_type, mapping)

[dgozman, 2014/09/11 13:43:22]

This call looks strange: json_type is not a json, but a string.

[vkuzkokov, 2014/09/11 17:19:20]

Fixed.

+        mapping["append"] = tmpl_append_dict.substitute(mapping)
+        mapping["wrap"] = tmpl_wrap_dict.substitute(mapping)
+        mapping["pass_type"] = "const %s&" % mapping["param_type"]
+      else:
+        mapping["param_type"] = "base::DictionaryValue*"
+        mapping["append"] = tmpl_append_obj.substitute(mapping)
+        mapping["wrap"] = tmpl_wrap_obj.substitute(mapping)
+    elif json_type == "string":
+      mapping["param_type"] = "std::string"
+      mapping["pass_type"] = "const std::string&"
+      mapping["Type"] = "String"
+    else:
+      raise Exception("Unknown type: %s" % json_type)
+  else:
+    raise Exception("Unknown type at %s.%s %s" %
+        (mapping["Domain"], mapping["command"], mapping["proto_param"]))
+  if not ("wrap" in mapping):
+    mapping["wrap"] = tmpl_wrap.substitute(mapping)
+  if not ("append" in mapping):
+    mapping["append"] = tmpl_append.substitute(mapping)
+  if not ("prep_req" in mapping):
+    mapping["prep_req"] = tmpl_prep_req.substitute(mapping)
+  if not ("pass_type" in mapping):
+    mapping["pass_type"] = mapping["param_type"]
+
+handlers = []
+frontends = []
+getters = []
+friends = []
+callbacks = []
+fields = []
+
+includes = []
+initializations = []
+client_detached = []
+set_rvh = []
+getter_impls = []
+callback_impls = []
+frontend_impls = []
+
+for json_domain in json_api["domains"]:
+  domain_map = {}
+  domain_map["Domain"] = json_domain["domain"]
+  domain_map["domain"] = Decapitalize(json_domain["domain"])
+
+  events = []
+  event_impls = []
+  domain_has_commands = False
+  domain_has_events = False
+
+  if "commands" in json_domain:
+    for json_command in json_domain["commands"]:
+      if (not ("handlers" in json_command) or
+          not ("browser" in json_command["handlers"])):
+        continue
+      domain_has_commands = True
+
+      command_map = domain_map.copy()
+      command_map["command"] = json_command["name"]
+      command_map["Command"] = Capitalize(json_command["name"])
+
+      prep = []
+      args = []
+      wrap = []
+
+      if "parameters" in json_command:
+        for json_param in json_command["parameters"]:
+          param_map = command_map.copy()
+          param_map["proto_param"] = json_param["name"]
+          param_map["param"] = Uncamelcase(json_param["name"])
+          param_map["var_name"] = "in_%s" % param_map["param"]
+
+          ResolveType(json_param, param_map)
+          if len(prep) == 0:
+            prep.append(params_prep)
+          if json_param.get("optional"):
+            if param_map["Type"] in ["List", "Dictionary"]:
+              # TODO(vkuzkokov) implement transformation of base::ListValue
+              # to std::vector and base::DictonaryValue to struct.
+              raise Exception(
+                  "Optional array and object parameters are not implemented")
+            prep.append(tmpl_prep_opt.substitute(param_map))
+            args.append(tmpl_arg_opt.substitute(param_map))
+          else:
+            prep.append(param_map["prep_req"])
+            args.append(tmpl_arg_req.substitute(param_map))
+
+      if "returns" in json_command:
+        for json_param in json_command["returns"]:
+          param_map = command_map.copy()
+          param_map["proto_param"] = json_param["name"]
+          param_map["param"] = Uncamelcase(json_param["name"])
+          param_map["var_name"] = "out_%s" % param_map["param"]
+
+          if json_param.get("optional"):
+            # TODO(vkuzkokov) implement Optional<T> for value types
+            raise Exception("Optional return values are not implemented")
+          ResolveType(json_param, param_map)
+          prep.append(tmpl_prep_output.substitute(param_map))
+          args.append(tmpl_arg_output.substitute(param_map))
+          wrap.append(param_map["wrap"])
+
+      initializations.append(tmpl_register.substitute(command_map))
+      callbacks.append(tmpl_callback.substitute(command_map))
+      callback_impls.append(tmpl_callback_impl.substitute(command_map,
+          prep = "".join(prep),
+          args = ", ".join(args),
+          wrap = "".join(wrap)))
+
+  if "events" in json_domain:
+    for json_event in json_domain["events"]:
+      if (not ("handlers" in json_event) or
+          not ("browser" in json_event["handlers"])):
+        continue
+      domain_has_events = True
+
+      event_map = domain_map.copy()
+      event_map["event"] = json_event["name"]
+      event_map["Event"] = Capitalize(json_event["name"])
+
+      params = []
+      wrap = []
+
+      if "parameters" in json_event:
+        for json_param in json_event["parameters"]:
+          param_map = event_map.copy()
+          param_map["proto_param"] = json_param["name"]
+          param_map["param"] = Uncamelcase(json_param["name"])
+          param_map["var_name"] = param_map["param"]
+
+          if json_param.get("optional"):
+            # TODO(vkuzkokov) force passing by pointer and check for NULL
+            raise Exception("Optional event params are not implemented")
+          ResolveType(json_param, param_map)
+          params.append(tmpl_event_param.substitute(param_map))
+          wrap.append(param_map["wrap"])
+
+      event_map["params"] = ", ".join(params)
+      events.append(tmpl_event.substitute(event_map))
+      event_impls.append(tmpl_event_impl.substitute(event_map,
+          wrap = "".join(wrap)))
+
+  if not (domain_has_commands or domain_has_events):
+    continue
+  handlers.append(tmpl_handler.substitute(domain_map))
+  getters.append(tmpl_getter.substitute(domain_map))
+  fields.append(tmpl_field.substitute(domain_map))
+  includes.append(tmpl_include.substitute(domain_map))
+  initializations.append(tmpl_init_handler.substitute(domain_map))
+  client_detached.append(tmpl_client_detached.substitute(domain_map))
+  set_rvh.append(tmpl_set_rvh.substitute(domain_map))
+  getter_impls.append(tmpl_getter_impl.substitute(domain_map))
+  if domain_has_events:
+    frontends.append(tmpl_frontend.substitute(domain_map,
+        events = "".join(events)))
+    friends.append(tmpl_friend.substitute(domain_map))
+    initializations.append(tmpl_init_frontend.substitute(domain_map))
+    frontend_impls.append(tmpl_frontend_impl.substitute(domain_map,
+        events = "\n".join(event_impls)))
+
+output_h_file = open(output_h_path, "w")
+output_cc_file = open(output_cc_path, "w")
+
+output_h_file.write(template_h.substitute({},
+    types = "\n".join(type_decls),
+    handlers = "".join(handlers),
+    getters = "".join(getters),
+    friends = "".join(friends),
+    callbacks = "".join(callbacks),
+    to_value = "".join(to_value),
+    fields = "".join(fields),
+    frontends = "\n".join(frontends)))
+
+output_cc_file.write(template_cc.substitute({},
+    includes = "".join(includes),
+    initializations = "".join(initializations),
+    client_detached = "".join(client_detached),
+    set_rvh = "".join(set_rvh),
+    getters = "\n".join(getter_impls),
+    callbacks = "\n".join(callback_impls),
+    to_value = "\n".join(to_value_impls),
+    types = "\n".join(type_impls),
+    frontends = "\n".join(frontend_impls)))