python
diff --git a/‎mypy/checker.py
Lines changed: 3 additions & 3 deletions b/‎mypy/checker.py
Lines changed: 3 additions & 3 deletions
diff --git a/‎mypy/git.py
Lines changed: 0 additions & 6 deletions b/‎mypy/git.py
Lines changed: 0 additions & 6 deletions
diff --git a/‎mypy/join.py
Lines changed: 3 additions & 4 deletions b/‎mypy/join.py
Lines changed: 3 additions & 4 deletions
diff --git a/‎mypy/meet.py
Lines changed: 1 addition & 2 deletions b/‎mypy/meet.py
Lines changed: 1 addition & 2 deletions
diff --git a/‎mypy/messages.py
Lines changed: 2 additions & 6 deletions b/‎mypy/messages.py
Lines changed: 2 additions & 6 deletions
diff --git a/‎mypy/plugins/singledispatch.py
Lines changed: 0 additions & 9 deletions b/‎mypy/plugins/singledispatch.py
Lines changed: 0 additions & 9 deletions
diff --git a/‎mypy/semanal.py
Lines changed: 0 additions & 16 deletions b/‎mypy/semanal.py
Lines changed: 0 additions & 16 deletions
diff --git a/‎mypy/semanal_shared.py
Lines changed: 1 addition & 23 deletions b/‎mypy/semanal_shared.py
Lines changed: 1 addition & 23 deletions
diff --git a/‎mypy/server/update.py
Lines changed: 0 additions & 7 deletions b/‎mypy/server/update.py
Lines changed: 0 additions & 7 deletions
diff --git a/‎mypy/subtypes.py
Lines changed: 0 additions & 4 deletions b/‎mypy/subtypes.py
Lines changed: 0 additions & 4 deletions
@@ -63,7 +63,7 @@
 from mypy.message_registry import ErrorMessage
 from mypy.subtypes import (
     is_subtype, is_equivalent, is_proper_subtype, is_more_precise,
-    restrict_subtype_away, is_subtype_ignoring_tvars, is_callable_compatible,
+    restrict_subtype_away, is_callable_compatible,
     unify_generic_callable, find_member
 )
 from mypy.constraints import SUPERTYPE_OF
@@ -956,7 +956,7 @@ def check_func_def(self, defn: FuncItem, typ: CallableType, name: Optional[str])
                         if isclass:
                             ref_type = mypy.types.TypeType.make_normalized(ref_type)
                         erased = get_proper_type(erase_to_bound(arg_type))
-                        if not is_subtype_ignoring_tvars(ref_type, erased):
+                        if not is_subtype(ref_type, erased, ignore_type_params=True):
                             note = None
                             if (isinstance(erased, Instance) and erased.type.is_protocol or
                                     isinstance(erased, TypeType) and
@@ -1737,7 +1737,7 @@ def erase_override(t: Type) -> Type:
 
                 if len(order) == len(original.items) and order != sorted(order):
                     self.msg.overload_signature_incompatible_with_supertype(
-                        name, name_in_super, supertype, override, node)
+                        name, name_in_super, supertype, node)
                     emitted_msg = True
 
             if not emitted_msg:
 
@@ -30,9 +30,3 @@ def is_dirty(dir: str) -> bool:
     """Check whether a git repository has uncommitted changes."""
     output = subprocess.check_output(["git", "status", "-uno", "--porcelain"], cwd=dir)
     return output.strip() != b""
-
-
-def has_extra_files(dir: str) -> bool:
-    """Check whether a git repository has untracked files."""
-    output = subprocess.check_output(["git", "clean", "--dry-run", "-d"], cwd=dir)
-    return output.strip() != b""
@@ -11,7 +11,7 @@
 )
 from mypy.maptype import map_instance_to_supertype
 from mypy.subtypes import (
-    is_subtype, is_equivalent, is_subtype_ignoring_tvars, is_proper_subtype,
+    is_subtype, is_equivalent, is_proper_subtype,
     is_protocol_implementation, find_member
 )
 from mypy.nodes import INVARIANT, COVARIANT, CONTRAVARIANT
@@ -72,7 +72,7 @@ def join_instances(self, t: Instance, s: Instance) -> ProperType:
                 assert new_type is not None
                 args.append(new_type)
             result: ProperType = Instance(t.type, args)
-        elif t.type.bases and is_subtype_ignoring_tvars(t, s):
+        elif t.type.bases and is_subtype(t, s, ignore_type_params=True):
             result = self.join_instances_via_supertype(t, s)
         else:
             # Now t is not a subtype of s, and t != s. Now s could be a subtype
@@ -402,8 +402,7 @@ def visit_typeddict_type(self, t: TypedDictType) -> ProperType:
                 if (is_equivalent(s_item_type, t_item_type) and
                     (item_name in t.required_keys) == (item_name in self.s.required_keys))
             ])
-            mapping_value_type = join_type_list(list(items.values()))
-            fallback = self.s.create_anonymous_fallback(value_type=mapping_value_type)
+            fallback = self.s.create_anonymous_fallback()
             # We need to filter by items.keys() since some required keys present in both t and
             # self.s might be missing from the join if the types are incompatible.
             required_keys = set(items.keys()) & t.required_keys & self.s.required_keys
 
@@ -629,8 +629,7 @@ def visit_typeddict_type(self, t: TypedDictType) -> ProperType:
                     assert t_item_type is not None
                     item_list.append((item_name, t_item_type))
             items = OrderedDict(item_list)
-            mapping_value_type = join.join_type_list(list(items.values()))
-            fallback = self.s.create_anonymous_fallback(value_type=mapping_value_type)
+            fallback = self.s.create_anonymous_fallback()
             required_keys = t.required_keys | self.s.required_keys
             return TypedDictType(items, required_keys, fallback)
         elif isinstance(self.s, Instance) and is_subtype(t, self.s):
 
@@ -807,7 +807,7 @@ def incompatible_operator_assignment(self, op: str,
 
     def overload_signature_incompatible_with_supertype(
             self, name: str, name_in_super: str, supertype: str,
-            overload: Overloaded, context: Context) -> None:
+            context: Context) -> None:
         target = self.override_target(name, name_in_super, supertype)
         self.fail('Signature of "{}" incompatible with {}'.format(
             name, target), context, code=codes.OVERRIDE)
@@ -1399,9 +1399,6 @@ def redundant_condition_in_comprehension(self, truthiness: bool, context: Contex
     def redundant_condition_in_if(self, truthiness: bool, context: Context) -> None:
         self.redundant_expr("If condition", truthiness, context)
 
-    def redundant_condition_in_assert(self, truthiness: bool, context: Context) -> None:
-        self.redundant_expr("Condition in assert", truthiness, context)
-
     def redundant_expr(self, description: str, truthiness: bool, context: Context) -> None:
         self.fail("{} is always {}".format(description, str(truthiness).lower()),
                   context, code=codes.REDUNDANT_EXPR)
@@ -1855,8 +1852,7 @@ def format_type(typ: Type, verbosity: int = 0) -> str:
 
 
 def format_type_bare(typ: Type,
-                     verbosity: int = 0,
-                     fullnames: Optional[Set[str]] = None) -> str:
+                     verbosity: int = 0) -> str:
     """
     Convert a type to a relatively short string suitable for error messages.
 
 
@@ -201,15 +201,6 @@ def call_singledispatch_function_after_register_argument(ctx: MethodContext) ->
     return ctx.default_return_type
 
 
-def rename_func(func: CallableType, new_name: CallableType) -> CallableType:
-    """Return a new CallableType that is `function` with the name of `new_name`"""
-    if new_name.name is not None:
-        signature_used = func.with_name(new_name.name)
-    else:
-        signature_used = func
-    return signature_used
-
-
 def call_singledispatch_function_callback(ctx: MethodSigContext) -> FunctionLike:
     """Called for functools._SingleDispatchCallable.__call__"""
     if not isinstance(ctx.type, Instance):
 
@@ -4979,19 +4979,6 @@ def add_exports(self, exp_or_exps: Union[Iterable[Expression], Expression]) -> N
             if isinstance(exp, StrExpr):
                 self.all_exports.append(exp.value)
 
-    def check_no_global(self,
-                        name: str,
-                        ctx: Context,
-                        is_overloaded_func: bool = False) -> None:
-        if name in self.globals:
-            prev_is_overloaded = isinstance(self.globals[name], OverloadedFuncDef)
-            if is_overloaded_func and prev_is_overloaded:
-                self.fail("Nonconsecutive overload {} found".format(name), ctx)
-            elif prev_is_overloaded:
-                self.fail("Definition of '{}' missing 'overload'".format(name), ctx)
-            else:
-                self.name_already_defined(name, ctx, self.globals[name])
-
     def name_not_defined(self, name: str, ctx: Context, namespace: Optional[str] = None) -> None:
         incomplete = self.is_incomplete_namespace(namespace or self.cur_mod_id)
         if (namespace is None
@@ -5121,9 +5108,6 @@ def fail(self,
         assert ctx is not None, msg
         self.errors.report(ctx.get_line(), ctx.get_column(), msg, blocker=blocker, code=code)
 
-    def fail_blocker(self, msg: str, ctx: Context) -> None:
-        self.fail(msg, ctx, blocker=True)
-
     def note(self, msg: str, ctx: Context, code: Optional[ErrorCode] = None) -> None:
         if not self.in_checked_function():
             return
 
@@ -7,10 +7,9 @@
 from mypy_extensions import trait
 
 from mypy.nodes import (
-    Context, SymbolTableNode, MypyFile, ImportedName, FuncDef, Node, TypeInfo, Expression, GDEF,
+    Context, SymbolTableNode, FuncDef, Node, TypeInfo, Expression,
     SymbolNode, SymbolTable
 )
-from mypy.util import correct_relative_import
 from mypy.types import (
     Type, FunctionLike, Instance, TupleType, TPDICT_FB_NAMES, ProperType, get_proper_type
 )
@@ -179,27 +178,6 @@ def is_func_scope(self) -> bool:
         raise NotImplementedError
 
 
-def create_indirect_imported_name(file_node: MypyFile,
-                                  module: str,
-                                  relative: int,
-                                  imported_name: str) -> Optional[SymbolTableNode]:
-    """Create symbol table entry for a name imported from another module.
-
-    These entries act as indirect references.
-    """
-    target_module, ok = correct_relative_import(
-        file_node.fullname,
-        relative,
-        module,
-        file_node.is_package_init_file())
-    if not ok:
-        return None
-    target_name = '%s.%s' % (target_module, imported_name)
-    link = ImportedName(target_name)
-    # Use GDEF since this refers to a module-level definition.
-    return SymbolTableNode(GDEF, link)
-
-
 def set_callable_name(sig: Type, fdef: FuncDef) -> ProperType:
     sig = get_proper_type(sig)
     if isinstance(sig, FunctionLike):
 
@@ -485,13 +485,6 @@ def ensure_trees_loaded(manager: BuildManager, graph: Dict[str, State],
         process_fresh_modules(graph, to_process, manager)
 
 
-def fix_fg_dependencies(manager: BuildManager, deps: Dict[str, Set[str]]) -> None:
-    """Populate the dependencies with stuff that build may have missed"""
-    # This means the root module and typestate
-    merge_dependencies(manager.load_fine_grained_deps(FAKE_ROOT_MODULE), deps)
-    # TypeState.add_all_protocol_deps(deps)
-
-
 # The result of update_module_isolated when no blockers, with these items:
 #
 # - Id of the changed module (can be different from the module argument)
 
@@ -154,10 +154,6 @@ def _is_subtype(left: Type, right: Type,
                                       ignore_promotions=ignore_promotions))
 
 
-def is_subtype_ignoring_tvars(left: Type, right: Type) -> bool:
-    return is_subtype(left, right, ignore_type_params=True)
-
-
 def is_equivalent(a: Type, b: Type,
                   *,
                   ignore_type_params: bool = False,