Merge remote-tracking branch 'origin/master' into opplug

Author: hauntsaninja

docs/source/command_line.rst

@@ -553,6 +553,36 @@ of the above sections.
     Note: the exact list of flags enabled by running :option:`--strict` may change
     over time.
 
+.. option:: --disable-error-code
+
+    This flag allows disabling one or multiple error codes globally.
+
+    .. code-block:: python
+
+        # no flag
+        x = 'a string'
+        x.trim()  # error: "str" has no attribute "trim"  [attr-defined]
+
+        # --disable-error-code attr-defined
+        x = 'a string'
+        x.trim()
+
+.. option:: --enable-error-code
+
+    This flag allows enabling one or multiple error codes globally.
+
+    Note: This flag will override disabled error codes from the --disable-error-code
+    flag
+
+    .. code-block:: python
+
+        # --disable-error-code attr-defined
+        x = 'a string'
+        x.trim()
+
+        # --disable-error-code attr-defined --enable-error-code attr-defined
+        x = 'a string'
+        x.trim()  # error: "str" has no attribute "trim"  [attr-defined]
 
 .. _configuring-error-messages:
 

mypy/build.py

@@ -223,7 +223,9 @@ def _build(sources: List[BuildSource],
                     options.show_error_codes,
                     options.pretty,
                     lambda path: read_py_file(path, cached_read, options.python_version),
-                    options.show_absolute_path)
+                    options.show_absolute_path,
+                    options.enabled_error_codes,
+                    options.disabled_error_codes)
     plugin, snapshot = load_plugins(options, errors, stdout, extra_plugins)
 
     # Add catch-all .gitignore to cache dir if we created it
@@ -762,13 +764,14 @@ def is_module(self, id: str) -> bool:
         """Is there a file in the file system corresponding to module id?"""
         return find_module_simple(id, self) is not None
 
-    def parse_file(self, id: str, path: str, source: str, ignore_errors: bool) -> MypyFile:
+    def parse_file(self, id: str, path: str, source: str, ignore_errors: bool,
+                   options: Options) -> MypyFile:
         """Parse the source of a file with the given name.
 
         Raise CompileError if there is a parse error.
         """
         t0 = time.time()
-        tree = parse(source, path, id, self.errors, options=self.options)
+        tree = parse(source, path, id, self.errors, options=options)
         tree._fullname = id
         self.add_stats(files_parsed=1,
                        modules_parsed=int(not tree.is_stub),
@@ -2001,7 +2004,8 @@ def parse_file(self) -> None:
 
             self.parse_inline_configuration(source)
             self.tree = manager.parse_file(self.id, self.xpath, source,
-                                           self.ignore_all or self.options.ignore_errors)
+                                           self.ignore_all or self.options.ignore_errors,
+                                           self.options)
 
         modules[self.id] = self.tree
 

mypy/checker.py

@@ -3317,6 +3317,9 @@ def visit_raise_stmt(self, s: RaiseStmt) -> None:
     def type_check_raise(self, e: Expression, s: RaiseStmt,
                          optional: bool = False) -> None:
         typ = get_proper_type(self.expr_checker.accept(e))
+        if isinstance(typ, DeletedType):
+            self.msg.deleted_as_rvalue(typ, e)
+            return
         exc_type = self.named_type('builtins.BaseException')
         expected_type = UnionType([exc_type, TypeType(exc_type)])
         if optional:

mypy/checkexpr.py

@@ -3464,6 +3464,10 @@ def visit_super_expr(self, e: SuperExpr) -> Type:
             self.chk.fail(message_registry.SUPER_ARG_2_NOT_INSTANCE_OF_ARG_1, e)
             return AnyType(TypeOfAny.from_error)
 
+        if len(mro) == index + 1:
+            self.chk.fail(message_registry.TARGET_CLASS_HAS_NO_BASE_CLASS, e)
+            return AnyType(TypeOfAny.from_error)
+
         for base in mro[index+1:]:
             if e.name in base.names or base == mro[-1]:
                 if e.info and e.info.fallback_to_any and base == mro[-1]:

mypy/checkstrformat.py

@@ -384,9 +384,10 @@ def perform_special_format_checks(self, spec: ConversionSpecifier, call: CallExp
             if self.chk.options.python_version >= (3, 0):
                 if (has_type_component(actual_type, 'builtins.bytes') and
                         not custom_special_method(actual_type, '__str__')):
-                    self.msg.fail("On Python 3 '{}'.format(b'abc') produces \"b'abc'\";"
-                                  " use !r if this is a desired behavior", call,
-                                  code=codes.STR_BYTES_PY3)
+                    self.msg.fail(
+                        "On Python 3 '{}'.format(b'abc') produces \"b'abc'\", not 'abc'; "
+                        "use '{!r}'.format(b'abc') if this is desired behavior",
+                        call, code=codes.STR_BYTES_PY3)
         if spec.flags:
             numeric_types = UnionType([self.named_type('builtins.int'),
                                        self.named_type('builtins.float')])
@@ -843,9 +844,10 @@ def check_s_special_cases(self, expr: FormatStringExpr, typ: Type, context: Cont
             # Couple special cases for string formatting.
             if self.chk.options.python_version >= (3, 0):
                 if has_type_component(typ, 'builtins.bytes'):
-                    self.msg.fail("On Python 3 '%s' % b'abc' produces \"b'abc'\";"
-                                  " use %r if this is a desired behavior", context,
-                                  code=codes.STR_BYTES_PY3)
+                    self.msg.fail(
+                        "On Python 3 '%s' % b'abc' produces \"b'abc'\", not 'abc'; "
+                        "use '%r' % b'abc' if this is desired behavior",
+                        context, code=codes.STR_BYTES_PY3)
             if self.chk.options.python_version < (3, 0):
                 if has_type_component(typ, 'builtins.unicode'):
                     self.unicode_upcast = True

mypy/dmypy_server.py

@@ -557,6 +557,10 @@ def fine_grained_increment_follow_imports(self, sources: List[BuildSource]) -> L
             if module[0] not in graph:
                 continue
             sources2 = self.direct_imports(module, graph)
+            # Filter anything already seen before. This prevents
+            # infinite looping if there are any self edges. (Self
+            # edges are maybe a bug, but...)
+            sources2 = [source for source in sources2 if source.module not in seen]
             changed, new_files = self.find_reachable_changed_modules(
                 sources2, graph, seen, changed_paths
             )

mypy/errorcodes.py

@@ -3,19 +3,26 @@
 These can be used for filtering specific errors.
 """
 
-from typing import List
+from typing import Dict, List
 from typing_extensions import Final
 
 
 # All created error codes are implicitly stored in this list.
 all_error_codes = []  # type: List[ErrorCode]
 
+error_codes = {}  # type: Dict[str, ErrorCode]
+
 
 class ErrorCode:
-    def __init__(self, code: str, description: str, category: str) -> None:
+    def __init__(self, code: str,
+                 description: str,
+                 category: str,
+                 default_enabled: bool = True) -> None:
         self.code = code
         self.description = description
         self.category = category
+        self.default_enabled = default_enabled
+        error_codes[code] = self
 
     def __str__(self) -> str:
         return '<ErrorCode {}>'.format(self.code)

mypy/errors.py

@@ -164,14 +164,18 @@ def __init__(self,
                  show_error_codes: bool = False,
                  pretty: bool = False,
                  read_source: Optional[Callable[[str], Optional[List[str]]]] = None,
-                 show_absolute_path: bool = False) -> None:
+                 show_absolute_path: bool = False,
+                 enabled_error_codes: Optional[Set[ErrorCode]] = None,
+                 disabled_error_codes: Optional[Set[ErrorCode]] = None) -> None:
         self.show_error_context = show_error_context
         self.show_column_numbers = show_column_numbers
         self.show_error_codes = show_error_codes
         self.show_absolute_path = show_absolute_path
         self.pretty = pretty
         # We use fscache to read source code when showing snippets.
         self.read_source = read_source
+        self.enabled_error_codes = enabled_error_codes or set()
+        self.disabled_error_codes = disabled_error_codes or set()
         self.initialize()
 
     def initialize(self) -> None:
@@ -195,7 +199,9 @@ def copy(self) -> 'Errors':
                      self.show_error_codes,
                      self.pretty,
                      self.read_source,
-                     self.show_absolute_path)
+                     self.show_absolute_path,
+                     self.enabled_error_codes,
+                     self.disabled_error_codes)
         new.file = self.file
         new.import_ctx = self.import_ctx[:]
         new.function_or_member = self.function_or_member[:]
@@ -351,15 +357,25 @@ def add_error_info(self, info: ErrorInfo) -> None:
         self._add_error_info(file, info)
 
     def is_ignored_error(self, line: int, info: ErrorInfo, ignores: Dict[int, List[str]]) -> bool:
-        if line not in ignores:
+        if info.code and self.is_error_code_enabled(info.code) is False:
+            return True
+        elif line not in ignores:
             return False
         elif not ignores[line]:
             # Empty list means that we ignore all errors
             return True
-        elif info.code:
+        elif info.code and self.is_error_code_enabled(info.code) is True:
             return info.code.code in ignores[line]
         return False
 
+    def is_error_code_enabled(self, error_code: ErrorCode) -> bool:
+        if error_code in self.disabled_error_codes:
+            return False
+        elif error_code in self.enabled_error_codes:
+            return True
+        else:
+            return error_code.default_enabled
+
     def clear_errors_in_targets(self, path: str, targets: Set[str]) -> None:
         """Remove errors in specific fine-grained targets within a file."""
         if path in self.error_info_map:

mypy/join.py

@@ -119,7 +119,7 @@ def visit_unbound_type(self, t: UnboundType) -> ProperType:
         return AnyType(TypeOfAny.special_form)
 
     def visit_union_type(self, t: UnionType) -> ProperType:
-        if is_subtype(self.s, t):
+        if is_proper_subtype(self.s, t):
             return t
         else:
             return mypy.typeops.make_simplified_union([self.s, t])

mypy/main.py

@@ -18,6 +18,7 @@
 from mypy.find_sources import create_source_list, InvalidSourceList
 from mypy.fscache import FileSystemCache
 from mypy.errors import CompileError
+from mypy.errorcodes import error_codes
 from mypy.options import Options, BuildType
 from mypy.config_parser import parse_version, parse_config_file
 from mypy.split_namespace import SplitNamespace
@@ -612,6 +613,14 @@ def add_invertible_flag(flag: str,
         '--strict', action='store_true', dest='special-opts:strict',
         help=strict_help)
 
+    strictness_group.add_argument(
+        '--disable-error-code', metavar='NAME', action='append', default=[],
+        help="Disable a specific error code")
+    strictness_group.add_argument(
+        '--enable-error-code', metavar='NAME', action='append', default=[],
+        help="Enable a specific error code"
+    )
+
     error_group = parser.add_argument_group(
         title='Configuring error messages',
         description="Adjust the amount of detail shown in error messages.")
@@ -860,6 +869,23 @@ def set_strict_flags() -> None:
         parser.error("You can't make a variable always true and always false (%s)" %
                      ', '.join(sorted(overlap)))
 
+    # Process `--enable-error-code` and `--disable-error-code` flags
+    disabled_codes = set(options.disable_error_code)
+    enabled_codes = set(options.enable_error_code)
+
+    valid_error_codes = set(error_codes.keys())
+
+    invalid_codes = (enabled_codes | disabled_codes) - valid_error_codes
+    if invalid_codes:
+        parser.error("Invalid error code(s): %s" %
+                     ', '.join(sorted(invalid_codes)))
+
+    options.disabled_error_codes |= {error_codes[code] for code in disabled_codes}
+    options.enabled_error_codes |= {error_codes[code] for code in enabled_codes}
+
+    # Enabling an error code always overrides disabling
+    options.disabled_error_codes -= options.enabled_error_codes
+
     # Set build flags.
     if options.strict_optional_whitelist is not None:
         # TODO: Deprecate, then kill this flag

mypy/message_registry.py

@@ -109,6 +109,7 @@
 SUPER_POSITIONAL_ARGS_REQUIRED = '"super" only accepts positional arguments'  # type: Final
 SUPER_ARG_2_NOT_INSTANCE_OF_ARG_1 = \
     'Argument 2 for "super" not an instance of argument 1'  # type: Final
+TARGET_CLASS_HAS_NO_BASE_CLASS = 'Target class has no base class'  # type: Final
 SUPER_OUTSIDE_OF_METHOD_NOT_SUPPORTED = \
     'super() outside of a method is not supported'  # type: Final
 SUPER_ENCLOSING_POSITIONAL_ARGS_REQUIRED = \

mypy/modulefinder.py

@@ -49,10 +49,18 @@ class ModuleNotFoundReason(Enum):
     # corresponding *-stubs package.
     FOUND_WITHOUT_TYPE_HINTS = 1
 
+    # The module was not found in the current working directory, but
+    # was able to be found in the parent directory.
+    WRONG_WORKING_DIRECTORY = 2
+
     def error_message_templates(self) -> Tuple[str, str]:
         if self is ModuleNotFoundReason.NOT_FOUND:
             msg = "Cannot find implementation or library stub for module named '{}'"
             note = "See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports"
+        elif self is ModuleNotFoundReason.WRONG_WORKING_DIRECTORY:
+            msg = "Cannot find implementation or library stub for module named '{}'"
+            note = ("You may be running mypy in a subpackage, "
+                    "mypy should be run on the package root")
         elif self is ModuleNotFoundReason.FOUND_WITHOUT_TYPE_HINTS:
             msg = "Skipping analyzing '{}': found module but no type hints or library stubs"
             note = "See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports"
@@ -166,6 +174,9 @@ def find_module(self, id: str) -> ModuleSearchResult:
         """Return the path of the module source file or why it wasn't found."""
         if id not in self.results:
             self.results[id] = self._find_module(id)
+            if (self.results[id] is ModuleNotFoundReason.NOT_FOUND
+                    and self._can_find_module_in_parent_dir(id)):
+                self.results[id] = ModuleNotFoundReason.WRONG_WORKING_DIRECTORY
         return self.results[id]
 
     def _find_module_non_stub_helper(self, components: List[str],
@@ -192,6 +203,20 @@ def _update_ns_ancestors(self, components: List[str], match: Tuple[str, bool]) -
                 self.ns_ancestors[pkg_id] = path
             path = os.path.dirname(path)
 
+    def _can_find_module_in_parent_dir(self, id: str) -> bool:
+        """Test if a module can be found by checking the parent directories
+        of the current working directory.
+        """
+        working_dir = os.getcwd()
+        parent_search = FindModuleCache(SearchPaths((), (), (), ()))
+        while any(file.endswith(("__init__.py", "__init__.pyi"))
+                  for file in os.listdir(working_dir)):
+            working_dir = os.path.dirname(working_dir)
+            parent_search.search_paths = SearchPaths((working_dir,), (), (), ())
+            if not isinstance(parent_search._find_module(id), ModuleNotFoundReason):
+                return True
+        return False
+
     def _find_module(self, id: str) -> ModuleSearchResult:
         fscache = self.fscache
 

mypy/options.py

@@ -3,12 +3,15 @@
 import pprint
 import sys
 
-from typing_extensions import Final
+from typing_extensions import Final, TYPE_CHECKING
 from typing import Dict, List, Mapping, Optional, Pattern, Set, Tuple, Callable, Any
 
 from mypy import defaults
 from mypy.util import get_class_descriptors, replace_object_state
 
+if TYPE_CHECKING:
+    from mypy.errors import ErrorCode
+
 
 class BuildType:
     STANDARD = 0  # type: Final[int]
@@ -177,6 +180,14 @@ def __init__(self) -> None:
         # Variable names considered False
         self.always_false = []  # type: List[str]
 
+        # Error codes to disable
+        self.disable_error_code = []  # type: List[str]
+        self.disabled_error_codes = set()  # type: Set[ErrorCode]
+
+        # Error codes to enable
+        self.enable_error_code = []  # type: List[str]
+        self.enabled_error_codes = set()  # type: Set[ErrorCode]
+
         # Use script name instead of __main__
         self.scripts_are_modules = False
 

mypy/semanal.py

@@ -4542,9 +4542,18 @@ def current_symbol_table(self, escape_comprehensions: bool = False) -> SymbolTab
         if self.is_func_scope():
             assert self.locals[-1] is not None
             if escape_comprehensions:
+                assert len(self.locals) == len(self.is_comprehension_stack)
+                # Retrieve the symbol table from the enclosing non-comprehension scope.
                 for i, is_comprehension in enumerate(reversed(self.is_comprehension_stack)):
                     if not is_comprehension:
-                        names = self.locals[-1 - i]
+                        if i == len(self.locals) - 1:  # The last iteration.
+                            # The caller of the comprehension is in the global space.
+                            names = self.globals
+                        else:
+                            names_candidate = self.locals[-1 - i]
+                            assert names_candidate is not None, \
+                                "Escaping comprehension from invalid scope"
+                            names = names_candidate
                         break
                 else:
                     assert False, "Should have at least one non-comprehension scope"