Mojo bindings generator: introduce Stylizer to specify naming rules.

mojo/public/tools/bindings/pylib/mojom/parse/ast.py

 # 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.
 
 """Node classes for the AST for a Mojo IDL file."""
 
 # Note: For convenience of testing, you probably want to define __eq__() methods
 # for all node types; it's okay to be slightly lax (e.g., not compare filename
 # and lineno). You may also define __repr__() to help with analyzing test
 # failures, especially for more complex types.
@@ skipping 66 matching lines @@
     if self.items:
       self.filename = self.items[0].filename
       self.lineno = self.items[0].lineno
 
 
 class Definition(NodeBase):
   """Represents a definition of anything that has a global name (e.g., enums,
   enum values, consts, structs, struct fields, interfaces). (This does not
   include parameter definitions.) This class is meant to be subclassed."""
 
-  def __init__(self, name, **kwargs):
-    assert isinstance(name, str)
+  def __init__(self, mojom_name, **kwargs):
+    assert isinstance(mojom_name, str)
     NodeBase.__init__(self, **kwargs)
-    self.name = name
+    self.mojom_name = mojom_name
 
 
 ################################################################################
 
 
 class Attribute(NodeBase):
   """Represents an attribute."""
 
   def __init__(self, key, value, **kwargs):
     assert isinstance(key, str)
     super(Attribute, self).__init__(**kwargs)
     self.key = key
     self.value = value
 
   def __eq__(self, other):
     return super(Attribute, self).__eq__(other) and \
            self.key == other.key and \
            self.value == other.value
 
 
 class AttributeList(NodeListBase):
   """Represents a list attributes."""
 
   _list_item_type = Attribute
 
 
 class Const(Definition):
   """Represents a const definition."""
 
-  def __init__(self, name, typename, value, **kwargs):
+  def __init__(self, mojom_name, typename, value, **kwargs):
     # The typename is currently passed through as a string.
     assert isinstance(typename, str)
     # The value is either a literal (currently passed through as a string) or a
     # "wrapped identifier".
     assert isinstance(value, str) or isinstance(value, tuple)
-    super(Const, self).__init__(name, **kwargs)
+    super(Const, self).__init__(mojom_name, **kwargs)
     self.typename = typename
     self.value = value
 
   def __eq__(self, other):
     return super(Const, self).__eq__(other) and \
            self.typename == other.typename and \
            self.value == other.value
 
 
 class Enum(Definition):
   """Represents an enum definition."""
 
-  def __init__(self, name, attribute_list, enum_value_list, **kwargs):
+  def __init__(self, mojom_name, attribute_list, enum_value_list, **kwargs):
     assert attribute_list is None or isinstance(attribute_list, AttributeList)
     assert enum_value_list is None or isinstance(enum_value_list, EnumValueList)
-    super(Enum, self).__init__(name, **kwargs)
+    super(Enum, self).__init__(mojom_name, **kwargs)
     self.attribute_list = attribute_list
     self.enum_value_list = enum_value_list
 
   def __eq__(self, other):
     return super(Enum, self).__eq__(other) and \
            self.attribute_list == other.attribute_list and \
            self.enum_value_list == other.enum_value_list
 
 
 class EnumValue(Definition):
   """Represents a definition of an enum value."""
 
-  def __init__(self, name, attribute_list, value, **kwargs):
+  def __init__(self, mojom_name, attribute_list, value, **kwargs):
     # The optional value is either an int (which is current a string) or a
     # "wrapped identifier".
     assert attribute_list is None or isinstance(attribute_list, AttributeList)
     assert value is None or isinstance(value, (str, tuple))
-    super(EnumValue, self).__init__(name, **kwargs)
+    super(EnumValue, self).__init__(mojom_name, **kwargs)
     self.attribute_list = attribute_list
     self.value = value
 
   def __eq__(self, other):
     return super(EnumValue, self).__eq__(other) and \
            self.attribute_list == other.attribute_list and \
            self.value == other.value
 
 
 class EnumValueList(NodeListBase):
@@ skipping 18 matching lines @@
 
 class ImportList(NodeListBase):
   """Represents a list (i.e., sequence) of import statements."""
 
   _list_item_type = Import
 
 
 class Interface(Definition):
   """Represents an interface definition."""
 
-  def __init__(self, name, attribute_list, body, **kwargs):
+  def __init__(self, mojom_name, attribute_list, body, **kwargs):
     assert attribute_list is None or isinstance(attribute_list, AttributeList)
     assert isinstance(body, InterfaceBody)
-    super(Interface, self).__init__(name, **kwargs)
+    super(Interface, self).__init__(mojom_name, **kwargs)
     self.attribute_list = attribute_list
     self.body = body
 
   def __eq__(self, other):
     return super(Interface, self).__eq__(other) and \
            self.attribute_list == other.attribute_list and \
            self.body == other.body
 
 
 class Method(Definition):
   """Represents a method definition."""
 
-  def __init__(self, name, attribute_list, ordinal, parameter_list,
+  def __init__(self, mojom_name, attribute_list, ordinal, parameter_list,
                response_parameter_list, **kwargs):
     assert attribute_list is None or isinstance(attribute_list, AttributeList)
     assert ordinal is None or isinstance(ordinal, Ordinal)
     assert isinstance(parameter_list, ParameterList)
     assert response_parameter_list is None or \
            isinstance(response_parameter_list, ParameterList)
-    super(Method, self).__init__(name, **kwargs)
+    super(Method, self).__init__(mojom_name, **kwargs)
     self.attribute_list = attribute_list
     self.ordinal = ordinal
     self.parameter_list = parameter_list
     self.response_parameter_list = response_parameter_list
 
   def __eq__(self, other):
     return super(Method, self).__eq__(other) and \
            self.attribute_list == other.attribute_list and \
            self.ordinal == other.ordinal and \
            self.parameter_list == other.parameter_list and \
            self.response_parameter_list == other.response_parameter_list
 
 
 # This needs to be declared after |Method|.
 class InterfaceBody(NodeListBase):
   """Represents the body of (i.e., list of definitions inside) an interface."""
 
   _list_item_type = (Const, Enum, Method)
 
 
 class Module(NodeBase):
   """Represents a module statement."""
 
-  def __init__(self, name, attribute_list, **kwargs):
-    # |name| is either none or a "wrapped identifier".
-    assert name is None or isinstance(name, tuple)
+  def __init__(self, mojom_namespace, attribute_list, **kwargs):
+    # |mojom_namespace| is either none or a "wrapped identifier".
+    assert mojom_namespace is None or isinstance(mojom_namespace, tuple)
     assert attribute_list is None or isinstance(attribute_list, AttributeList)
     super(Module, self).__init__(**kwargs)
-    self.name = name
+    self.mojom_namespace = mojom_namespace
     self.attribute_list = attribute_list
 
   def __eq__(self, other):
     return super(Module, self).__eq__(other) and \
-           self.name == other.name and \
+           self.mojom_namespace == other.mojom_namespace and \
            self.attribute_list == other.attribute_list
 
 
 class Mojom(NodeBase):
   """Represents an entire .mojom file. (This is the root node.)"""
 
   def __init__(self, module, import_list, definition_list, **kwargs):
     assert module is None or isinstance(module, Module)
     assert isinstance(import_list, ImportList)
     assert isinstance(definition_list, list)
@@ skipping 22 matching lines @@
     self.value = value
 
   def __eq__(self, other):
     return super(Ordinal, self).__eq__(other) and \
            self.value == other.value
 
 
 class Parameter(NodeBase):
   """Represents a method request or response parameter."""
 
-  def __init__(self, name, attribute_list, ordinal, typename, **kwargs):
-    assert isinstance(name, str)
+  def __init__(self, mojom_name, attribute_list, ordinal, typename, **kwargs):
+    assert isinstance(mojom_name, str)
     assert attribute_list is None or isinstance(attribute_list, AttributeList)
     assert ordinal is None or isinstance(ordinal, Ordinal)
     assert isinstance(typename, str)
     super(Parameter, self).__init__(**kwargs)
-    self.name = name
+    self.mojom_name = mojom_name
     self.attribute_list = attribute_list
     self.ordinal = ordinal
     self.typename = typename
 
   def __eq__(self, other):
     return super(Parameter, self).__eq__(other) and \
-           self.name == other.name and \
+           self.mojom_name == other.mojom_name and \
            self.attribute_list == other.attribute_list and \
            self.ordinal == other.ordinal and \
            self.typename == other.typename
 
 
 class ParameterList(NodeListBase):
   """Represents a list of (method request or response) parameters."""
 
   _list_item_type = Parameter
 
 
 class Struct(Definition):
   """Represents a struct definition."""
 
-  def __init__(self, name, attribute_list, body, **kwargs):
+  def __init__(self, mojom_name, attribute_list, body, **kwargs):
     assert attribute_list is None or isinstance(attribute_list, AttributeList)
     assert isinstance(body, StructBody) or body is None
-    super(Struct, self).__init__(name, **kwargs)
+    super(Struct, self).__init__(mojom_name, **kwargs)
     self.attribute_list = attribute_list
     self.body = body
 
   def __eq__(self, other):
     return super(Struct, self).__eq__(other) and \
            self.attribute_list == other.attribute_list and \
            self.body == other.body
 
 
 class StructField(Definition):
   """Represents a struct field definition."""
 
-  def __init__(self, name, attribute_list, ordinal, typename, default_value,
-               **kwargs):
-    assert isinstance(name, str)
+  def __init__(self, mojom_name, attribute_list, ordinal, typename,
+               default_value, **kwargs):
+    assert isinstance(mojom_name, str)
     assert attribute_list is None or isinstance(attribute_list, AttributeList)
     assert ordinal is None or isinstance(ordinal, Ordinal)
     assert isinstance(typename, str)
     # The optional default value is currently either a value as a string or a
     # "wrapped identifier".
     assert default_value is None or isinstance(default_value, (str, tuple))
-    super(StructField, self).__init__(name, **kwargs)
+    super(StructField, self).__init__(mojom_name, **kwargs)
     self.attribute_list = attribute_list
     self.ordinal = ordinal
     self.typename = typename
     self.default_value = default_value
 
   def __eq__(self, other):
     return super(StructField, self).__eq__(other) and \
            self.attribute_list == other.attribute_list and \
            self.ordinal == other.ordinal and \
            self.typename == other.typename and \
            self.default_value == other.default_value
 
 
 # This needs to be declared after |StructField|.
 class StructBody(NodeListBase):
   """Represents the body of (i.e., list of definitions inside) a struct."""
 
   _list_item_type = (Const, Enum, StructField)
 
 
 class Union(Definition):
   """Represents a union definition."""
 
-  def __init__(self, name, attribute_list, body, **kwargs):
+  def __init__(self, mojom_name, attribute_list, body, **kwargs):
     assert attribute_list is None or isinstance(attribute_list, AttributeList)
     assert isinstance(body, UnionBody)
-    super(Union, self).__init__(name, **kwargs)
+    super(Union, self).__init__(mojom_name, **kwargs)
     self.attribute_list = attribute_list
     self.body = body
 
   def __eq__(self, other):
     return super(Union, self).__eq__(other) and \
            self.attribute_list == other.attribute_list and \
            self.body == other.body
 
 
 class UnionField(Definition):
 
-  def __init__(self, name, attribute_list, ordinal, typename, **kwargs):
-    assert isinstance(name, str)
+  def __init__(self, mojom_name, attribute_list, ordinal, typename, **kwargs):
+    assert isinstance(mojom_name, str)
     assert attribute_list is None or isinstance(attribute_list, AttributeList)
     assert ordinal is None or isinstance(ordinal, Ordinal)
     assert isinstance(typename, str)
-    super(UnionField, self).__init__(name, **kwargs)
+    super(UnionField, self).__init__(mojom_name, **kwargs)
     self.attribute_list = attribute_list
     self.ordinal = ordinal
     self.typename = typename
 
   def __eq__(self, other):
     return super(UnionField, self).__eq__(other) and \
            self.attribute_list == other.attribute_list and \
            self.ordinal == other.ordinal and \
            self.typename == other.typename
 
 
 class UnionBody(NodeListBase):
 
   _list_item_type = UnionField