libv8 6.3.292.48.1 → 6.7.288.46.0

data/vendor/depot_tools/third_party/pylint/checkers/python3.py

@@ -12,12 +12,13 @@
 # this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """Check Python 2 code for Python 2/3 source-compatible issues."""
-from __future__ import absolute_import
+from __future__ import absolute_import, print_function
 
 import re
 import tokenize
 
 import astroid
+from astroid import bases
 from pylint import checkers, interfaces
 from pylint.utils import WarningScope
 from pylint.checkers import utils
@@ -46,6 +47,46 @@ def _check_dict_node(node):
     return (not inferred_types
             or any(isinstance(x, astroid.Dict) for x in inferred_types))
 
+def _is_builtin(node):
+    return getattr(node, 'name', None) in ('__builtin__', 'builtins')
+
+_accepts_iterator = {'iter', 'list', 'tuple', 'sorted', 'set', 'sum', 'any',
+                     'all', 'enumerate', 'dict'}
+
+def _in_iterating_context(node):
+    """Check if the node is being used as an iterator.
+
+    Definition is taken from lib2to3.fixer_util.in_special_context().
+    """
+    parent = node.parent
+    # Since a call can't be the loop variant we only need to know if the node's
+    # parent is a 'for' loop to know it's being used as the iterator for the
+    # loop.
+    if isinstance(parent, astroid.For):
+        return True
+    # Need to make sure the use of the node is in the iterator part of the
+    # comprehension.
+    elif isinstance(parent, astroid.Comprehension):
+        if parent.iter == node:
+            return True
+    # Various built-ins can take in an iterable or list and lead to the same
+    # value.
+    elif isinstance(parent, astroid.CallFunc):
+        if isinstance(parent.func, astroid.Name):
+            parent_scope = parent.func.lookup(parent.func.name)[0]
+            if _is_builtin(parent_scope) and parent.func.name in _accepts_iterator:
+                return True
+        elif isinstance(parent.func, astroid.Getattr):
+            if parent.func.attrname == 'join':
+                return True
+    # If the call is in an unpacking, there's no need to warn,
+    # since it can be considered iterating.
+    elif (isinstance(parent, astroid.Assign) and
+          isinstance(parent.targets[0], (astroid.List, astroid.Tuple))):
+        if len(parent.targets[0].elts) > 1:
+            return True
+    return False
+
 
 class Python3Checker(checkers.BaseChecker):
 
@@ -177,13 +218,13 @@ class Python3Checker(checkers.BaseChecker):
         'W1618': ('import missing `from __future__ import absolute_import`',
                   'no-absolute-import',
                   'Used when an import is not accompanied by '
-                  '`from __future__ import absolute_import`'
-                  ' (default behaviour in Python 3)',
+                  '``from __future__ import absolute_import`` '
+                  '(default behaviour in Python 3)',
                   {'maxversion': (3, 0)}),
         'W1619': ('division w/o __future__ statement',
                   'old-division',
                   'Used for non-floor division w/o a float literal or '
-                  '``from __future__ import division``'
+                  '``from __future__ import division`` '
                   '(Python 3 returns a float for int division unconditionally)',
                   {'maxversion': (3, 0)}),
         'W1620': ('Calling a dict.iter*() method',
@@ -244,14 +285,7 @@ class Python3Checker(checkers.BaseChecker):
                   'Used when a __cmp__ method is defined '
                   '(method is not used by Python 3)',
                   {'maxversion': (3, 0)}),
-        'W1631': ('map is used as implicitly evaluated call',
-                  'implicit-map-evaluation',
-                  'Used when the map builtin is used as implicitly '
-                  'evaluated call, as in "map(func, args)" on a single line. '
-                  'This behaviour will not work in Python 3, where '
-                  'map is a generator and must be evaluated. '
-                  'Prefer a for-loop as alternative.',
-                  {'maxversion': (3, 0)}),
+        # 'W1631': replaced by W1636
         'W1632': ('input built-in referenced',
                   'input-builtin',
                   'Used when the input built-in is referenced '
@@ -262,6 +296,44 @@ class Python3Checker(checkers.BaseChecker):
                   'Used when the round built-in is referenced '
                   '(backwards-incompatible semantics in Python 3)',
                   {'maxversion': (3, 0)}),
+        'W1634': ('intern built-in referenced',
+                  'intern-builtin',
+                  'Used when the intern built-in is referenced '
+                  '(Moved to sys.intern in Python 3)',
+                  {'maxversion': (3, 0)}),
+        'W1635': ('unichr built-in referenced',
+                  'unichr-builtin',
+                  'Used when the unichr built-in is referenced '
+                  '(Use chr in Python 3)',
+                  {'maxversion': (3, 0)}),
+        'W1636': ('map built-in referenced when not iterating',
+                  'map-builtin-not-iterating',
+                  'Used when the map built-in is referenced in a non-iterating '
+                  'context (returns an iterator in Python 3)',
+                  {'maxversion': (3, 0),
+                   'old_names': [('W1631', 'implicit-map-evaluation')]}),
+        'W1637': ('zip built-in referenced when not iterating',
+                  'zip-builtin-not-iterating',
+                  'Used when the zip built-in is referenced in a non-iterating '
+                  'context (returns an iterator in Python 3)',
+                  {'maxversion': (3, 0)}),
+        'W1638': ('range built-in referenced when not iterating',
+                  'range-builtin-not-iterating',
+                  'Used when the range built-in is referenced in a non-iterating '
+                  'context (returns an iterator in Python 3)',
+                  {'maxversion': (3, 0)}),
+        'W1639': ('filter built-in referenced when not iterating',
+                  'filter-builtin-not-iterating',
+                  'Used when the filter built-in is referenced in a non-iterating '
+                  'context (returns an iterator in Python 3)',
+                  {'maxversion': (3, 0)}),
+        'W1640': ('Using the cmp argument for list.sort / sorted',
+                  'using-cmp-argument',
+                  'Using the cmp argument for list.sort or the sorted '
+                  'builtin should be avoided, since it was removed in '
+                  'Python 3. Using either `key` or `functools.cmp_to_key` '
+                  'should be preferred.',
+                  {'maxversion': (3, 0)}),
     }
 
     _bad_builtins = frozenset([
@@ -273,11 +345,13 @@ class Python3Checker(checkers.BaseChecker):
         'execfile',
         'file',
         'input',  # Not missing, but incompatible semantics
+        'intern',
         'long',
         'raw_input',
         'reduce',
         'round',  # Not missing, but incompatible semantics
         'StandardError',
+        'unichr',
         'unicode',
         'xrange',
         'reload',
@@ -299,6 +373,11 @@ class Python3Checker(checkers.BaseChecker):
         self._future_absolute_import = False
         super(Python3Checker, self).__init__(*args, **kwargs)
 
+    def visit_module(self, node): # pylint: disable=unused-argument
+        """Clear checker state after previous module."""
+        self._future_division = False
+        self._future_absolute_import = False
+
     def visit_function(self, node):
         if node.is_method() and node.name in self._unused_magic_methods:
             method_name = node.name
@@ -312,19 +391,10 @@ class Python3Checker(checkers.BaseChecker):
             if isinstance(arg, astroid.Tuple):
                 self.add_message('parameter-unpacking', node=arg)
 
-    @utils.check_messages('implicit-map-evaluation')
-    def visit_discard(self, node):
-        if (isinstance(node.value, astroid.CallFunc) and
-                isinstance(node.value.func, astroid.Name) and
-                node.value.func.name == 'map'):
-            module = node.value.func.lookup('map')[0]
-            if getattr(module, 'name', None) == '__builtin__':
-                self.add_message('implicit-map-evaluation', node=node)
-
     def visit_name(self, node):
         """Detect when a "bad" built-in is referenced."""
         found_node = node.lookup(node.name)[0]
-        if getattr(found_node, 'name', None) == '__builtin__':
+        if _is_builtin(found_node):
             if node.name in self._bad_builtins:
                 message = node.name.lower() + '-builtin'
                 self.add_message(message, node=node)
@@ -363,22 +433,57 @@ class Python3Checker(checkers.BaseChecker):
             else:
                 self.add_message('old-division', node=node)
 
-    @utils.check_messages('next-method-called',
-                          'dict-iter-method',
-                          'dict-view-method')
+    def _check_cmp_argument(self, node):
+        # Check that the `cmp` argument is used
+        args = []
+        if (isinstance(node.func, astroid.Getattr)
+                and node.func.attrname == 'sort'):
+            inferred = utils.safe_infer(node.func.expr)
+            if not inferred:
+                return
+
+            builtins_list = "{}.list".format(bases.BUILTINS)
+            if (isinstance(inferred, astroid.List)
+                    or inferred.qname() == builtins_list):
+                args = node.args
+
+        elif (isinstance(node.func, astroid.Name)
+                and node.func.name == 'sorted'):
+            inferred = utils.safe_infer(node.func)
+            if not inferred:
+                return
+
+            builtins_sorted = "{}.sorted".format(bases.BUILTINS)
+            if inferred.qname() == builtins_sorted:
+                args = node.args
+
+        for arg in args:
+            if isinstance(arg, astroid.Keyword) and arg.arg == 'cmp':
+                self.add_message('using-cmp-argument', node=node)
+                return
+
     def visit_callfunc(self, node):
-        if not isinstance(node.func, astroid.Getattr):
-            return
-        if any([node.args, node.starargs, node.kwargs]):
-            return
-        if node.func.attrname == 'next':
-            self.add_message('next-method-called', node=node)
-        else:
-            if _check_dict_node(node.func.expr):
-                if node.func.attrname in ('iterkeys', 'itervalues', 'iteritems'):
-                    self.add_message('dict-iter-method', node=node)
-                elif node.func.attrname in ('viewkeys', 'viewvalues', 'viewitems'):
-                    self.add_message('dict-view-method', node=node)
+        self._check_cmp_argument(node)
+
+        if isinstance(node.func, astroid.Getattr):
+            if any([node.args, node.starargs, node.kwargs]):
+                return
+            if node.func.attrname == 'next':
+                self.add_message('next-method-called', node=node)
+            else:
+                if _check_dict_node(node.func.expr):
+                    if node.func.attrname in ('iterkeys', 'itervalues', 'iteritems'):
+                        self.add_message('dict-iter-method', node=node)
+                    elif node.func.attrname in ('viewkeys', 'viewvalues', 'viewitems'):
+                        self.add_message('dict-view-method', node=node)
+        elif isinstance(node.func, astroid.Name):
+            found_node = node.func.lookup(node.func.name)[0]
+            if _is_builtin(found_node):
+                if node.func.name in ('filter', 'map', 'range', 'zip'):
+                    if not _in_iterating_context(node):
+                        checker = '{}-builtin-not-iterating'.format(node.func.name)
+                        self.add_message(checker, node=node)
+
 
     @utils.check_messages('indexing-exception')
     def visit_subscript(self, node):

data/vendor/depot_tools/third_party/pylint/checkers/spelling.py

@@ -61,6 +61,9 @@ class SpellingChecker(BaseTokenChecker):
                   '%s\nDid you mean: \'%s\'?',
                   'wrong-spelling-in-docstring',
                   'Used when a word in docstring is not spelled correctly.'),
+        'C0403': ('Invalid characters %r in a docstring',
+                  'invalid-characters-in-docstring',
+                  'Used when a word in docstring cannot be checked by enchant.'),
         }
     options = (('spelling-dict',
                 {'default' : '', 'type' : 'choice', 'metavar' : '<dict name>',
@@ -168,7 +171,13 @@ class SpellingChecker(BaseTokenChecker):
                 word = word[2:]
 
             # If it is a known word, then continue.
-            if self.spelling_dict.check(word):
+            try:
+                if self.spelling_dict.check(word):
+                    continue
+            except enchant.errors.Error:
+                # this can only happen in docstrings, not comments
+                self.add_message('invalid-characters-in-docstring',
+                                 line=line_num, args=(word,))
                 continue
 
             # Store word to private dict or raise a message.

data/vendor/depot_tools/third_party/pylint/checkers/stdlib.py

@@ -15,7 +15,6 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """Checkers for various standard library functions."""
 
-import re
 import six
 import sys
 
@@ -27,10 +26,15 @@ from pylint.checkers import BaseChecker
 from pylint.checkers import utils
 
 
+TYPECHECK_COMPARISON_OPERATORS = frozenset(('is', 'is not', '==', '!=', 'in', 'not in'))
+LITERAL_NODE_TYPES = (astroid.Const, astroid.Dict, astroid.List, astroid.Set)
+
 if sys.version_info >= (3, 0):
     OPEN_MODULE = '_io'
+    TYPE_QNAME = 'builtins.type'
 else:
     OPEN_MODULE = '__builtin__'
+    TYPE_QNAME = '__builtin__.type'
 
 
 def _check_mode_str(mode):
@@ -50,7 +54,6 @@ def _check_mode_str(mode):
     reading = "r" in modes
     writing = "w" in modes
     appending = "a" in modes
-    updating = "+" in modes
     text = "t" in modes
     binary = "b" in modes
     if "U" in modes:
@@ -76,6 +79,15 @@ def _check_mode_str(mode):
     return True
 
 
+def _is_one_arg_pos_call(call):
+    """Is this a call with exactly 1 argument,
+    where that argument is positional?
+    """
+    return (isinstance(call, astroid.CallFunc)
+            and len(call.args) == 1
+            and not isinstance(call.args[0], astroid.Keyword))
+
+
 class StdlibChecker(BaseChecker):
     __implements__ = (IAstroidChecker,)
     name = 'stdlib'
@@ -88,7 +100,7 @@ class StdlibChecker(BaseChecker):
                   'See http://docs.python.org/2/library/functions.html#open'),
         'W1502': ('Using datetime.time in a boolean context.',
                   'boolean-datetime',
-                  'Using datetetime.time in a boolean context can hide '
+                  'Using datetime.time in a boolean context can hide '
                   'subtle bugs when the time they represent matches '
                   'midnight UTC. This behaviour was fixed in Python 3.5. '
                   'See http://bugs.python.org/issue13936 for reference.',
@@ -96,10 +108,16 @@ class StdlibChecker(BaseChecker):
         'W1503': ('Redundant use of %s with constant '
                   'value %r',
                   'redundant-unittest-assert',
-                  'The first argument of assertTrue and assertFalse is'
-                  'a condition. If a constant is passed as parameter, that'
+                  'The first argument of assertTrue and assertFalse is '
+                  'a condition. If a constant is passed as parameter, that '
                   'condition will be always true. In this case a warning '
-                  'should be emitted.')
+                  'should be emitted.'),
+        'W1504': ('Using type() instead of isinstance() for a typecheck.',
+                  'unidiomatic-typecheck',
+                  'The idiomatic way to perform an explicit typecheck in '
+                  'Python is to use isinstance(x, Y) rather than '
+                  'type(x) == Y, type(x) is Y. Though there are unusual '
+                  'situations where these give different results.')
     }
 
     @utils.check_messages('bad-open-mode', 'redundant-unittest-assert')
@@ -132,6 +150,14 @@ class StdlibChecker(BaseChecker):
         for value in node.values:
             self._check_datetime(value)
 
+    @utils.check_messages('unidiomatic-typecheck')
+    def visit_compare(self, node):
+        operator, right = node.ops[0]
+        if operator in TYPECHECK_COMPARISON_OPERATORS:
+            left = node.left
+            if _is_one_arg_pos_call(left):
+                self._check_type_x_is_y(node, left, operator, right)
+
     def _check_redundant_assert(self, node, infer):
         if (isinstance(infer, astroid.BoundMethod) and
                 node.args and isinstance(node.args[0], astroid.Const) and
@@ -152,7 +178,6 @@ class StdlibChecker(BaseChecker):
                 infered.qname() == 'datetime.time'):
             self.add_message('boolean-datetime', node=node)
 
-
     def _check_open_mode(self, node):
         """Check that the mode argument of an open or file call is valid."""
         try:
@@ -167,6 +192,24 @@ class StdlibChecker(BaseChecker):
                 self.add_message('bad-open-mode', node=node,
                                  args=mode_arg.value)
 
+    def _check_type_x_is_y(self, node, left, operator, right):
+        """Check for expressions like type(x) == Y."""
+        left_func = utils.safe_infer(left.func)
+        if not (isinstance(left_func, astroid.Class)
+                and left_func.qname() == TYPE_QNAME):
+            return
+
+        if operator in ('is', 'is not') and _is_one_arg_pos_call(right):
+            right_func = utils.safe_infer(right.func)
+            if (isinstance(right_func, astroid.Class)
+                    and right_func.qname() == TYPE_QNAME):
+                # type(x) == type(a)
+                right_arg = utils.safe_infer(right.args[0])
+                if not isinstance(right_arg, LITERAL_NODE_TYPES):
+                    # not e.g. type(x) == type([])
+                    return
+        self.add_message('unidiomatic-typecheck', node=node)
+
 
 def register(linter):
     """required method to auto register this checker """

data/vendor/depot_tools/third_party/pylint/checkers/strings.py

@@ -181,7 +181,7 @@ def parse_format_method_string(format_string):
             if isinstance(keyname, numbers.Number):
                 # In Python 2 it will return long which will lead
                 # to different output between 2 and 3
-                manual_pos_arg.add(keyname)
+                manual_pos_arg.add(str(keyname))
                 keyname = int(keyname)
             keys.append((keyname, list(fielditerator)))
         else:

data/vendor/depot_tools/third_party/pylint/epylint.py

@@ -1,4 +1,5 @@
-# -*- coding: utf-8; mode: python; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- vim:fenc=utf-8:ft=python:et:sw=4:ts=4:sts=4
+# -*- coding: utf-8; mode: python; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4
+# -*- vim:fenc=utf-8:ft=python:et:sw=4:ts=4:sts=4
 # Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
 # http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #

data/vendor/depot_tools/third_party/pylint/gui.py

@@ -38,7 +38,7 @@ from pylint.reporters.guireporter import GUIReporter
 
 HOME = os.path.expanduser('~/')
 HISTORY = '.pylint-gui-history'
-COLORS = {'(I)':'lightblue',
+COLORS = {'(I)':'green',
           '(C)':'blue', '(R)':'darkblue',
           '(W)':'black', '(E)':'darkred',
           '(F)':'red'}

data/vendor/depot_tools/third_party/pylint/lint.py

@@ -48,7 +48,7 @@ from logilab.common import optik_ext
 from logilab.common import interface
 from logilab.common import textutils
 from logilab.common import ureports
-from logilab.common.__pkginfo__ import version as common_version
+from logilab.common import __version__ as common_version
 import six
 
 from pylint import checkers
@@ -60,6 +60,10 @@ from pylint.__pkginfo__ import version
 
 
 MANAGER = astroid.MANAGER
+INCLUDE_IDS_HELP = ("Deprecated. It was used to include message\'s "
+                    "id in output. Use --msg-template instead.")
+SYMBOLS_HELP = ("Deprecated. It was used to include symbolic ids of "
+                "messages in output. Use --msg-template instead.")
 
 def _get_new_args(message):
     location = (
@@ -105,6 +109,24 @@ def _merge_stats(stats):
     return merged
 
 
+@contextlib.contextmanager
+def _patch_sysmodules():
+    # Context manager that permits running pylint, on Windows, with -m switch
+    # and with --jobs, as in 'python -2 -m pylint .. --jobs'.
+    # For more details why this is needed,
+    # see Python issue http://bugs.python.org/issue10845.
+
+    mock_main = __name__ != '__main__' # -m switch
+    if mock_main:
+        sys.modules['__main__'] = sys.modules[__name__]
+
+    try:
+        yield
+    finally:
+        if mock_main:
+            sys.modules.pop('__main__')
+
+
 # Python Linter class #########################################################
 
 MSGS = {
@@ -177,10 +199,10 @@ MSGS = {
     }
 
 
-def _deprecated_option(shortname, opt_type):
+def _deprecated_option(shortname, opt_type, help_msg):
     def _warn_deprecated(option, optname, *args): # pylint: disable=unused-argument
         sys.stderr.write('Warning: option %s is deprecated and ignored.\n' % (optname,))
-    return {'short': shortname, 'help': 'DEPRECATED', 'hide': True,
+    return {'short': shortname, 'help': help_msg, 'hide': True,
             'type': opt_type, 'action': 'callback', 'callback': _warn_deprecated}
 
 
@@ -190,6 +212,8 @@ if multiprocessing is not None:
             tasks_queue, results_queue, self._config = self._args # pylint: disable=no-member
 
             self._config["jobs"] = 1  # Child does not parallelize any further.
+            self._python3_porting_mode = self._config.pop(
+                'python3_porting_mode', None)
 
             # Run linter for received files/modules.
             for file_or_module in iter(tasks_queue.get, 'STOP'):
@@ -197,7 +221,8 @@ if multiprocessing is not None:
                 try:
                     results_queue.put(result)
                 except Exception as ex:
-                    print("internal error with sending report for module %s" % file_or_module, file=sys.stderr)
+                    print("internal error with sending report for module %s" %
+                          file_or_module, file=sys.stderr)
                     print(ex, file=sys.stderr)
                     results_queue.put({})
 
@@ -212,6 +237,13 @@ if multiprocessing is not None:
             linter.load_configuration(**self._config)
             linter.set_reporter(reporters.CollectingReporter())
 
+            # Enable the Python 3 checker mode. This option is
+            # passed down from the parent linter up to here, since
+            # the Python 3 porting flag belongs to the Run class,
+            # instead of the Linter class.
+            if self._python3_porting_mode:
+                linter.python3_porting_mode()
+
             # Run the checks.
             linter.check(file_or_module)
 
@@ -350,8 +382,9 @@ class PyLinter(configuration.OptionsManagerMixIn,
                             'See doc for all details')
                  }),
 
-                ('include-ids', _deprecated_option('i', 'yn')),
-                ('symbols', _deprecated_option('s', 'yn')),
+                ('include-ids', _deprecated_option('i', 'yn',
+                                                   INCLUDE_IDS_HELP)),
+                ('symbols', _deprecated_option('s', 'yn', SYMBOLS_HELP)),
 
                 ('jobs',
                  {'type' : 'int', 'metavar': '<n-processes>',
@@ -373,6 +406,19 @@ class PyLinter(configuration.OptionsManagerMixIn,
                             ' loading into the active Python interpreter and may run'
                             ' arbitrary code')}
                   ),
+
+                ('optimize-ast',
+                  {'type': 'yn', 'metavar': '<yn>', 'default': False,
+                   'help': ('Allow optimization of some AST trees. This will '
+                            'activate a peephole AST optimizer, which will '
+                            'apply various small optimizations. For instance, '
+                            'it can be used to obtain the result of joining '
+                            'multiple strings with the addition operator. '
+                            'Joining a lot of strings can lead to a maximum '
+                            'recursion error in Pylint and this flag can prevent '
+                            'that. It has one side effect, the resulting AST '
+                            'will be different than the one from reality.')}
+                ),
                )
 
     option_groups = (
@@ -427,6 +473,8 @@ class PyLinter(configuration.OptionsManagerMixIn,
                        )
         self.register_checker(self)
         self._dynamic_plugins = set()
+        self._python3_porting_mode = False
+        self._error_mode = False
         self.load_provider_defaults()
         if reporter:
             self.set_reporter(reporter)
@@ -555,11 +603,34 @@ class PyLinter(configuration.OptionsManagerMixIn,
 
     def error_mode(self):
         """error mode: enable only errors; no reports, no persistent"""
+        self._error_mode = True
         self.disable_noerror_messages()
         self.disable('miscellaneous')
+        if self._python3_porting_mode:
+            self.disable('all')
+            for msg_id in self._checker_messages('python3'):
+                if msg_id.startswith('E'):
+                    self.enable(msg_id)
+        else:
+            self.disable('python3')
         self.set_option('reports', False)
         self.set_option('persistent', False)
 
+    def python3_porting_mode(self):
+        """Disable all other checkers and enable Python 3 warnings."""
+        self.disable('all')
+        self.enable('python3')
+        if self._error_mode:
+            # The error mode was activated, using the -E flag.
+            # So we'll need to enable only the errors from the
+            # Python 3 porting checker.
+            for msg_id in self._checker_messages('python3'):
+                if msg_id.startswith('E'):
+                    self.enable(msg_id)
+                else:
+                    self.disable(msg_id)
+        self._python3_porting_mode = True
+
     # block level option handling #############################################
     #
     # see func_block_disable_msg.py test case for expected behaviour
@@ -596,7 +667,8 @@ class PyLinter(configuration.OptionsManagerMixIn,
                 except KeyError:
                     meth = self._bw_options_methods[opt]
                     # found a "(dis|en)able-msg" pragma deprecated suppresssion
-                    self.add_message('deprecated-pragma', line=start[0], args=(opt, opt.replace('-msg', '')))
+                    self.add_message('deprecated-pragma', line=start[0],
+                                     args=(opt, opt.replace('-msg', '')))
                 for msgid in textutils.splitstrip(value):
                     # Add the line where a control pragma was encountered.
                     if opt in control_pragmas:
@@ -604,7 +676,8 @@ class PyLinter(configuration.OptionsManagerMixIn,
 
                     try:
                         if (opt, msgid) == ('disable', 'all'):
-                            self.add_message('deprecated-pragma', line=start[0], args=('disable=all', 'skip-file'))
+                            self.add_message('deprecated-pragma', line=start[0],
+                                             args=('disable=all', 'skip-file'))
                             self.add_message('file-ignored', line=start[0])
                             self._ignore_file = True
                             return
@@ -674,19 +747,9 @@ class PyLinter(configuration.OptionsManagerMixIn,
             with fix_import_path(files_or_modules):
                 self._do_check(files_or_modules)
         else:
-            # Hack that permits running pylint, on Windows, with -m switch
-            # and with --jobs, as in 'python -2 -m pylint .. --jobs'.
-            # For more details why this is needed,
-            # see Python issue http://bugs.python.org/issue10845.
-
-            mock_main = __name__ != '__main__' # -m switch
-            if mock_main:
-                sys.modules['__main__'] = sys.modules[__name__]
-            try:
+            with _patch_sysmodules():
                 self._parallel_check(files_or_modules)
-            finally:
-                if mock_main:
-                    sys.modules.pop('__main__')
+
 
     def _parallel_task(self, files_or_modules):
         # Prepare configuration for child linters.
@@ -697,6 +760,7 @@ class PyLinter(configuration.OptionsManagerMixIn,
             for optname, optdict, val in opt_providers.options_and_values():
                 if optname not in filter_options:
                     config[optname] = configuration.format_option_value(optdict, val)
+        config['python3_porting_mode'] = self._python3_porting_mode
 
         childs = []
         manager = multiprocessing.Manager()  # pylint: disable=no-member
@@ -805,7 +869,8 @@ class PyLinter(configuration.OptionsManagerMixIn,
             self.current_file = ast_node.file # pylint: disable=maybe-no-member
             self.check_astroid_module(ast_node, walker, rawcheckers, tokencheckers)
             # warn about spurious inline messages handling
-            for msgid, line, args in self.file_state.iter_spurious_suppression_messages(self.msgs_store):
+            spurious_messages = self.file_state.iter_spurious_suppression_messages(self.msgs_store)
+            for msgid, line, args in spurious_messages:
                 self.add_message(msgid, line, None, args)
         # notify global end
         self.stats['statement'] = walker.nbstatements
@@ -889,6 +954,7 @@ class PyLinter(configuration.OptionsManagerMixIn,
         self.stats = {'by_module' : {},
                       'by_msg' : {},
                      }
+        MANAGER.optimize_ast = self.config.optimize_ast
         MANAGER.always_load_extensions = self.config.unsafe_load_any_extension
         MANAGER.extension_package_whitelist.update(
             self.config.extension_pkg_whitelist)
@@ -1315,8 +1381,7 @@ group are mutually exclusive.'),
 
     def cb_python3_porting_mode(self, *args, **kwargs):
         """Activate only the python3 porting checker."""
-        self.linter.disable('all')
-        self.linter.enable('python3')
+        self.linter.python3_porting_mode()
 
 
 def cb_list_confidence_levels(option, optname, value, parser):