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

mojo/public/tools/bindings/pylib/mojom/generate/translate.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.
 
 """Convert parse tree to AST.
 
 This module converts the parse tree to the AST we use for code generation. The
 main entry point is OrderedModule, which gets passed the parser
 representation of a mojom file. When called it's assumed that all imports have
 already been parsed and converted to ASTs before.
@@ skipping 204 matching lines @@
     second_kind = spec[key_end+2:-1]
 
     kind = mojom.Map(_Kind(kinds, first_kind, scope),
                      _Kind(kinds, second_kind, scope))
   else:
     kind = mojom.Kind(spec)
 
   kinds[spec] = kind
   return kind
 
-def _KindFromImport(original_kind, imported_from):
-  """Used with 'import module' - clones the kind imported from the given
-  module's namespace. Only used with Structs, Unions, Interfaces and Enums."""
-  kind = copy.copy(original_kind)
-  # |shared_definition| is used to store various properties (see
-  # |AddSharedProperty()| in module.py), including |imported_from|. We don't
-  # want the copy to share these with the original, so copy it if necessary.
-  if hasattr(original_kind, 'shared_definition'):
-    kind.shared_definition = copy.copy(original_kind.shared_definition)
-  kind.imported_from = imported_from
-  return kind
-
 def _Import(module, import_module):
-  import_item = {}
-  import_item['module_name'] = import_module.name
-  import_item['namespace'] = import_module.namespace
-  import_item['module'] = import_module
-
   # Copy the struct kinds from our imports into the current module.
   importable_kinds = (mojom.Struct, mojom.Union, mojom.Enum, mojom.Interface)
   for kind in import_module.kinds.itervalues():
     if (isinstance(kind, importable_kinds) and
-        kind.imported_from is None):
-      kind = _KindFromImport(kind, import_item)
+        kind.module.path == import_module.path):
       module.kinds[kind.spec] = kind
   # Ditto for values.
   for value in import_module.values.itervalues():
-    if value.imported_from is None:
-      # Values don't have shared definitions (since they're not nullable), so no
-      # need to do anything special.
-      value = copy.copy(value)
-      value.imported_from = import_item
+    if value.module.path == import_module.path:
       module.values[value.GetSpec()] = value
 
-  return import_item
+  return import_module
 
 def _Struct(module, parsed_struct):
   """
   Args:
     module: {mojom.Module} Module currently being constructed.
     parsed_struct: {ast.Struct} Parsed struct.
 
   Returns:
     {mojom.Struct} AST struct.
   """
@@ skipping 360 matching lines @@
     {mojom.Module} An AST for the mojom.
   """
   module = _Module(tree, name, imports)
   for interface in module.interfaces:
     next_ordinal = 0
     for method in interface.methods:
       if method.ordinal is None:
         method.ordinal = next_ordinal
       next_ordinal = method.ordinal + 1
   return module