Add optional schema compiler error messages

tools/json_schema_compiler/cc_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.
 
 from code import Code
 from model import PropertyType, Type
 import cpp_util
 import model
 import schema_util
 import sys
@@ skipping 13 matching lines @@
   """A .cc generator for a namespace.
   """
   def __init__(self, namespace, cpp_type_generator, cpp_namespace):
     self._namespace = namespace
     self._type_helper = cpp_type_generator
     self._cpp_namespace = cpp_namespace
     self._target_namespace = (
         self._type_helper.GetCppNamespaceName(self._namespace))
     self._util_cc_helper = (
         util_cc_helper.UtilCCHelper(self._type_helper))
+    self._generate_error_messages = namespace.compiler_options.get(
+        'generate_error_messages', False)
 
   def Generate(self):
     """Generates a Code object with the .cc for a single namespace.
     """
     c = Code()
     (c.Append(cpp_util.CHROMIUM_LICENSE)
       .Append()
       .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file)
       .Append()
       .Append(self._util_cc_helper.GetIncludePath())
@@ skipping 131 matching lines @@
 
   def _GenerateTypePopulate(self, cpp_namespace, type_):
     """Generates the function for populating a type given a pointer to it.
 
     E.g for type "Foo", generates Foo::Populate()
     """
     classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
     c = Code()
     (c.Append('// static')
       .Append('bool %(namespace)s::Populate(')
-      .Sblock('    const base::Value& value, %(name)s* out) {')
-    )
+      .Sblock('    %s) {' % self._GenerateParams(
+          ('const base::Value& value', '%(name)s* out'))))
+
     if type_.property_type == PropertyType.CHOICES:
       for choice in type_.choices:
         (c.Sblock('if (%s) {' % self._GenerateValueIsTypeExpression('value',
                                                                     choice))
             .Concat(self._GeneratePopulateVariableFromValue(
                 choice,
                 '(&value)',
                 'out->as_%s' % choice.unix_name,
                 'false',
                 is_ptr=True))
             .Append('return true;')
           .Eblock('}')
         )
-      c.Append('return false;')
+      (c.Concat(self._GenerateError(
+          '"expected %s, got " +  %s' %
+              (" or ".join(choice.name for choice in type_.choices),
+              self._util_cc_helper.GetValueTypeString('value'))))
+        .Append('return false;'))
     elif type_.property_type == PropertyType.OBJECT:
-      (c.Append('if (!value.IsType(base::Value::TYPE_DICTIONARY))')
-        .Append('  return false;')
-      )
+      (c.Sblock('if (!value.IsType(base::Value::TYPE_DICTIONARY)) {')
+        .Concat(self._GenerateError(
+          '"expected dictionary, got " + ' +
+          self._util_cc_helper.GetValueTypeString('value')))
+        .Append('return false;')
+        .Eblock('}'))
+
       if type_.properties or type_.additional_properties is not None:
         c.Append('const base::DictionaryValue* dict = '
                      'static_cast<const base::DictionaryValue*>(&value);')
       for prop in type_.properties.values():
         c.Concat(self._InitializePropertyToDefault(prop, 'out'))
       for prop in type_.properties.values():
         c.Concat(self._GenerateTypePopulateProperty(prop, 'dict', 'out'))
       if type_.additional_properties is not None:
         if type_.additional_properties.property_type == PropertyType.ANY:
           c.Append('out->additional_properties.MergeDictionary(dict);')
@@ skipping 38 matching lines @@
           'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false')))
       underlying_type = self._type_helper.FollowRef(prop.type_)
       if underlying_type.property_type == PropertyType.ENUM:
         (c.Append('} else {')
           .Append('%%(dst)s->%%(name)s = %s;' %
               self._type_helper.GetEnumNoneValue(prop.type_)))
       c.Eblock('}')
     else:
-      (c.Append(
-          'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s))')
-        .Append('  return false;')
+      (c.Sblock(
+          'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
+        .Concat(self._GenerateError('"\'%%(key)s\' is required"'))
+        .Append('return false;')
+        .Eblock('}')
         .Concat(self._GeneratePopulatePropertyFromValue(
             prop, value_var, dst, 'false'))
       )
     c.Append()
     c.Substitute({
       'value_var': value_var,
       'key': prop.name,
       'src': src,
       'dst': dst,
       'name': prop.unix_name
     })
     return c
 
   def _GenerateTypeFromValue(self, cpp_namespace, type_):
     classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
     c = Code()
     (c.Append('// static')
-      .Append('scoped_ptr<%s> %s::FromValue(const base::Value& value) {' % (
-          classname, cpp_namespace))
+      .Append('scoped_ptr<%s> %s::FromValue(%s) {' % (classname,
+        cpp_namespace, self._GenerateParams(('const base::Value& value',))))
       .Append('  scoped_ptr<%s> out(new %s());' % (classname, classname))
-      .Append('  if (!Populate(value, out.get()))')
+      .Append('  if (!Populate(%s))' % self._GenerateArgs(
+          ('value', 'out.get()')))
       .Append('    return scoped_ptr<%s>();' % classname)
       .Append('  return out.Pass();')
       .Append('}')
     )
     return c
 
   def _GenerateTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes the type into a base::Value.
     E.g. for type "Foo" generates Foo::ToValue()
     """
@@ skipping 182 matching lines @@
   def _GenerateParamsCheck(self, function, var):
     """Generates a check for the correct number of arguments when creating
     Params.
     """
     c = Code()
     num_required = 0
     for param in function.params:
       if not param.optional:
         num_required += 1
     if num_required == len(function.params):
-      c.Append('if (%(var)s.GetSize() != %(total)d)')
+      c.Sblock('if (%(var)s.GetSize() != %(total)d) {')
     elif not num_required:
-      c.Append('if (%(var)s.GetSize() > %(total)d)')
+      c.Sblock('if (%(var)s.GetSize() > %(total)d) {')
     else:
-      c.Append('if (%(var)s.GetSize() < %(required)d'
-          ' || %(var)s.GetSize() > %(total)d)')
-    c.Append('  return scoped_ptr<Params>();')
-    c.Substitute({
+      c.Sblock('if (%(var)s.GetSize() < %(required)d'
+          ' || %(var)s.GetSize() > %(total)d) {')
+    (c.Concat(self._GenerateError(
+        '"expected %%(total)d arguments, got " '
+        '+ base::IntToString(%%(var)s.GetSize())'))
+      .Append('return scoped_ptr<Params>();')
+      .Eblock('}')
+      .Substitute({
         'var': var,
         'required': num_required,
         'total': len(function.params),
-    })
+    }))
     return c
 
   def _GenerateFunctionParamsCreate(self, function):
     """Generate function to create an instance of Params. The generated
     function takes a base::ListValue of arguments.
 
     E.g for function "Bar", generate Bar::Params::Create()
     """
     c = Code()
     (c.Append('// static')
-      .Sblock('scoped_ptr<Params> '
-                  'Params::Create(const base::ListValue& args) {')
+      .Sblock('scoped_ptr<Params> Params::Create(%s) {' % self._GenerateParams(
+        ['const base::ListValue& args']))
       .Concat(self._GenerateParamsCheck(function, 'args'))
-      .Append('scoped_ptr<Params> params(new Params());')
-    )
+      .Append('scoped_ptr<Params> params(new Params());'))
 
     for param in function.params:
       c.Concat(self._InitializePropertyToDefault(param, 'params'))
 
     for i, param in enumerate(function.params):
       # Any failure will cause this function to return. If any argument is
       # incorrect or missing, those following it are not processed. Note that
       # for optional arguments, we allow missing arguments and proceed because
       # there may be other arguments following it.
       failure_value = 'scoped_ptr<Params>()'
       c.Append()
       value_var = param.unix_name + '_value'
       (c.Append('const base::Value* %(value_var)s = NULL;')
         .Append('if (args.Get(%(i)s, &%(value_var)s) &&')
         .Sblock('    !%(value_var)s->IsType(base::Value::TYPE_NULL)) {')
         .Concat(self._GeneratePopulatePropertyFromValue(
             param, value_var, 'params', failure_value))
         .Eblock('}')
       )
       if not param.optional:
         (c.Sblock('else {')
+          .Concat(self._GenerateError('"\'%%(key)s\' is required"'))
           .Append('return %s;' % failure_value)
-          .Eblock('}')
-        )
-      c.Substitute({'value_var': value_var, 'i': i})
+          .Eblock('}'))
+      c.Substitute({'value_var': value_var, 'i': i, 'key': param.name})
     (c.Append()
       .Append('return params.Pass();')
       .Eblock('}')
       .Append()
     )
 
     return c
 
   def _GeneratePopulatePropertyFromValue(self,
                                          prop,
@@ skipping 23 matching lines @@
     |failure_value|.
     """
     c = Code()
     c.Sblock('{')
 
     underlying_type = self._type_helper.FollowRef(type_)
 
     if underlying_type.property_type.is_fundamental:
       if is_ptr:
         (c.Append('%(cpp_type)s temp;')
-          .Append('if (!%s)' % cpp_util.GetAsFundamentalValue(
+          .Sblock('if (!%s) {' % cpp_util.GetAsFundamentalValue(
                       self._type_helper.FollowRef(type_), src_var, '&temp'))
-          .Append('  return %(failure_value)s;')
+          .Concat(self._GenerateError(
+            '"\'%%(key)s\': expected ' + '%s, got " + %s' % (
+                type_.name,
+                self._util_cc_helper.GetValueTypeString(
+                    '%%(src_var)s', True))))
+          .Append('return %(failure_value)s;')
+          .Eblock('}')
           .Append('%(dst_var)s.reset(new %(cpp_type)s(temp));')
         )
       else:
-        (c.Append('if (!%s)' % cpp_util.GetAsFundamentalValue(
+        (c.Sblock('if (!%s) {' % cpp_util.GetAsFundamentalValue(
                       self._type_helper.FollowRef(type_),
                       src_var,
                       '&%s' % dst_var))
-          .Append('  return %(failure_value)s;')
+          .Concat(self._GenerateError(
+            '"\'%%(key)s\': expected ' + '%s, got " + %s' % (
+                type_.name,
+                self._util_cc_helper.GetValueTypeString(
+                    '%%(src_var)s', True))))
+          .Append('return %(failure_value)s;')
+          .Eblock('}')
         )
     elif underlying_type.property_type == PropertyType.OBJECT:
       if is_ptr:
         (c.Append('const base::DictionaryValue* dictionary = NULL;')
-          .Append('if (!%(src_var)s->GetAsDictionary(&dictionary))')
+          .Sblock('if (!%(src_var)s->GetAsDictionary(&dictionary)) {')
+          .Concat(self._GenerateError(
+            '"\'%%(key)s\': expected dictionary, got " + ' +
+            self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
+          .Append('return %(failure_value)s;')
+          .Eblock('}')
+          .Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
+          .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs(
+            ('*dictionary', 'temp.get()')))
           .Append('  return %(failure_value)s;')
-          .Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
-          .Append('if (!%(cpp_type)s::Populate(*dictionary, temp.get()))')
-          .Append('  return %(failure_value)s;')
+          .Append('}')
           .Append('%(dst_var)s = temp.Pass();')
         )
       else:
         (c.Append('const base::DictionaryValue* dictionary = NULL;')
-          .Append('if (!%(src_var)s->GetAsDictionary(&dictionary))')
+          .Sblock('if (!%(src_var)s->GetAsDictionary(&dictionary)) {')
+          .Concat(self._GenerateError(
+            '"\'%%(key)s\': expected dictionary, got " + ' +
+            self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
+          .Append('return %(failure_value)s;')
+          .Eblock('}')
+          .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs(
+            ('*dictionary', '&%(dst_var)s')))
           .Append('  return %(failure_value)s;')
-          .Append('if (!%(cpp_type)s::Populate(*dictionary, &%(dst_var)s))')
-          .Append('  return %(failure_value)s;')
+          .Append('}')
         )
     elif underlying_type.property_type == PropertyType.FUNCTION:
       if is_ptr:
         c.Append('%(dst_var)s.reset(new base::DictionaryValue());')
     elif underlying_type.property_type == PropertyType.ANY:
       c.Append('%(dst_var)s.reset(%(src_var)s->DeepCopy());')
     elif underlying_type.property_type == PropertyType.ARRAY:
       # util_cc_helper deals with optional and required arrays
       (c.Append('const base::ListValue* list = NULL;')
-        .Append('if (!%(src_var)s->GetAsList(&list))')
-        .Append('  return %(failure_value)s;'))
+        .Sblock('if (!%(src_var)s->GetAsList(&list)) {')
+          .Concat(self._GenerateError(
+            '"\'%%(key)s\': expected list, got " + ' +
+            self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
+          .Append('return %(failure_value)s;')
+          .Eblock('}'))
       item_type = self._type_helper.FollowRef(underlying_type.item_type)
       if item_type.property_type == PropertyType.ENUM:
         c.Concat(self._GenerateListValueToEnumArrayConversion(
                      item_type,
                      'list',
                      dst_var,
                      failure_value,
                      is_ptr=is_ptr))
       else:
-        (c.Append('if (!%s)' % self._util_cc_helper.PopulateArrayFromList(
+        (c.Sblock('if (!%s) {' % self._util_cc_helper.PopulateArrayFromList(
               underlying_type,
               'list',
               dst_var,
               is_ptr))
-          .Append('  return %(failure_value)s;')
+          .Concat(self._GenerateError(
+            '"unable to populate array \'%%(parent_key)s\'"'))
+          .Append('return %(failure_value)s;')
+          .Eblock('}')
         )
     elif underlying_type.property_type == PropertyType.CHOICES:
       if is_ptr:
         (c.Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
-          .Append('if (!%(cpp_type)s::Populate(*%(src_var)s, temp.get()))')
+          .Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
+            ('*%(src_var)s', 'temp.get()')))
           .Append('  return %(failure_value)s;')
           .Append('%(dst_var)s = temp.Pass();')
         )
       else:
-        (c.Append('if (!%(cpp_type)s::Populate(*%(src_var)s, &%(dst_var)s))')
-          .Append('  return %(failure_value)s;')
-        )
+        (c.Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
+            ('*%(src_var)s', '&%(dst_var)s')))
+          .Append('  return %(failure_value)s;'))
     elif underlying_type.property_type == PropertyType.ENUM:
       c.Concat(self._GenerateStringToEnumConversion(type_,
                                                     src_var,
                                                     dst_var,
                                                     failure_value))
     elif underlying_type.property_type == PropertyType.BINARY:
-      (c.Append('if (!%(src_var)s->IsType(base::Value::TYPE_BINARY))')
-        .Append('  return %(failure_value)s;')
+      (c.Sblock('if (!%(src_var)s->IsType(base::Value::TYPE_BINARY)) {')
+        .Concat(self._GenerateError(
+          '"\'%%(key)s\': expected binary, got " + ' +
+          self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
+        .Append('return %(failure_value)s;')
+        .Eblock('}')
         .Append('const base::BinaryValue* binary_value =')
         .Append('    static_cast<const base::BinaryValue*>(%(src_var)s);')
       )
       if is_ptr:
         (c.Append('%(dst_var)s.reset(')
           .Append('    new std::string(binary_value->GetBuffer(),')
           .Append('                    binary_value->GetSize()));')
         )
       else:
         (c.Append('%(dst_var)s.assign(binary_value->GetBuffer(),')
           .Append('                   binary_value->GetSize());')
         )
     else:
       raise NotImplementedError(type_)
     return c.Eblock('}').Substitute({
       'cpp_type': self._type_helper.GetCppType(type_),
       'src_var': src_var,
       'dst_var': dst_var,
       'failure_value': failure_value,
+      'key': type_.name,
+      'parent_key': type_.parent.name
     })
 
   def _GenerateListValueToEnumArrayConversion(self,
                                               item_type,
                                               src_var,
                                               dst_var,
                                               failure_value,
                                               is_ptr=False):
       """Returns Code that converts a ListValue of string constants from
       |src_var| into an array of enums of |type_| in |dst_var|. On failure,
@@ skipping 23 matching lines @@
                                       src_var,
                                       dst_var,
                                       failure_value):
     """Returns Code that converts a string type in |src_var| to an enum with
     type |type_| in |dst_var|. In the generated code, if |src_var| is not
     a valid enum name then the function will return |failure_value|.
     """
     c = Code()
     enum_as_string = '%s_as_string' % type_.unix_name
     (c.Append('std::string %s;' % enum_as_string)
-      .Append('if (!%s->GetAsString(&%s))' % (src_var, enum_as_string))
-      .Append('  return %s;' % failure_value)
+      .Sblock('if (!%s->GetAsString(&%s)) {' % (src_var, enum_as_string))
+      .Concat(self._GenerateError(
+        '"\'%%(key)s\': expected string, got " + ' +
+        self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
+      .Append('return %s;' % failure_value)
+      .Eblock('}')
       .Append('%s = Parse%s(%s);' % (dst_var,
                                      self._type_helper.GetCppType(type_),
                                      enum_as_string))
-      .Append('if (%s == %s)' % (dst_var,
+      .Sblock('if (%s == %s) {' % (dst_var,
                                  self._type_helper.GetEnumNoneValue(type_)))
-     .Append('  return %s;' % failure_value)
+      .Concat(self._GenerateError(
+        '\"\'%%(key)s\': expected \\"' +
+        '\\" or \\"'.join(self._type_helper.FollowRef(type_).enum_values) +
+        '\\", got \\"" + %s + "\\""' % enum_as_string))
+      .Append('return %s;' % failure_value)
+      .Eblock('}')
+      .Substitute({'src_var': src_var, 'key': type_.name})
     )
     return c
 
   def _GeneratePropertyFunctions(self, namespace, params):
     """Generates the member functions for a list of parameters.
     """
     return self._GenerateTypes(namespace, (param.type_ for param in params))
 
   def _GenerateTypes(self, namespace, types):
     """Generates the member functions for a list of types.
@@ skipping 105 matching lines @@
     """
     c = Code()
     underlying_type = self._type_helper.FollowRef(prop.type_)
     if (underlying_type.property_type == PropertyType.ENUM and
         prop.optional):
       c.Append('%s->%s = %s;' % (
         dst,
         prop.unix_name,
         self._type_helper.GetEnumNoneValue(prop.type_)))
     return c
+
+  def _GenerateError(self, body):
+    """Generates an error message pertaining to population failure.
+
+    E.g 'expected bool, got int'
+    """
+    c = Code()
+    if not self._generate_error_messages:
+      return c
+    (c.Append('if (error)')
+      .Append('  *error = ' + body + ';'))
+    return c
+
+  def _GenerateParams(self, params):
+    """Builds the parameter list for a function, given an array of parameters.
+    """
+    if self._generate_error_messages:
+      params = list(params) + ['std::string* error']
+    return ', '.join(str(p) for p in params)
+
+  def _GenerateArgs(self, args):
+    """Builds the argument list for a function, given an array of arguments.
+    """
+    if self._generate_error_messages:
+      args = list(args) + ['error']
+    return ', '.join(str(a) for a in args)