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 *
 
 import os
 from datetime import datetime
 
-LICENSE = ("""
-// Copyright (c) %s, the Dart project authors.  Please see the AUTHORS file
+LICENSE = (
+"""// Copyright (c) %s, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.""" %
     datetime.now().year)
 
 class DartGenerator(object):
   def __init__(self, dart_overrides_dir=None):
     self._dart_overrides_dir = dart_overrides_dir
 
   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
+    # TODO(sashab): Once inline type definitions start being added to
+    # self._types, make a _FindType(self, type_) function that looks at
+    # self._namespace.types.
     self._types = namespace.types
 
     # 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 here, so they have proper names, and are implemented along with
+    # all other types. Also update the parameters/members with these types
+    # to reference these new types instead.
+
   def Generate(self):
     """Generates a Code object with the .dart for the entire namespace.
     """
     c = Code()
     (c.Append(LICENSE)
+      .Append()
       .Append('// Generated from namespace: %s' % self._namespace.name)
       .Append()
       .Append('part of chrome;'))
 
     if self._types:
       (c.Append()
         .Append('/**')
         .Append(' * Types')
         .Append(' */')
+        .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.
+      override = self._GetOverride([type_.name], document_with=type_)
+      c.Cblock(override if override is not None else self._GenerateType(type_))
 
     if self._namespace.events:
-      (c.Append()
-        .Append('/**')
+      (c.Append('/**')
         .Append(' * Events')
         .Append(' */')
+        .Append()
       )
     for event_name in self._namespace.events:
-      c.Concat(self._GenerateEvent(self._namespace.events[event_name]))
+      c.Cblock(self._GenerateEvent(self._namespace.events[event_name]))
 
-    (c.Append()
-      .Append('/**')
+    (c.Append('/**')
       .Append(' * Functions')
       .Append(' */')
+      .Append()
     )
-    c.Concat(self._GenerateMainClass())
+    c.Cblock(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.
     """
     c = Code()
-    (c.Append()
-      .Concat(self._GenerateDocumentation(type_))
+
+    # Since enums are just treated as strings for now, don't generate their
+    # type.
+    # TODO(sashab): Find a nice way to wrap enum objects.
+    if type_.property_type is PropertyType.ENUM:
+      return c
+
+    (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()]
 
     if add_public_constructor:
       (c.Append('/*')
         .Append(' * Public constructor')
         .Append(' */')
         .Sblock('%(type_name)s({%(constructor_fields)s}) {')
       )
 
       for prop_name in type_.properties:
-        c.Append('this.%s = %s;' % (prop_name, prop_name))
+        (c.Sblock('if (?%s)' % prop_name)
+          .Append('this.%s = %s;' % (prop_name, prop_name))
+          .Eblock()
+        )
       (c.Eblock('}')
         .Append()
       )
 
     (c.Append('/*')
       .Append(' * Private constructor')
       .Append(' */')
       .Append('%(type_name)s._proxy(_jsObject) : super._proxy(_jsObject);')
     )
 
     # Add an accessor (getter & setter) for each property.
     properties = [p for p in type_.properties.values()
                   if not self._IsFunction(p.type_)]
     if properties:
       (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):
-        # Add the getter.
-        if not self._ConcatOverride(c, type_, prop, key_suffix='.get',
-                                       add_doc=True):
-          # Add the documentation for this property.
-          c.Concat(self._GenerateDocumentation(prop))
-
-          if (self._IsBaseType(prop.type_)
-              or self._IsListOfBaseTypes(prop.type_)):
-            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))
-              .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)))
-              .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'):
-          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("}")
-          )
+      override = self._GetOverride([type_.name, prop.name], document_with=prop)
+      c.Concat(override if override is not None
+               else self._GenerateGetterAndSetter(type_, prop))
 
     # 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.
+      override = self._GetOverride([type_.name, prop.name], document_with=prop)
+      c.Cblock(override if override is not None
+               else self._GenerateFunction(prop.type_.function))
 
     (c.Eblock('}')
       .Substitute({
-        'type_name': type_.simple_name,
+        'type_name': self._AddPrefix(type_.simple_name),
         'constructor_fields': ', '.join(constructor_fields)
       })
     )
 
     return c
 
+  def _GenerateGetterAndSetter(self, type_, prop):
+    """Given a Type and Property, returns the Code object for the getter and
+    setter for that property.
+    """
+    c = Code()
+    override = self._GetOverride([type_.name, prop.name, '.get'],
+                                 document_with=prop)
+    c.Cblock(override if override is not None
+             else self._GenerateGetter(type_, prop))
+    override = self._GetOverride([type_.name, prop.name, '.set'])
+    c.Cblock(override if override is not None
+             else self._GenerateSetter(type_, prop))
+    return c
+
+  def _GenerateGetter(self, type_, prop):
+    """Given a Type and Property, returns the Code object for the getter for
+    that property.
+
+    Also adds the documentation for this property before the method.
+    """
+    c = Code()
+    c.Concat(self._GenerateDocumentation(prop))
+
+    type_name = self._GetDartType(prop.type_)
+    if (self._IsBaseType(prop.type_)):
+      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))
+        .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)))
+        .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)
+      )
+    return c
+
+  def _GenerateSetter(self, type_, prop):
+    """Given a Type and Property, returns the Code object for the setter for
+    that property.
+    """
+    c = Code()
+    type_name = self._GetDartType(prop.type_)
+    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("}")
+    )
+    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_):
         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 70 matching lines @@
 
   def _GenerateEvent(self, event):
     """Given a Function object, returns the Code with the .dart for this event,
     represented by the function.
 
     All events extend the Event base type.
     """
     c = Code()
 
     # Add documentation for this event.
-    (c.Append()
-      .Concat(self._GenerateDocumentation(event))
+    (c.Concat(self._GenerateDocumentation(event))
       .Sblock('class Event_%(event_name)s extends Event {')
     )
 
     # If this event needs a proxy, all calls need to be proxied.
     needs_proxy = self._NeedsProxy(event)
 
     # Override Event callback type definitions.
     for ret_type, event_func in (('void', 'addListener'),
                                  ('void', 'removeListener'),
                                  ('bool', 'hasListener')):
       param_list = self._GenerateParameterList(event.params, event.callback,
                                                convert_optional=True)
       if needs_proxy:
         (c.Sblock('%s %s(void callback(%s)) {' % (ret_type, event_func,
                                                  param_list))
           .Concat(self._GenerateProxiedFunction(event, 'callback'))
           .Append('super.%s(callback);' % event_func)
           .Eblock('}')
         )
       else:
         c.Append('%s %s(void callback(%s)) => super.%s(callback);' %
             (ret_type, event_func, param_list, event_func))
       c.Append()
 
     # Generate the constructor.
     (c.Append('Event_%(event_name)s(jsObject) : '
-              'super(jsObject, %(param_num)d);')
+              'super._(jsObject, %(param_num)d);')
       .Eblock('}')
       .Substitute({
         'event_name': self._namespace.unix_name + '_' + event.name,
         'param_num': len(event.params)
       })
     )
 
     return c
 
   def _GenerateMainClass(self):
     """Generates the main class for this file, which links to all functions
     and events.
 
     Returns a code object.
     """
     c = Code()
-    (c.Append()
-      .Sblock('class API_%s {' % self._namespace.unix_name)
+    (c.Sblock('class API_%s {' % self._namespace.unix_name)
       .Append('/*')
       .Append(' * API connection')
       .Append(' */')
       .Append('Object _jsObject;')
     )
 
     # Add events.
     if self._namespace.events:
       (c.Append()
         .Append('/*')
         .Append(' * Events')
         .Append(' */')
       )
     for event_name in self._namespace.events:
       c.Append('Event_%s_%s %s;' % (self._namespace.unix_name, event_name,
                                     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.
+      override = self._GetOverride([function.name], document_with=function)
+      c.Cblock(override if override is not None
+               else self._GenerateFunction(function))
 
     # Add the constructor.
-    (c.Append()
-      .Sblock('API_%s(this._jsObject) {' % self._namespace.unix_name)
-    )
+    c.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))
 
     (c.Eblock('}')
       .Eblock('}')
     )
     return c
 
   def _GeneratePropertySignature(self, prop):
     """Given a property, returns a signature for that property.
     Recursively generates the signature for callbacks.
     Returns a String for the given property.
 
     e.g.
       bool x
       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 _GetOverride(self, key_chain, document_with=None):
+    """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, finds the override code and returns
+    the Code object. If not, returns None.
 
-    |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 document_with is not None, adds the documentation for this property
+    before the override code.
+    """
+    c = Code()
+    contents = self._type_overrides.get('.'.join(key_chain))
+    if contents is None:
+      return None
 
-    If add_doc is given, adds the documentation for this property before the
-    override code.
+    if document_with is not None:
+      c.Concat(self._GenerateDocumentation(document_with))
+    for line in contents.strip('\n').split('\n'):
+      c.Append(line)
+    return c
+
+  def _AddPrefix(self, name):
+    """Given the name of a type, prefixes the namespace (as camelcase) and
+    return the new name.
     """
-    contents = self._type_overrides.get('%s.%s%s' % (type_.name, prop.name,
-                                     key_suffix))
-    if contents is None:
-      return False
-
-    if prop is not None:
-      c.Concat(self._GenerateDocumentation(prop))
-    for line in contents.split('\n'):
-      c.Append(line)
-    return True
+    # TODO(sashab): Split the dart library into multiple files, avoiding the
+    # need for this prefixing.
+    return ('%s%s' % (
+        ''.join(s.capitalize() for s in self._namespace.name.split('.')),
+        name))
 
   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.CHOICES:
+      return all(self._IsSerializableObjectType(c) for c in type_.choices)
+    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.CHOICES:
+      return all(self._IsListOfSerializableObjects(c) for c in type_.choices)
+    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)))
 
   def _IsListOfBaseTypes(self, type_):
     """Given a model.Type, returns whether this type is a list of base type
     objects (PropertyType.REF types).
     """
+    if type_.property_type is PropertyType.CHOICES:
+      return all(self._IsListOfBaseTypes(c) for c in type_.choices)
     return (type_.property_type is PropertyType.ARRAY and
             self._IsBaseType(type_.item_type))
 
   def _IsBaseType(self, type_):
     """Given a model.type_, returns whether this type is a base type
-    (string, number or boolean).
+    (string, number, boolean, or a list of these).
+
+    If type_ is a Choices object, returns True if all possible choices are base
+    types.
     """
-    return (self._GetDartType(type_) in
-            ['bool', 'num', 'int', 'double', 'String'])
+    # TODO(sashab): Remove 'Choices' as a base type once they are wrapped in
+    # native Dart classes.
+    if type_.property_type is PropertyType.CHOICES:
+      return all(self._IsBaseType(c) for c in type_.choices)
+    return (
+        (self._GetDartType(type_) in ['bool', 'num', 'int', 'double', 'String'])
+        or (type_.property_type is PropertyType.ARRAY
+            and self._IsBaseType(type_.item_type))
+    )
 
   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(sashab): 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'
+      # TODO(sashab): type_.name is the name of the function's parameter for
+      # inline types defined in functions. Think of a way to generate names
+      # for this, or remove all inline type definitions at the start.
+      if type_.instance_of is not None:
+        return type_.instance_of
+      if not isinstance(type_.parent, Function):
+        return self._AddPrefix(type_.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)