libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/third_party/logilab/astroid/manager.py

@@ -21,45 +21,23 @@ from various source and using a cache of built modules)
 """
 from __future__ import print_function
 
-__docformat__ = "restructuredtext en"
-
-import collections
 import imp
 import os
-from os.path import dirname, join, isdir, exists
-from warnings import warn
 import zipimport
 
-from logilab.common.configuration import OptionsProviderMixIn
-
-from astroid.exceptions import AstroidBuildingException
+from astroid import exceptions
 from astroid import modutils
+from astroid import transforms
 
 
-def astroid_wrapper(func, modname):
-    """wrapper to give to AstroidManager.project_from_files"""
-    print('parsing %s...' % modname)
-    try:
-        return func(modname)
-    except AstroidBuildingException as exc:
-        print(exc)
-    except Exception as exc:
-        import traceback
-        traceback.print_exc()
-
-def _silent_no_wrap(func, modname):
-    """silent wrapper that doesn't do anything; can be used for tests"""
-    return func(modname)
-
 def safe_repr(obj):
     try:
         return repr(obj)
-    except:
+    except Exception: # pylint: disable=broad-except
         return '???'
 
 
-
-class AstroidManager(OptionsProviderMixIn):
+class AstroidManager(object):
     """the astroid manager, responsible to build astroid from files
      or modules.
 
@@ -67,31 +45,27 @@ class AstroidManager(OptionsProviderMixIn):
     """
 
     name = 'astroid loader'
-    options = (("ignore",
-                {'type' : "csv", 'metavar' : "<file>",
-                 'dest' : "black_list", "default" : ('CVS',),
-                 'help' : "add <file> (may be a directory) to the black list\
-. It should be a base name, not a path. You may set this option multiple times\
-."}),
-               ("project",
-                {'default': "No Name", 'type' : 'string', 'short': 'p',
-                 'metavar' : '<project name>',
-                 'help' : 'set the project name.'}),
-              )
     brain = {}
+
     def __init__(self):
         self.__dict__ = AstroidManager.brain
         if not self.__dict__:
-            OptionsProviderMixIn.__init__(self)
-            self.load_defaults()
             # NOTE: cache entries are added by the [re]builder
             self.astroid_cache = {}
             self._mod_file_cache = {}
-            self.transforms = collections.defaultdict(list)
             self._failed_import_hooks = []
             self.always_load_extensions = False
             self.optimize_ast = False
             self.extension_package_whitelist = set()
+            self._transform = transforms.TransformVisitor()
+
+            # Export these APIs for convenience
+            self.register_transform = self._transform.register_transform
+            self.unregister_transform = self._transform.unregister_transform
+
+    def visit_transforms(self, node):
+        """Visit the transforms and apply them to the given *node*."""
+        return self._transform.visit(node)
 
     def ast_from_file(self, filepath, modname=None, fallback=True, source=False):
         """given a module name, return the astroid object"""
@@ -105,15 +79,15 @@ class AstroidManager(OptionsProviderMixIn):
                 modname = '.'.join(modutils.modpath_from_file(filepath))
             except ImportError:
                 modname = filepath
-        if modname in self.astroid_cache and self.astroid_cache[modname].file == filepath:
+        if modname in self.astroid_cache and self.astroid_cache[modname].source_file == filepath:
             return self.astroid_cache[modname]
         if source:
             from astroid.builder import AstroidBuilder
             return AstroidBuilder(self).file_build(filepath, modname)
         elif fallback and modname:
             return self.ast_from_module_name(modname)
-        raise AstroidBuildingException('unable to get astroid for file %s' %
-                                       filepath)
+        raise exceptions.AstroidBuildingException(
+            'unable to get astroid for file %s' % filepath)
 
     def _build_stub_module(self, modname):
         from astroid.builder import AstroidBuilder
@@ -137,7 +111,7 @@ class AstroidManager(OptionsProviderMixIn):
             return self._build_stub_module(modname)
         old_cwd = os.getcwd()
         if context_file:
-            os.chdir(dirname(context_file))
+            os.chdir(os.path.dirname(context_file))
         try:
             filepath, mp_type = self.file_from_module_name(modname, context_file)
             if mp_type == modutils.PY_ZIPMODULE:
@@ -151,18 +125,20 @@ class AstroidManager(OptionsProviderMixIn):
                     module = modutils.load_module_from_name(modname)
                 except Exception as ex:
                     msg = 'Unable to load module %s (%s)' % (modname, ex)
-                    raise AstroidBuildingException(msg)
+                    raise exceptions.AstroidBuildingException(msg)
                 return self.ast_from_module(module, modname)
             elif mp_type == imp.PY_COMPILED:
-                raise AstroidBuildingException("Unable to load compiled module %s" % (modname,))
+                msg = "Unable to load compiled module %s" % (modname,)
+                raise exceptions.AstroidBuildingException(msg)
             if filepath is None:
-                raise AstroidBuildingException("Unable to load module %s" % (modname,))
+                msg = "Unable to load module %s" % (modname,)
+                raise exceptions.AstroidBuildingException(msg)
             return self.ast_from_file(filepath, modname, fallback=False)
-        except AstroidBuildingException as e:
+        except exceptions.AstroidBuildingException as e:
             for hook in self._failed_import_hooks:
                 try:
                     return hook(modname)
-                except AstroidBuildingException:
+                except exceptions.AstroidBuildingException:
                     pass
             raise e
         finally:
@@ -186,11 +162,12 @@ class AstroidManager(OptionsProviderMixIn):
                 module = builder.string_build(importer.get_source(resource),
                                               zmodname, filepath)
                 return module
-            except:
+            except Exception: # pylint: disable=broad-except
                 continue
         return None
 
     def file_from_module_name(self, modname, contextfile):
+        # pylint: disable=redefined-variable-type
         try:
             value = self._mod_file_cache[(modname, contextfile)]
         except KeyError:
@@ -199,9 +176,9 @@ class AstroidManager(OptionsProviderMixIn):
                     modname.split('.'), context_file=contextfile)
             except ImportError as ex:
                 msg = 'Unable to load module %s (%s)' % (modname, ex)
-                value = AstroidBuildingException(msg)
+                value = exceptions.AstroidBuildingException(msg)
             self._mod_file_cache[(modname, contextfile)] = value
-        if isinstance(value, AstroidBuildingException):
+        if isinstance(value, exceptions.AstroidBuildingException):
             raise value
         return value
 
@@ -226,12 +203,11 @@ class AstroidManager(OptionsProviderMixIn):
             try:
                 modname = klass.__module__
             except AttributeError:
-                raise AstroidBuildingException(
-                    'Unable to get module for class %s' % safe_repr(klass))
+                msg = 'Unable to get module for class %s' % safe_repr(klass)
+                raise exceptions.AstroidBuildingException(msg)
         modastroid = self.ast_from_module_name(modname)
         return modastroid.getattr(klass.__name__)[0] # XXX
 
-
     def infer_ast_from_something(self, obj, context=None):
         """infer astroid for the given class"""
         if hasattr(obj, '__class__') and not isinstance(obj, type):
@@ -241,75 +217,29 @@ class AstroidManager(OptionsProviderMixIn):
         try:
             modname = klass.__module__
         except AttributeError:
-            raise AstroidBuildingException(
-                'Unable to get module for %s' % safe_repr(klass))
+            msg = 'Unable to get module for %s' % safe_repr(klass)
+            raise exceptions.AstroidBuildingException(msg)
         except Exception as ex:
-            raise AstroidBuildingException(
-                'Unexpected error while retrieving module for %s: %s'
-                % (safe_repr(klass), ex))
+            msg = ('Unexpected error while retrieving module for %s: %s'
+                   % (safe_repr(klass), ex))
+            raise exceptions.AstroidBuildingException(msg)
         try:
             name = klass.__name__
         except AttributeError:
-            raise AstroidBuildingException(
-                'Unable to get name for %s' % safe_repr(klass))
+            msg = 'Unable to get name for %s' % safe_repr(klass)
+            raise exceptions.AstroidBuildingException(msg)
         except Exception as ex:
-            raise AstroidBuildingException(
-                'Unexpected error while retrieving name for %s: %s'
-                % (safe_repr(klass), ex))
+            exc = ('Unexpected error while retrieving name for %s: %s'
+                   % (safe_repr(klass), ex))
+            raise exceptions.AstroidBuildingException(exc)
         # take care, on living object __module__ is regularly wrong :(
         modastroid = self.ast_from_module_name(modname)
         if klass is obj:
-            for  infered in modastroid.igetattr(name, context):
-                yield infered
+            for inferred in modastroid.igetattr(name, context):
+                yield inferred
         else:
-            for infered in modastroid.igetattr(name, context):
-                yield infered.instanciate_class()
-
-    def project_from_files(self, files, func_wrapper=astroid_wrapper,
-                           project_name=None, black_list=None):
-        """return a Project from a list of files or modules"""
-        # build the project representation
-        project_name = project_name or self.config.project
-        black_list = black_list or self.config.black_list
-        project = Project(project_name)
-        for something in files:
-            if not exists(something):
-                fpath = modutils.file_from_modpath(something.split('.'))
-            elif isdir(something):
-                fpath = join(something, '__init__.py')
-            else:
-                fpath = something
-            astroid = func_wrapper(self.ast_from_file, fpath)
-            if astroid is None:
-                continue
-            # XXX why is first file defining the project.path ?
-            project.path = project.path or astroid.file
-            project.add_module(astroid)
-            base_name = astroid.name
-            # recurse in package except if __init__ was explicitly given
-            if astroid.package and something.find('__init__') == -1:
-                # recurse on others packages / modules if this is a package
-                for fpath in modutils.get_module_files(dirname(astroid.file),
-                                                       black_list):
-                    astroid = func_wrapper(self.ast_from_file, fpath)
-                    if astroid is None or astroid.name == base_name:
-                        continue
-                    project.add_module(astroid)
-        return project
-
-    def register_transform(self, node_class, transform, predicate=None):
-        """Register `transform(node)` function to be applied on the given
-        Astroid's `node_class` if `predicate` is None or returns true
-        when called with the node as argument.
-
-        The transform function may return a value which is then used to
-        substitute the original node in the tree.
-        """
-        self.transforms[node_class].append((transform, predicate))
-
-    def unregister_transform(self, node_class, transform, predicate=None):
-        """Unregister the given transform."""
-        self.transforms[node_class].remove((transform, predicate))
+            for inferred in modastroid.igetattr(name, context):
+                yield inferred.instantiate_class()
 
     def register_failed_import_hook(self, hook):
         """Registers a hook to resolve imports that cannot be found otherwise.
@@ -321,30 +251,6 @@ class AstroidManager(OptionsProviderMixIn):
         """
         self._failed_import_hooks.append(hook)
 
-    def transform(self, node):
-        """Call matching transforms for the given node if any and return the
-        transformed node.
-        """
-        cls = node.__class__
-        if cls not in self.transforms:
-            # no transform registered for this class of node
-            return node
-
-        transforms = self.transforms[cls]
-        orig_node = node  # copy the reference
-        for transform_func, predicate in transforms:
-            if predicate is None or predicate(node):
-                ret = transform_func(node)
-                # if the transformation function returns something, it's
-                # expected to be a replacement for the node
-                if ret is not None:
-                    if node is not orig_node:
-                        # node has already be modified by some previous
-                        # transformation, warn about it
-                        warn('node %s substituted multiple times' % node)
-                    node = ret
-        return node
-
     def cache_module(self, module):
         """Cache a module if no module with the same name is known yet."""
         self.astroid_cache.setdefault(module.name, module)
@@ -359,33 +265,3 @@ class AstroidManager(OptionsProviderMixIn):
         import astroid.raw_building
         astroid.raw_building._astroid_bootstrapping(
             astroid_builtin=astroid_builtin)
-
-
-class Project(object):
-    """a project handle a set of modules / packages"""
-    def __init__(self, name=''):
-        self.name = name
-        self.path = None
-        self.modules = []
-        self.locals = {}
-        self.__getitem__ = self.locals.__getitem__
-        self.__iter__ = self.locals.__iter__
-        self.values = self.locals.values
-        self.keys = self.locals.keys
-        self.items = self.locals.items
-
-    def add_module(self, node):
-        self.locals[node.name] = node
-        self.modules.append(node)
-
-    def get_module(self, name):
-        return self.locals[name]
-
-    def get_children(self):
-        return self.modules
-
-    def __repr__(self):
-        return '<Project %r at %s (%s modules)>' % (self.name, id(self),
-                                                    len(self.modules))
-
-

data/vendor/depot_tools/third_party/logilab/astroid/mixins.py

@@ -18,16 +18,16 @@
 """This module contains some mixins for the different nodes.
 """
 
-from logilab.common.decorators import cachedproperty
+import warnings
 
-from astroid.exceptions import (AstroidBuildingException, InferenceError,
-                                NotFoundError)
+from astroid import decorators
+from astroid import exceptions
 
 
 class BlockRangeMixIn(object):
     """override block range """
 
-    @cachedproperty
+    @decorators.cachedproperty
     def blockstart_tolineno(self):
         return self.lineno
 
@@ -55,15 +55,29 @@ class FilterStmtsMixin(object):
             return [node], True
         return _stmts, False
 
-    def ass_type(self):
+    def assign_type(self):
         return self
 
+    def ass_type(self):
+        warnings.warn('%s.ass_type() is deprecated and slated for removal '
+                      'in astroid 2.0, use %s.assign_type() instead.'
+                      % (type(self).__name__, type(self).__name__),
+                      PendingDeprecationWarning, stacklevel=2)
+        return self.assign_type()
+
 
 class AssignTypeMixin(object):
 
-    def ass_type(self):
+    def assign_type(self):
         return self
 
+    def ass_type(self):
+        warnings.warn('%s.ass_type() is deprecated and slated for removal '
+                      'in astroid 2.0, use %s.assign_type() instead.'
+                      % (type(self).__name__, type(self).__name__),
+                      PendingDeprecationWarning, stacklevel=2)
+        return self.assign_type()
+
     def _get_filtered_stmts(self, lookup_node, node, _stmts, mystmt):
         """method used in filter_stmts"""
         if self is mystmt:
@@ -77,11 +91,18 @@ class AssignTypeMixin(object):
 
 class ParentAssignTypeMixin(AssignTypeMixin):
 
+    def assign_type(self):
+        return self.parent.assign_type()
+
     def ass_type(self):
-        return self.parent.ass_type()
+        warnings.warn('%s.ass_type() is deprecated and slated for removal '
+                      'in astroid 2.0, use %s.assign_type() instead.'
+                      % (type(self).__name__, type(self).__name__),
+                      PendingDeprecationWarning, stacklevel=2)
+        return self.assign_type()
 
 
-class FromImportMixIn(FilterStmtsMixin):
+class ImportFromMixin(FilterStmtsMixin):
     """MixIn for From and Import Nodes"""
 
     def _infer_name(self, frame, name):
@@ -104,11 +125,14 @@ class FromImportMixIn(FilterStmtsMixin):
             # FIXME: we used to raise InferenceError here, but why ?
             return mymodule
         try:
-            return mymodule.import_module(modname, level=level)
-        except AstroidBuildingException:
-            raise InferenceError(modname)
+            return mymodule.import_module(modname, level=level,
+                                          relative_only=level and level >= 1)
+        except exceptions.AstroidBuildingException as ex:
+            if isinstance(ex.args[0], SyntaxError):
+                raise exceptions.InferenceError(str(ex))
+            raise exceptions.InferenceError(modname)
         except SyntaxError as ex:
-            raise InferenceError(str(ex))
+            raise exceptions.InferenceError(str(ex))
 
     def real_name(self, asname):
         """get name from 'as' name"""
@@ -120,5 +144,4 @@ class FromImportMixIn(FilterStmtsMixin):
                 _asname = name
             if asname == _asname:
                 return name
-        raise NotFoundError(asname)
-
+        raise exceptions.NotFoundError(asname)

data/vendor/depot_tools/third_party/logilab/astroid/modutils.py

@@ -28,10 +28,9 @@
 """
 from __future__ import with_statement
 
-__docformat__ = "restructuredtext en"
-
 import imp
 import os
+import platform
 import sys
 from distutils.sysconfig import get_python_lib
 from distutils.errors import DistutilsPlatformError
@@ -42,8 +41,6 @@ try:
 except ImportError:
     pkg_resources = None
 
-from logilab.common import _handle_blacklist
-
 PY_ZIPMODULE = object()
 
 if sys.platform.startswith('win'):
@@ -53,12 +50,7 @@ else:
     PY_SOURCE_EXTS = ('py',)
     PY_COMPILED_EXTS = ('so',)
 
-# Notes about STD_LIB_DIRS
-# Consider arch-specific installation for STD_LIB_DIRS definition
-# :mod:`distutils.sysconfig` contains to much hardcoded values to rely on
-#
-# :see: `Problems with /usr/lib64 builds <http://bugs.python.org/issue1294959>`_
-# :see: `FHS <http://www.pathname.com/fhs/pub/fhs-2.3.html#LIBLTQUALGTALTERNATEFORMATESSENTIAL>`_
+
 try:
     # The explicit sys.prefix is to work around a patch in virtualenv that
     # replaces the 'real' sys.prefix (i.e. the location of the binary)
@@ -70,22 +62,53 @@ try:
         # Take care of installations where exec_prefix != prefix.
         get_python_lib(standard_lib=True, prefix=sys.exec_prefix),
         get_python_lib(standard_lib=True)])
-    if os.name == 'nt':
-        STD_LIB_DIRS.add(os.path.join(sys.prefix, 'dlls'))
-        try:
-            # real_prefix is defined when running inside virtualenv.
-            STD_LIB_DIRS.add(os.path.join(sys.real_prefix, 'dlls'))
-        except AttributeError:
-            pass
 # get_python_lib(standard_lib=1) is not available on pypy, set STD_LIB_DIR to
 # non-valid path, see https://bugs.pypy.org/issue1164
 except DistutilsPlatformError:
     STD_LIB_DIRS = set()
 
-EXT_LIB_DIR = get_python_lib()
+if os.name == 'nt':
+    STD_LIB_DIRS.add(os.path.join(sys.prefix, 'dlls'))
+    try:
+        # real_prefix is defined when running inside virtualenv.
+        STD_LIB_DIRS.add(os.path.join(sys.real_prefix, 'dlls'))
+    except AttributeError:
+        pass
+if platform.python_implementation() == 'PyPy':
+    _root = os.path.join(sys.prefix, 'lib_pypy')
+    STD_LIB_DIRS.add(_root)
+    try:
+        # real_prefix is defined when running inside virtualenv.
+        STD_LIB_DIRS.add(os.path.join(sys.real_prefix, 'lib_pypy'))
+    except AttributeError:
+        pass
+    del _root
+if os.name == 'posix':
+    # Need the real prefix is we're under a virtualenv, otherwise
+    # the usual one will do.
+    try:
+        prefix = sys.real_prefix
+    except AttributeError:
+        prefix = sys.prefix
+
+    def _posix_path(path):
+        base_python = 'python%d.%d' % sys.version_info[:2]
+        return os.path.join(prefix, path, base_python)
+
+    STD_LIB_DIRS.add(_posix_path('lib'))
+    if sys.maxsize > 2**32:
+        # This tries to fix a problem with /usr/lib64 builds,
+        # where systems are running both 32-bit and 64-bit code
+        # on the same machine, which reflects into the places where
+        # standard library could be found. More details can be found
+        # here http://bugs.python.org/issue1294959.
+        # An easy reproducing case would be
+        # https://github.com/PyCQA/pylint/issues/712#issuecomment-163178753
+        STD_LIB_DIRS.add(_posix_path('lib64'))
 
-BUILTIN_MODULES = dict(zip(sys.builtin_module_names,
-                           [1]*len(sys.builtin_module_names)))
+EXT_LIB_DIR = get_python_lib()
+IS_JYTHON = platform.python_implementation() == 'Jython'
+BUILTIN_MODULES = dict.fromkeys(sys.builtin_module_names, True)
 
 
 class NoSourceFile(Exception):
@@ -97,6 +120,32 @@ def _normalize_path(path):
     return os.path.normcase(os.path.abspath(path))
 
 
+def _path_from_filename(filename, is_jython=IS_JYTHON):
+    if not is_jython:
+        if sys.version_info > (3, 0):
+            return filename
+        else:
+            if filename.endswith(".pyc"):
+                return filename[:-1]
+            return filename
+    head, has_pyclass, _ = filename.partition("$py.class")
+    if has_pyclass:
+        return head + ".py"
+    return filename
+
+
+def _handle_blacklist(blacklist, dirnames, filenames):
+    """remove files/directories in the black list
+
+    dirnames/filenames are usually from os.walk
+    """
+    for norecurs in blacklist:
+        if norecurs in dirnames:
+            dirnames.remove(norecurs)
+        elif norecurs in filenames:
+            filenames.remove(norecurs)
+
+
 _NORM_PATH_CACHE = {}
 
 def _cache_normalize_path(path):
@@ -112,7 +161,7 @@ def _cache_normalize_path(path):
         result = _NORM_PATH_CACHE[path] = _normalize_path(path)
         return result
 
-def load_module_from_name(dotted_name, path=None, use_sys=1):
+def load_module_from_name(dotted_name, path=None, use_sys=True):
     """Load a Python module from its name.
 
     :type dotted_name: str
@@ -184,14 +233,16 @@ def load_module_from_modpath(parts, path=None, use_sys=1):
         if prevmodule:
             setattr(prevmodule, part, module)
         _file = getattr(module, '__file__', '')
+        prevmodule = module
+        if not _file and _is_namespace(curname):
+            continue
         if not _file and len(modpath) != len(parts):
             raise ImportError('no module in %s' % '.'.join(parts[len(modpath):]))
         path = [os.path.dirname(_file)]
-        prevmodule = module
     return module
 
 
-def load_module_from_file(filepath, path=None, use_sys=1, extrapath=None):
+def load_module_from_file(filepath, path=None, use_sys=True, extrapath=None):
     """Load a Python module from it's path.
 
     :type filepath: str
@@ -219,9 +270,11 @@ def load_module_from_file(filepath, path=None, use_sys=1, extrapath=None):
 
 def _check_init(path, mod_path):
     """check there are some __init__.py all along the way"""
+    modpath = []
     for part in mod_path:
+        modpath.append(part)
         path = os.path.join(path, part)
-        if not _has_init(path):
+        if not _is_namespace('.'.join(modpath)) and not _has_init(path):
             return False
     return True
 
@@ -246,7 +299,9 @@ def modpath_from_file(filename, extrapath=None):
     :rtype: list(str)
     :return: the corresponding splitted module's name
     """
-    base = os.path.splitext(os.path.abspath(filename))[0]
+    filename = _path_from_filename(filename)
+    filename = os.path.abspath(filename)
+    base = os.path.splitext(filename)[0]
     if extrapath is not None:
         for path_ in extrapath:
             path = os.path.abspath(path_)
@@ -317,8 +372,8 @@ def file_info_from_modpath(modpath, path=None, context_file=None):
 def get_module_part(dotted_name, context_file=None):
     """given a dotted name return the module part of the name :
 
-    >>> get_module_part('logilab.common.modutils.get_module_part')
-    'logilab.common.modutils'
+    >>> get_module_part('astroid.as_string.dump')
+    'astroid.as_string'
 
     :type dotted_name: str
     :param dotted_name: full name of the identifier we are interested in
@@ -382,9 +437,8 @@ def get_module_files(src_directory, blacklist):
       path of the directory corresponding to the package
 
     :type blacklist: list or tuple
-    :param blacklist:
-      optional list of files or directory to ignore, default to the value of
-      `logilab.common.STD_BLACKLIST`
+    :param blacklist: iterable
+      list of files or directories to ignore.
 
     :rtype: list
     :return:
@@ -419,7 +473,8 @@ def get_source_file(filename, include_no_ext=False):
     :rtype: str
     :return: the absolute path of the source file if it exists
     """
-    base, orig_ext = os.path.splitext(os.path.abspath(filename))
+    filename = os.path.abspath(_path_from_filename(filename))
+    base, orig_ext = os.path.splitext(filename)
     for ext in PY_SOURCE_EXTS:
         source_path = '%s.%s' % (base, ext)
         if os.path.exists(source_path):
@@ -464,7 +519,8 @@ def is_standard_module(modname, std_path=None):
     # modules which are not living in a file are considered standard
     # (sys and __builtin__ for instance)
     if filename is None:
-        return True
+        # we assume there are no namespaces in stdlib
+        return not _is_namespace(modname)
     filename = _normalize_path(filename)
     if filename.startswith(_cache_normalize_path(EXT_LIB_DIR)):
         return False
@@ -538,15 +594,27 @@ def _file_from_modpath(modpath, path=None, context=None):
     return mp_filename, mtype
 
 def _search_zip(modpath, pic):
-    for filepath, importer in pic.items():
+    for filepath, importer in list(pic.items()):
         if importer is not None:
             if importer.find_module(modpath[0]):
                 if not importer.find_module(os.path.sep.join(modpath)):
                     raise ImportError('No module named %s in %s/%s' % (
                         '.'.join(modpath[1:]), filepath, modpath))
-                return PY_ZIPMODULE, os.path.abspath(filepath) + os.path.sep + os.path.sep.join(modpath), filepath
+                return (PY_ZIPMODULE,
+                        os.path.abspath(filepath) + os.path.sep + os.path.sep.join(modpath),
+                        filepath)
     raise ImportError('No module named %s' % '.'.join(modpath))
 
+try:
+    import pkg_resources
+except ImportError:
+    pkg_resources = None
+
+
+def _is_namespace(modname):
+    return (pkg_resources is not None
+            and modname in pkg_resources._namespace_packages)
+
 
 def _module_file(modpath, path=None):
     """get a module type / file path
@@ -579,14 +647,13 @@ def _module_file(modpath, path=None):
     except AttributeError:
         checkeggs = False
     # pkg_resources support (aka setuptools namespace packages)
-    if (pkg_resources is not None
-            and modpath[0] in pkg_resources._namespace_packages
-            and modpath[0] in sys.modules
-            and len(modpath) > 1):
+    if _is_namespace(modpath[0]) and modpath[0] in sys.modules:
         # setuptools has added into sys.modules a module object with proper
         # __path__, get back information from there
         module = sys.modules[modpath.pop(0)]
-        path = module.__path__
+        path = list(module.__path__)
+        if not modpath:
+            return imp.C_BUILTIN, None
     imported = []
     while modpath:
         modname = modpath[0]
@@ -609,7 +676,7 @@ def _module_file(modpath, path=None):
             # Don't forget to close the stream to avoid
             # spurious ResourceWarnings.
             if stream:
-               stream.close()
+                stream.close()
 
             if checkeggs and mp_filename:
                 fullabspath = [_cache_normalize_path(x) for x in _path]
@@ -639,7 +706,11 @@ def _module_file(modpath, path=None):
             except IOError:
                 path = [mp_filename]
             else:
-                if b'pkgutil' in data and b'extend_path' in data:
+                extend_path = b'pkgutil' in data and b'extend_path' in data
+                declare_namespace = (
+                    b"pkg_resources" in data
+                    and b"declare_namespace(__name__)" in data)
+                if extend_path or declare_namespace:
                     # extend_path is called, search sys.path for module/packages
                     # of this name see pkgutil.extend_path documentation
                     path = [os.path.join(p, *imported) for p in sys.path