Imported Upstream version 1.35.9

[platform/upstream/gobject-introspection.git] / giscanner / transformer.py

diff --git a/giscanner/transformer.py b/giscanner/transformer.py
index d6a5f8f..3513fc8 100644 (file)
--- a/giscanner/transformer.py
+++ b/giscanner/transformer.py
@@ -54,15 +54,11 @@ class Transformer(object):
         self._namespace = namespace
         self._pkg_config_packages = set()
         self._typedefs_ns = {}
-        self._includes = {} # <string namespace -> Namespace>
-        self._include_names = set() # string namespace
+        self._parsed_includes = {} # <string namespace -> Namespace>
         self._includepaths = []
         self._passthrough_mode = False
         self._annotations = {}
 
-    def get_includes(self):
-        return self._include_names
-
     def get_pkgconfig_packages(self):
         return self._pkg_config_packages
 
@@ -125,11 +121,11 @@ class Transformer(object):
         self._includepaths = list(paths)
 
     def register_include(self, include):
-        if include in self._include_names:
+        if include in self._namespace.includes:
             return
+        self._namespace.includes.add(include)
         filename = self._find_include(include)
         self._parse_include(filename)
-        self._include_names.add(include)
 
     def register_include_uninstalled(self, include_path):
         basename = os.path.basename(include_path)
@@ -138,10 +134,10 @@ class Transformer(object):
 "Include path %r must be a filename path ending in .gir" % (include_path, ))
         girname = basename[:-4]
         include = ast.Include.from_string(girname)
-        if include in self._include_names:
+        if include in self._namespace.includes:
             return
+        self._namespace.includes.add(include)
         self._parse_include(include_path, uninstalled=True)
-        self._include_names.add(include)
 
     def lookup_giname(self, name):
         """Given a name of the form Foo or Bar.Foo,
@@ -155,11 +151,11 @@ namespaces."""
             if ns == self._namespace.name:
                 return self._namespace.get(giname)
             # Fallback to the main namespace if not a dependency and matches a prefix
-            if ns in self._namespace.identifier_prefixes and not ns in self._includes:
+            if ns in self._namespace.identifier_prefixes and not ns in self._parsed_includes:
                 message.warn(("Deprecated reference to identifier " +
                               "prefix %s in GIName %s") % (ns, name))
                 return self._namespace.get(giname)
-            include = self._includes[ns]
+            include = self._parsed_includes[ns]
             return include.get(giname)
 
     def lookup_typenode(self, typeobj):
@@ -196,7 +192,7 @@ None."""
         self._parse_include(filename)
         parser = self._cachestore.load(filename)
         self._namespace = parser.get_namespace()
-        del self._includes[self._namespace.name]
+        del self._parsed_includes[self._namespace.name]
         return self
 
     def _parse_include(self, filename, uninstalled=False):
@@ -209,20 +205,22 @@ None."""
             if self._cachestore is not None:
                 self._cachestore.store(filename, parser)
 
-        for include in parser.get_includes():
-            self.register_include(include)
+        for include in parser.get_namespace().includes:
+            if include.name not in self._parsed_includes:
+                dep_filename = self._find_include(include)
+                self._parse_include(dep_filename)
 
         if not uninstalled:
-            for pkg in parser.get_pkgconfig_packages():
+            for pkg in parser.get_namespace().exported_packages:
                 self._pkg_config_packages.add(pkg)
         namespace = parser.get_namespace()
-        self._includes[namespace.name] = namespace
+        self._parsed_includes[namespace.name] = namespace
 
     def _iter_namespaces(self):
         """Return an iterator over all included namespaces; the
 currently-scanned namespace is first."""
         yield self._namespace
-        for ns in self._includes.itervalues():
+        for ns in self._parsed_includes.itervalues():
             yield ns
 
     def _sort_matches(self, x, y):
@@ -481,8 +479,8 @@ raise ValueError."""
     def _create_parameters(self, symbol, base_type):
         # warn if we see annotations for unknown parameters
         param_names = set(child.ident for child in base_type.child_list)
-        for child in base_type.child_list:
-            yield self._create_parameter(symbol, child)
+        for i, child in enumerate(base_type.child_list):
+            yield self._create_parameter(symbol, i, child)
 
     def _synthesize_union_type(self, symbol, parent_symbol):
         # Synthesize a named union so that it can be referenced.
@@ -695,16 +693,20 @@ raise ValueError."""
             return container
         return ast.Type(ctype=ctype, is_const=is_const, complete_ctype=complete_ctype)
 
-    def _create_parameter(self, parent_symbol, symbol):
+    def _create_parameter(self, parent_symbol, index, symbol):
         if symbol.type == CSYMBOL_TYPE_ELLIPSIS:
             ptype = ast.Varargs()
         else:
             ptype = self._create_type_from_base(symbol.base_type, is_parameter=True)
 
-        if symbol.ident is None and symbol.base_type and symbol.base_type.type != CTYPE_VOID:
-            message.warn_symbol(parent_symbol, "missing parameter name; undocumentable")
+        if symbol.ident is None:
+            if symbol.base_type and symbol.base_type.type != CTYPE_VOID:
+                message.warn_symbol(parent_symbol, "missing parameter name; undocumentable")
+            ident = 'arg%d' % (index, )
+        else:
+            ident = symbol.ident
 
-        return ast.Parameter(symbol.ident, ptype)
+        return ast.Parameter(ident, ptype)
 
     def _create_return(self, source_type):
         typeval = self._create_type_from_base(source_type, is_return=True)
@@ -895,7 +897,7 @@ Note that type resolution may not succeed."""
         # which has nominal namespace of "Meta", but a few classes are
         # "Mutter".  We don't export that data in introspection currently.
         # Basically the library should be fixed, but we'll hack around it here.
-        for namespace in self._includes.itervalues():
+        for namespace in self._parsed_includes.itervalues():
             target = namespace.get_by_ctype(pointer_stripped)
             if target:
                 typeval.target_giname = '%s.%s' % (namespace.name, target.name)