Mojo code generator: simplify how imported types and values are handled.

mojo/public/tools/bindings/pylib/mojom/generate/module.py

 # Copyright 2013 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 module's classes provide an interface to mojo modules. Modules are
 # collections of interfaces and structs to be used by mojo ipc clients and
 # servers.
 #
 # A simple interface would be created this way:
 # module = mojom.generate.module.Module('Foo')
@@ skipping 64 matching lines @@
       obj.__class__.__name__,
       ',\n'.join(ReprIndent(name, as_ref)
                  for (name, as_ref) in names.iteritems()))
 
 
 class Kind(object):
   """Kind represents a type (e.g. int8, string).
 
   Attributes:
     spec: A string uniquely identifying the type. May be None.
+    module: {Module} The defining module. Set to None for built-in types.
     parent_kind: The enclosing type. For example, a struct defined
         inside an interface has that interface as its parent. May be None.
   """
-  def __init__(self, spec=None):
+  def __init__(self, spec=None, module=None):
     self.spec = spec
+    self.module = module
     self.parent_kind = None
 
   def Repr(self, as_ref=True):
     return '<%s spec=%r>' % (self.__class__.__name__, self.spec)
 
   def __repr__(self):
     # Gives us a decent __repr__ for all kinds.
     return self.Repr()
 
 
 class ReferenceKind(Kind):
   """ReferenceKind represents pointer and handle types.
 
   A type is nullable if null (for pointer types) or invalid handle (for handle
   types) is a legal value for the type.
 
   Attributes:
     is_nullable: True if the type is nullable.
   """
-
-  def __init__(self, spec=None, is_nullable=False):
+  def __init__(self, spec=None, is_nullable=False, module=None):
     assert spec is None or is_nullable == spec.startswith('?')
-    Kind.__init__(self, spec)
+    Kind.__init__(self, spec, module)
     self.is_nullable = is_nullable
     self.shared_definition = {}
 
   def Repr(self, as_ref=True):
     return '<%s spec=%r is_nullable=%r>' % (self.__class__.__name__, self.spec,
                                             self.is_nullable)
 
   def MakeNullableKind(self):
     assert not self.is_nullable
 
     if self == STRING:
       return NULLABLE_STRING
     if self == HANDLE:
       return NULLABLE_HANDLE
     if self == DCPIPE:
       return NULLABLE_DCPIPE
     if self == DPPIPE:
       return NULLABLE_DPPIPE
     if self == MSGPIPE:
       return NULLABLE_MSGPIPE
     if self == SHAREDBUFFER:
       return NULLABLE_SHAREDBUFFER
 
     nullable_kind = type(self)()
     nullable_kind.shared_definition = self.shared_definition
     if self.spec is not None:
       nullable_kind.spec = '?' + self.spec
     nullable_kind.is_nullable = True
+    nullable_kind.parent_kind = self.parent_kind
+    nullable_kind.module = self.module
 
     return nullable_kind
 
   @classmethod
   def AddSharedProperty(cls, name):
     """Adds a property |name| to |cls|, which accesses the corresponding item in
        |shared_definition|.
 
        The reason of adding such indirection is to enable sharing definition
        between a reference kind and its nullable variation. For example:
@@ skipping 66 matching lines @@
 
 
 ATTRIBUTE_MIN_VERSION = 'MinVersion'
 ATTRIBUTE_EXTENSIBLE = 'Extensible'
 ATTRIBUTE_SYNC = 'Sync'
 
 
 class NamedValue(object):
   def __init__(self, module, parent_kind, name):
     self.module = module
-    self.namespace = module.namespace
     self.parent_kind = parent_kind
     self.name = name
-    self.imported_from = None
 
   def GetSpec(self):
-    return (self.namespace + '.' +
+    return (self.module.namespace + '.' +
         (self.parent_kind and (self.parent_kind.name + '.') or "") +
         self.name)
 
 
 class BuiltinValue(object):
   def __init__(self, value):
     self.value = value
 
 
 class ConstantValue(NamedValue):
   def __init__(self, module, parent_kind, constant):
     NamedValue.__init__(self, module, parent_kind, constant.name)
     self.constant = constant
 
 
 class EnumValue(NamedValue):
   def __init__(self, module, enum, field):
     NamedValue.__init__(self, module, enum.parent_kind, field.name)
     self.enum = enum
 
   def GetSpec(self):
-    return (self.namespace + '.' +
+    return (self.module.namespace + '.' +
         (self.parent_kind and (self.parent_kind.name + '.') or "") +
         self.enum.name + '.' + self.name)
 
 
 class Constant(object):
   def __init__(self, name=None, kind=None, value=None, parent_kind=None):
     self.name = name
     self.kind = kind
     self.value = value
     self.parent_kind = parent_kind
@@ skipping 27 matching lines @@
 class UnionField(Field): pass
 
 
 class Struct(ReferenceKind):
   """A struct with typed fields.
 
   Attributes:
     name: {str} The name of the struct type.
     native_only: {bool} Does the struct have a body (i.e. any fields) or is it
         purely a native struct.
-    module: {Module} The defining module.
-    imported_from: {dict} Information about where this union was
-        imported from.
     fields: {List[StructField]} The members of the struct.
     attributes: {dict} Additional information about the struct, such as
         if it's a native struct.
   """
 
   ReferenceKind.AddSharedProperty('name')
   ReferenceKind.AddSharedProperty('native_only')
-  ReferenceKind.AddSharedProperty('module')
-  ReferenceKind.AddSharedProperty('imported_from')
   ReferenceKind.AddSharedProperty('fields')
   ReferenceKind.AddSharedProperty('attributes')
 
   def __init__(self, name=None, module=None, attributes=None):
     if name is not None:
       spec = 'x:' + name
     else:
       spec = None
-    ReferenceKind.__init__(self, spec)
+    ReferenceKind.__init__(self, spec, False, module)
     self.name = name
     self.native_only = False
-    self.module = module
-    self.imported_from = None
     self.fields = []
     self.attributes = attributes
 
   def Repr(self, as_ref=True):
     if as_ref:
-      return '<%s name=%r imported_from=%s>' % (
+      return '<%s name=%r module=%s>' % (
           self.__class__.__name__, self.name,
-          Repr(self.imported_from, as_ref=True))
+          Repr(self.module, as_ref=True))
     else:
-      return GenericRepr(self, {'name': False, 'fields': False,
-                                'imported_from': True})
+      return GenericRepr(self, {'name': False, 'fields': False, 'module': True})
 
   def AddField(self, name, kind, ordinal=None, default=None, attributes=None):
     field = StructField(name, kind, ordinal, default, attributes)
     self.fields.append(field)
     return field
 
 
 class Union(ReferenceKind):
   """A union of several kinds.
 
   Attributes:
     name: {str} The name of the union type.
-    module: {Module} The defining module.
-    imported_from: {dict} Information about where this union was
-        imported from.
     fields: {List[UnionField]} The members of the union.
     attributes: {dict} Additional information about the union, such as
         which Java class name to use to represent it in the generated
         bindings.
   """
   ReferenceKind.AddSharedProperty('name')
-  ReferenceKind.AddSharedProperty('module')
-  ReferenceKind.AddSharedProperty('imported_from')
   ReferenceKind.AddSharedProperty('fields')
   ReferenceKind.AddSharedProperty('attributes')
 
   def __init__(self, name=None, module=None, attributes=None):
     if name is not None:
       spec = 'x:' + name
     else:
       spec = None
-    ReferenceKind.__init__(self, spec)
+    ReferenceKind.__init__(self, spec, False, module)
     self.name = name
-    self.module = module
-    self.imported_from = None
     self.fields = []
     self.attributes = attributes
 
   def Repr(self, as_ref=True):
     if as_ref:
       return '<%s spec=%r is_nullable=%r fields=%s>' % (
           self.__class__.__name__, self.spec, self.is_nullable,
           Repr(self.fields))
     else:
       return GenericRepr(self, {'fields': True, 'is_nullable': False})
@@ skipping 160 matching lines @@
     return self.attributes.get(ATTRIBUTE_MIN_VERSION) \
         if self.attributes else None
 
   @property
   def sync(self):
     return self.attributes.get(ATTRIBUTE_SYNC) \
         if self.attributes else None
 
 
 class Interface(ReferenceKind):
-  ReferenceKind.AddSharedProperty('module')
   ReferenceKind.AddSharedProperty('name')
-  ReferenceKind.AddSharedProperty('imported_from')
   ReferenceKind.AddSharedProperty('methods')
   ReferenceKind.AddSharedProperty('attributes')
 
   def __init__(self, name=None, module=None, attributes=None):
     if name is not None:
       spec = 'x:' + name
     else:
       spec = None
-    ReferenceKind.__init__(self, spec)
-    self.module = module
+    ReferenceKind.__init__(self, spec, False, module)
     self.name = name
-    self.imported_from = None
     self.methods = []
     self.attributes = attributes
 
   def Repr(self, as_ref=True):
     if as_ref:
       return '<%s name=%r>' % (self.__class__.__name__, self.name)
     else:
       return GenericRepr(self, {'name': False, 'attributes': False,
                                 'methods': False})
 
@@ skipping 32 matching lines @@
     self.numeric_value = numeric_value
 
   @property
   def min_version(self):
     return self.attributes.get(ATTRIBUTE_MIN_VERSION) \
         if self.attributes else None
 
 
 class Enum(Kind):
   def __init__(self, name=None, module=None, attributes=None):
-    self.module = module
     self.name = name
     self.native_only = False
-    self.imported_from = None
     if name is not None:
       spec = 'x:' + name
     else:
       spec = None
-    Kind.__init__(self, spec)
+    Kind.__init__(self, spec, module)
     self.fields = []
     self.attributes = attributes
 
   def Repr(self, as_ref=True):
     if as_ref:
       return '<%s name=%r>' % (self.__class__.__name__, self.name)
     else:
       return GenericRepr(self, {'name': False, 'fields': False})
 
   @property
@@ skipping 253 matching lines @@
       return True
     elif IsAnyInterfaceKind(kind):
       return True
     elif IsArrayKind(kind):
       return Check(kind.kind)
     elif IsMapKind(kind):
       return Check(kind.key_kind) or Check(kind.value_kind)
     else:
       return False
   return Check(kind)