Improvements to JSON Schema Compiler's Dart Generation

tools/json_schema_compiler/dart_generator.py

 # Copyright (c) 2012 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.
 """
 Generator language component for compiler.py that adds Dart language support.
 """
 
 from code import Code
 from model import *
 from schema_util import *
@@ skipping 13 matching lines @@
 
   def Generate(self, namespace):
     return _Generator(namespace, self._dart_overrides_dir).Generate()
 
 class _Generator(object):
   """A .dart generator for a namespace.
   """
 
   def __init__(self, namespace, dart_overrides_dir=None):
     self._namespace = namespace
     self._types = namespace.types

[not at google - send to devlin, 2013/02/07 01:16:41]

I didn't notice that you added this alias... it doesn't really seem very
valuable.

 
     # Build a dictionary of Type Name --> Custom Dart code.
     self._type_overrides = {}
     if dart_overrides_dir is not None:
       for filename in os.listdir(dart_overrides_dir):
         if filename.startswith(namespace.unix_name):
           with open(os.path.join(dart_overrides_dir, filename)) as f:
             # Split off the namespace and file extension, leaving just the type.
             type_path = '.'.join(filename.split('.')[1:-1])
             self._type_overrides[type_path] = f.read()
 
+    # TODO(sashab): Add all inline type definitions to the global Types
+    # dictionary.
+    # List types do not apply - their types are automatically generated instead
+    # of the list type.
+
   def Generate(self):
     """Generates a Code object with the .dart for the entire namespace.
     """
     c = Code()
-    (c.Append(LICENSE)
+    (c.Append(LICENSE.strip())

[not at google - send to devlin, 2013/02/07 01:16:41]

Why strip()?

P.S. you could make LICENCE a Code() object and then use Cblock here
(automatically adds the blank line) - if you want. I don't mind either way.

[sashab, 2013/02/08 01:53:34]

The problem is getting the LICENSE (and the triple quotes) to fit inside the
code. If you look at where its defined, its hard to fit it to 80 chars since it
barely fits within 80 chars itself.

Managed to get it to fit, though, removing the need for .strip().

+      .Append()
       .Append('// Generated from namespace: %s' % self._namespace.name)
       .Append()
       .Append('part of chrome;'))
 
     if self._types:
       (c.Append()
         .Append('/**')
         .Append(' * Types')
         .Append(' */')
       )
-    for type_name in self._types:
-      c.Concat(self._GenerateType(self._types[type_name]))
+    for type_ in self._types.values():
+      # Check for custom dart for this whole type.
+      c.Append()
+      if not self._ConcatOverride(c, [type_.name], doc_property=type_):

[not at google - send to devlin, 2013/02/07 01:16:41]

Without looking at the implementation of ConcatOverride: can it return a Code
object rather than accepting one to concat onto? Return None if it doesn't? I
think I meant to make this comment last time around but forgot.

You could be super tricky like

override = self._GetOverride([type_.name], doc_property=true)
c.Cblock(override if override is not None else self._GenerateType(type_))

but wow ternarys are ugly. Whatever, use your judgement.

[sashab, 2013/02/08 01:53:34]

This is pretty much what I wanted to do before. Not super-tricky, but I wanted
to get a code object and then be like "if it exists, add it on, blah blah"...
But it seemed much simpler to just return T/F.

Changed it to return a code object, arguably more readable. Refactored the way
getters/setters work to use the nice ternary operators too =)

+        c.Concat(self._GenerateType(type_))

[not at google - send to devlin, 2013/02/07 01:16:41]

I suggest using Cblock() here rather than the c.Append() before. In fixing
whitespace things in the C++ compiler I've found that the easiest way to get
things right is for Code to generate without any blank lines before/after and
let the Concat'ters of the code add any spacing (usually with Cblock if they
desire that).

Since I presume that you want a blank line between each type definition, use
Cblock here. If you always want a blank line between /** Types */ and the first
type, do it there (up on line 65).

[sashab, 2013/02/08 01:53:34]

Don't think I need a blank line between /** Types */ and the first type. The
problem with CBlock() is a lot of the places I'm using .Append() need strings,
and CBlock() wants a code object.

 
     if self._namespace.events:
       (c.Append()
         .Append('/**')
         .Append(' * Events')
         .Append(' */')
       )
     for event_name in self._namespace.events:
       c.Concat(self._GenerateEvent(self._namespace.events[event_name]))
 
     (c.Append()
       .Append('/**')
       .Append(' * Functions')
       .Append(' */')
     )
     c.Concat(self._GenerateMainClass())
 
     return c
 
   def _GenerateType(self, type_):
     """Given a Type object, returns the Code with the .dart for this
     type's definition.
 
     Assumes this type is a Parameter Type (creatable by user), and creates an
     object that extends ChromeObject. All parameters are specifiable as named
     arguments in the constructor, and all methods are wrapped with getters and
     setters that hide the JS() implementation.
+
+    List objects with inline types are created with a definition for the inline
+    type instead.
     """
+    if type_.property_type is PropertyType.ARRAY:
+      # This is an inline type definition: generate that type instead.
+      type_ = type_.item_type
+      # Save this to global types, just so future functions don't get confused.
+      self._types[type_.name] = type_

[not at google - send to devlin, 2013/02/07 01:16:41]

This modifies the original model (since types_ is just a reference into the
model). That probably isn't what you want to do.

Why is this necessary anyway?

[sashab, 2013/02/08 01:53:34]

A little complicated... Basically for objects that are actually arrays. In this
case, we want a wrapper for the actual object, not the array. May not be needed
anymore so removed.

+
     c = Code()
-    (c.Append()
-      .Concat(self._GenerateDocumentation(type_))
+    (c.Concat(self._GenerateDocumentation(type_))
       .Sblock('class %(type_name)s extends ChromeObject {')
     )
 
     # Check whether this type has function members. If it does, don't allow
     # public construction.
     add_public_constructor = all(not self._IsFunction(p.type_)
                                  for p in type_.properties.values())
     constructor_fields = [self._GeneratePropertySignature(p)
                           for p in type_.properties.values()]
 
@@ skipping 23 matching lines @@
       (c.Append()
         .Append('/*')
         .Append(' * Public accessors')
         .Append(' */')
       )
     for prop in properties:
       type_name = self._GetDartType(prop.type_)
 
       # Check for custom dart for this whole property.
       c.Append()
-      if not self._ConcatOverride(c, type_, prop, add_doc=True):
+      if not self._ConcatOverride(c, [type_.name, prop.name],
+                                  doc_property=prop):
         # Add the getter.
-        if not self._ConcatOverride(c, type_, prop, key_suffix='.get',
-                                       add_doc=True):
+        if not self._ConcatOverride(c, [type_.name, prop.name, '.get'],
+                                    doc_property=prop):
           # Add the documentation for this property.
           c.Concat(self._GenerateDocumentation(prop))
 
-          if (self._IsBaseType(prop.type_)
-              or self._IsListOfBaseTypes(prop.type_)):
+          if (self._IsBaseType(prop.type_, list_as_base=True)):
             c.Append("%s get %s => JS('%s', '#.%s', this._jsObject);" %
                 (type_name, prop.name, type_name, prop.name))
           elif self._IsSerializableObjectType(prop.type_):
             c.Append("%s get %s => new %s._proxy(JS('', '#.%s', "
                      "this._jsObject));"
               % (type_name, prop.name, type_name, prop.name))
           elif self._IsListOfSerializableObjects(prop.type_):
-            (c.Sblock('%s get %s {' % (type_name, prop.name))
-              .Append('%s __proxy_%s = new %s();' % (type_name, prop.name,
-                                                     type_name))
+            array_type, array_type_name = prop.type_, type_name
+            if prop.type_.property_type is not PropertyType.ARRAY:
+              # This is a reference to an array object, not the object itself.
+              array_type = self._types[prop.type_.ref_type]

[not at google - send to devlin, 2013/02/07 01:16:41]

I think you should re-use CppTypeGenerator rather than reimplementing the ref
logic.

And by "reuse" I mean pull out the initialization logic, FindType, and FollowRef
(make FindType public) into a new class like TypeGraph. Construct TypeGraph
rather than CppTypeGenerator in the compiler, pass it everywhere, and the h/c
generators can construct the CppTypeGenerator themselves from an injected
TypeGraph.

If you read through the c/h generators and look for FollowRef you'll see an
idiom where methods right at the start do something like

concrete_type = type_helper_.FollowRef(type_)

and then deal with the concrete type rather than the ref type. That won't always
be the right thing to do obviously - often you'll want to know that it is
actually a ref - but when generating the instructions typically you only care
about the concrete type.

I think many places where you're looking at REF would be moot if you used that
idiom.

[sashab, 2013/02/08 01:53:34]

May no longer be needed; temporarily removed.

+              array_type_name =self._GetDartType(array_type)
+            (c.Sblock('%s get %s {' % (array_type_name, prop.name))
+              .Append('%s __proxy_%s = new %s();' % (array_type_name, prop.name,
+                                                     array_type_name))
               .Sblock("for (var o in JS('List', '#.%s', this._jsObject)) {" %
                       prop.name)
               .Append('__proxy_%s.add(new %s._proxy(o));' % (prop.name,
-                   self._GetDartType(prop.type_.item_type)))
+                   self._GetDartType(array_type.item_type)))
               .Eblock('}')
               .Append('return __proxy_%s;' % prop.name)
               .Eblock('}')
             )
           elif self._IsObjectType(prop.type_):
             # TODO(sashab): Think of a way to serialize generic Dart objects.
             c.Append("%s get %s => JS('%s', '#.%s', this._jsObject);" %
                 (type_name, prop.name, type_name, prop.name))
           else:
             raise Exception(
                 "Could not generate wrapper for %s.%s: unserializable type %s" %
                 (type_.name, prop.name, type_name)
             )
 
         # Add the setter.
         c.Append()
-        if not self._ConcatOverride(c, type_, prop, key_suffix='.set'):
+        if not self._ConcatOverride(c, [type_.name, prop.name, '.set']):
           wrapped_name = prop.name
           if not self._IsBaseType(prop.type_):
             wrapped_name = 'convertArgument(%s)' % prop.name
 
           (c.Sblock("void set %s(%s %s) {" % (prop.name, type_name, prop.name))
             .Append("JS('void', '#.%s = #', this._jsObject, %s);" %
               (prop.name, wrapped_name))
             .Eblock("}")
           )
 
     # Now add all the methods.
     methods = [t for t in type_.properties.values()
                if self._IsFunction(t.type_)]
     if methods:
       (c.Append()
         .Append('/*')
         .Append(' * Methods')
         .Append(' */')
       )
     for prop in methods:
-      c.Concat(self._GenerateFunction(prop.type_.function))
+      # Check if there's an override for this method.
+      if not self._ConcatOverride(c, [type_.name, prop.name],
+                                    doc_property=prop):
+        c.Concat(self._GenerateFunction(prop.type_.function))
 
     (c.Eblock('}')
       .Substitute({
         'type_name': type_.simple_name,
         'constructor_fields': ', '.join(constructor_fields)
       })
     )
 
     return c
 
   def _GenerateDocumentation(self, prop):
     """Given an object, generates the documentation for this object (as a
     code string) and returns the Code object.
 
     Returns an empty code object if the object has no documentation.
 
     Uses triple-quotes for the string.
     """
     c = Code()
     if prop.description is not None:
       for line in prop.description.split('\n'):
         c.Comment(line, comment_prefix='/// ')
     return c
 
   def _GenerateFunction(self, f):
     """Returns the Code object for the given function.
     """
     c = Code()
-    (c.Append()
-      .Concat(self._GenerateDocumentation(f))
-    )
+    c.Concat(self._GenerateDocumentation(f))
 
     if not self._NeedsProxiedCallback(f):
         c.Append("%s => %s;" % (self._GenerateFunctionSignature(f),
                                self._GenerateProxyCall(f)))
         return c
 
     (c.Sblock("%s {" % self._GenerateFunctionSignature(f))
       .Concat(self._GenerateProxiedFunction(f.callback, f.callback.name))
       .Append('%s;' % self._GenerateProxyCall(f))
       .Eblock('}')
     )
 
     return c
 
   def _GenerateProxiedFunction(self, f, callback_name):
     """Given a function (assumed to be a callback), generates the proxied
     version of this function, which calls |callback_name| if it is defined.
 
     Returns a Code object.
     """
     c = Code()
     proxied_params = []
     # A list of Properties, containing List<*> objects that need proxying for
     # their members (by copying out each member and proxying it).
     lists_to_proxy = []
     for p in f.params:
-      if self._IsBaseType(p.type_) or self._IsListOfBaseTypes(p.type_):
+      if self._IsBaseType(p.type_, list_as_base=True):
         proxied_params.append(p.name)
       elif self._IsSerializableObjectType(p.type_):
         proxied_params.append('new %s._proxy(%s)' % (
             self._GetDartType(p.type_), p.name))
       elif self._IsListOfSerializableObjects(p.type_):
         proxied_params.append('__proxy_%s' % p.name)
         lists_to_proxy.append(p)
       elif self._IsObjectType(p.type_):
         # TODO(sashab): Find a way to build generic JS objects back in Dart.
         proxied_params.append('%s' % p.name)
+      elif p.type_.property_type is PropertyType.ARRAY:
+        # TODO(sashab): This might be okay - what if this is a list of
+        # FileEntry elements? In this case, a basic list will proxy the objects
+        # fine.
+        proxied_params.append('%s' % p.name)
       else:
         raise Exception(
             "Cannot automatically create proxy; can't wrap %s, type %s" % (
                 self._GenerateFunctionSignature(f), self._GetDartType(p.type_)))
 
     (c.Sblock("void __proxy_callback(%s) {" % ', '.join(p.name for p in
                                                f.params))
       .Sblock('if (?%s) {' % callback_name)
     )
 
@@ skipping 142 matching lines @@
                                     event_name))
 
     # Add functions.
     if self._namespace.functions:
       (c.Append()
         .Append('/*')
         .Append(' * Functions')
         .Append(' */')
       )
     for function in self._namespace.functions.values():
-      c.Concat(self._GenerateFunction(function))
+      # Check for custom dart for this whole property.
+      c.Append()
+      if not self._ConcatOverride(c, [function.name], doc_property=function):
+        c.Concat(self._GenerateFunction(function))
 
     # Add the constructor.
     (c.Append()
       .Sblock('API_%s(this._jsObject) {' % self._namespace.unix_name)
     )
 
     # Add events to constructor.
     for event_name in self._namespace.events:
       c.Append("%s = new Event_%s_%s(JS('', '#.%s', this._jsObject));" %
         (event_name, self._namespace.unix_name, event_name, event_name))
@@ skipping 13 matching lines @@
       void onClosed()
       void doSomething(bool x, void callback([String x]))
     """
     if self._IsFunction(prop.type_):
       return self._GenerateFunctionSignature(prop.type_.function)
     return '%(type)s %(name)s' % {
                'type': self._GetDartType(prop.type_),
                'name': prop.simple_name
            }
 
-  def _GenerateFunctionSignature(self, function):
+  def _GenerateFunctionSignature(self, function, convert_optional=False):
     """Given a function object, returns the signature for that function.
     Recursively generates the signature for callbacks.
     Returns a String for the given function.
 
-    If prepend_this is True, adds "this." to the function's name.
+    If convert_optional is True, changes optional parameters to be required.
 
     e.g.
       void onClosed()
       bool isOpen([String type])
       void doSomething(bool x, void callback([String x]))
-
-    e.g. If prepend_this is True:
-      void this.onClosed()
-      bool this.isOpen([String type])
-      void this.doSomething(bool x, void callback([String x]))
     """
     sig = '%(return_type)s %(name)s(%(params)s)'
 
     if function.returns:
       return_type = self._GetDartType(function.returns)
     else:
       return_type = 'void'
 
     return sig % {
         'return_type': return_type,
         'name': function.simple_name,
         'params': self._GenerateParameterList(function.params,
-                                              function.callback)
+                                              function.callback,
+                                              convert_optional=convert_optional)
     }
 
   def _GenerateParameterList(self,
                              params,
                              callback=None,
                              convert_optional=False):
     """Given a list of function parameters, generates their signature (as a
     string).
 
     e.g.
@@ skipping 10 matching lines @@
     params_opt = []
     for param in params:
       p_sig = self._GeneratePropertySignature(param)
       if param.optional and not convert_optional:
         params_opt.append(p_sig)
       else:
         params_req.append(p_sig)
 
     # Add the callback, if it exists.
     if callback:
-      c_sig = self._GenerateFunctionSignature(callback)
+      c_sig = self._GenerateFunctionSignature(callback, convert_optional=True)
       if callback.optional:
         params_opt.append(c_sig)
       else:
         params_req.append(c_sig)
 
     # Join the parameters with commas.
     # Optional parameters have to be in square brackets, e.g.:
     #
     #  required params | optional params |     output
     #        []        |        []       |       ''
     #      [x, y]      |        []       |     'x, y'
     #        []        |      [a, b]     |    '[a, b]'
     #      [x, y]      |      [a, b]     | 'x, y, [a, b]'
     if params_opt:
       params_opt[0] = '[%s' % params_opt[0]
       params_opt[-1] = '%s]' % params_opt[-1]
     param_sets = [', '.join(params_req), ', '.join(params_opt)]
 
     # The 'if p' part here is needed to prevent commas where there are no
     # parameters of a certain type.
     # If there are no optional parameters, this prevents a _trailing_ comma,
     # e.g. '(x, y,)'. Similarly, if there are no required parameters, this
     # prevents a leading comma, e.g. '(, [a, b])'.
     return ', '.join(p for p in param_sets if p)
 
-  def _ConcatOverride(self, c, type_, prop, key_suffix='', add_doc=False):
-    """Given a particular type and property to find in the custom dart
-    overrides, checks whether there is an override for that key.
-    If there is, appends the override code, and returns True.
-    If not, returns False.
+  def _ConcatOverride(self, c, key_chain, doc_property=False):

[not at google - send to devlin, 2013/02/07 01:16:41]

From what I can tell, this isn't always a property. In fact reading the code I
assumed it was some flag about whether to document properties.

How about like "document_as" or something.

Also =False as the default argument seems wrong. Should be None.

[sashab, 2013/02/08 01:53:34]

Done.

+    """Given a list of keys, joins them with periods and searches for them in
+    the custom dart overrides.
+    If there is an override for that key, appends the override code and returns
+    True. If not, returns False.
 
-    |key_suffix| will be added to the end of the key before searching, e.g.
-    '.set' or '.get' can be used for setters and getters respectively.
-
-    If add_doc is given, adds the documentation for this property before the
-    override code.
+    If doc_property is given, adds the documentation for this property before
+    the override code.
     """
-    contents = self._type_overrides.get('%s.%s%s' % (type_.name, prop.name,
-                                     key_suffix))
+    contents = self._type_overrides.get('.'.join(key_chain))
     if contents is None:
       return False
 
-    if prop is not None:
-      c.Concat(self._GenerateDocumentation(prop))
-    for line in contents.split('\n'):
+    if doc_property is not None:
+      c.Concat(self._GenerateDocumentation(doc_property))
+    for line in contents.strip().split('\n'):

[not at google - send to devlin, 2013/02/07 01:16:41]

why strip()?

[sashab, 2013/02/08 01:53:34]

Good question. File contents always contain a trailing newline. Since the
documentation should be straight before the function definition, all newlines
here must be removed (hence removing all the blank lines). Maybe .strip('\n') is
better?

       c.Append(line)
     return True
 
   def _IsFunction(self, type_):
     """Given a model.Type, returns whether this type is a function.
     """
     return type_.property_type == PropertyType.FUNCTION
 
   def _IsSerializableObjectType(self, type_):
     """Given a model.Type, returns whether this type is a serializable object.
     Serializable objects are custom types defined in this namespace.
+
+    If this object is a reference to something not in this namespace, assumes
+    its a serializable object.
     """
-    if (type_.property_type == PropertyType.REF
-        and type_.ref_type in self._types):
-      return self._IsObjectType(self._types[type_.ref_type])
+    if type_.property_type is PropertyType.REF:
+      if type_.ref_type in self._types:
+        return self._IsObjectType(self._types[type_.ref_type])
+      return True
     if (type_.property_type == PropertyType.OBJECT
         and type_.instance_of in self._types):
       return self._IsObjectType(self._types[type_.instance_of])
     return False
 
   def _IsObjectType(self, type_):
     """Given a model.Type, returns whether this type is an object.
     """
     return (self._IsSerializableObjectType(type_)
             or type_.property_type in [PropertyType.OBJECT, PropertyType.ANY])
 
   def _IsListOfSerializableObjects(self, type_):
     """Given a model.Type, returns whether this type is a list of serializable
-    objects (PropertyType.REF types).
+    objects (or regular objects, if this list is treated as a type - in this
+    case, the item type was defined inline).
+
+    If this type is a reference to something not in this namespace, assumes
+    it is not a list of serializable objects.
     """
+    if type_.property_type is PropertyType.REF:
+      if type_.ref_type in self._types:
+        return self._IsListOfSerializableObjects(self._types[type_.ref_type])
+      return False
     return (type_.property_type is PropertyType.ARRAY and
-            type_.item_type.property_type is PropertyType.REF)
+        (self._IsSerializableObjectType(type_.item_type) or
+         (self._IsObjectType(type_.item_type) and type_.name in self._types)))
 
   def _IsListOfBaseTypes(self, type_):
     """Given a model.Type, returns whether this type is a list of base type
     objects (PropertyType.REF types).
     """
     return (type_.property_type is PropertyType.ARRAY and
             self._IsBaseType(type_.item_type))
 
-  def _IsBaseType(self, type_):
+  def _IsBaseType(self, type_, list_as_base=False):

[not at google - send to devlin, 2013/02/07 01:16:41]

list_as_base isn't descriptive on its own, I had to come look a this method to
see what all the list_as_base things were about. It's also a pretty specialised
thing to be passing a generic method like this.

I'm not really sure what should be the default (true or false) though true makes
a bit more sense to me - so how about a parameter "follow" or "unwrap"
(follow=False/unwrap=False) and invert the conditions.

Does the same problem exist for other types that wrap other types? Notably ref
types (should those be treated the same was as lists?). At times when you don't
want to unwrap, do you still want to dig down into choices?

I guess my understanding of the code that's being generated isn't deep enough to
understand the problem that this solves.

[sashab, 2013/02/08 01:53:34]

Before, lists had to be wrapped to be generated correctly. In this new version,
lists don't need to be wrapped, so they are technically a "base type". Choices
will remain a base type until we come up with a nice way to handle them using
Dart classes (I added a note about that).

     """Given a model.type_, returns whether this type is a base type
     (string, number or boolean).
+
+    If type_ is a Choices object, returns True if all possible choices are base
+    types.
+
+    If list_as_base is True, counts List as a base type.
     """
-    return (self._GetDartType(type_) in
-            ['bool', 'num', 'int', 'double', 'String'])
+    return (
+        (self._GetDartType(type_) in ['bool', 'num', 'int', 'double', 'String'])
+        or (type_.property_type is PropertyType.ARRAY
+           and self._IsBaseType(type_.item_type, list_as_base=list_as_base))
+        or (type_.property_type is PropertyType.CHOICES
+           and all(self._IsBaseType(t, list_as_base=list_as_base)
+                   for t in type_.choices))
+    )
 
   def _GetDartType(self, type_):
     """Given a model.Type object, returns its type as a Dart string.
     """
     if type_ is None:
       return 'void'
 
     prop_type = type_.property_type
     if prop_type is PropertyType.REF:
+      if type_.ref_type in self._types:
+        return self._GetDartType(self._types[type_.ref_type])
       # TODO(sashab): If the type is foreign, it might have to be imported.
       return StripNamespace(type_.ref_type)
     elif prop_type is PropertyType.BOOLEAN:
       return 'bool'
     elif prop_type is PropertyType.INTEGER:
       return 'int'
     elif prop_type is PropertyType.INT64:
       return 'num'
     elif prop_type is PropertyType.DOUBLE:
       return 'double'
     elif prop_type is PropertyType.STRING:
       return 'String'
     elif prop_type is PropertyType.ENUM:
       return 'String'
     elif prop_type is PropertyType.CHOICES:
-      # TODO: What is a Choices type? Is it closer to a Map Dart object?
+      # TODO: Think of a nice way to generate code for Choices objects in Dart.
       return 'Object'
     elif prop_type is PropertyType.ANY:
       return 'Object'
     elif prop_type is PropertyType.OBJECT:
-      return type_.instance_of or 'Object'
+      if type_.instance_of is not None:
+        return type_.instance_of
+      if type(type_.parent) is not Function:
+        return type_.name
+      # If we're here, the parent's type is a Function. So it's name will be the
+      # name of the function parameter (its an inline type definition).
+      # TODO(sashab): When there is a nice way to generate code for inline
+      # types, change this to reflect the type's new name.
+      return 'Object'
     elif prop_type is PropertyType.FUNCTION:
       return 'Function'
     elif prop_type is PropertyType.ARRAY:
       return 'List<%s>' % self._GetDartType(type_.item_type)
     elif prop_type is PropertyType.BINARY:
       return 'String'
     else:
       raise NotImplementedError(prop_type)