def no_variant_matches_arguments(self, overload: Overloaded,
                                   context: Context) -> None:
     if overload.name():
         self.fail('No overload variant of {} matches argument types'
                   .format(overload.name()), context)
     else:
         self.fail('No overload variant matches argument types', context)

 def no_variant_matches_arguments(self, overload: Overloaded, arg_types: List[Type],
                                  context: Context) -> None:
     if overload.name():
         self.fail('No overload variant of {} matches argument types {}'
                   .format(overload.name(), arg_types), context)
     else:
         self.fail('No overload variant matches argument types {}'.format(arg_types), context)

 def visit_overloaded(self, t: Overloaded) -> Type:
     items = []  # type: List[CallableType]
     for item in t.items():
         new_item = item.accept(self)
         assert isinstance(new_item, CallableType)
         items.append(new_item)
     return Overloaded(items)

 def visit_overloaded(self, t: Overloaded) -> Type:
     # TODO: Implement a better algorithm that covers at least the same cases
     # as TypeJoinVisitor.visit_overloaded().
     s = self.s
     if isinstance(s, FunctionLike):
         if s.items() == t.items():
             return Overloaded(t.items())
         elif is_subtype(s, t):
             return s
         elif is_subtype(t, s):
             return t
         else:
             return meet_types(t.fallback, s.fallback)
     elif isinstance(self.s, Instance) and self.s.type.is_protocol:
         call = unpack_callback_protocol(self.s)
         if call:
             return meet_types(t, call)
     return meet_types(t.fallback, s)

 def visit_overloaded(self, t: Overloaded) -> Type:
     items = []  # type: List[CallableType]
     for item in t.items():
         new = item.accept(self)
         if isinstance(new, CallableType):
             items.append(new)
         else:
             raise RuntimeError('CallableType expected, but got {}'.format(type(new)))
     return Overloaded(items=items)

 def infer_against_overloaded(self, overloaded: Overloaded,
                              template: Callable) -> List[Constraint]:
     # Create constraints by matching an overloaded type against a template.
     # This is tricky to do in general. We cheat by only matching against
     # the first overload item, and by only matching the return type. This
     # seems to work somewhat well, but we should really use a more
     # reliable technique.
     item = overloaded.items()[0]
     return infer_constraints(template.ret_type, item.ret_type,
                              self.direction)

def find_matching_overload_item(overloaded: Overloaded, template: CallableType) -> CallableType:
    """Disambiguate overload item against a template."""
    items = overloaded.items()
    for item in items:
        # Return type may be indeterminate in the template, so ignore it when performing a
        # subtype check.
        if mypy.subtypes.is_callable_subtype(item, template, ignore_return=True):
            return item
    # Fall back to the first item if we can't find a match. This is totally arbitrary --
    # maybe we should just bail out at this point.
    return items[0]

 def visit_overloaded(self, left: Overloaded) -> bool:
     right = self.right
     if isinstance(right, Instance):
         return is_subtype(left.fallback, right)
     elif isinstance(right, CallableType) or is_named_instance(right, "builtins.type"):
         for item in left.items():
             if is_subtype(item, right, self.check_type_parameter):
                 return True
         return False
     elif isinstance(right, Overloaded):
         # TODO: this may be too restrictive
         if len(left.items()) != len(right.items()):
             return False
         for i in range(len(left.items())):
             if not is_subtype(left.items()[i], right.items()[i], self.check_type_parameter):
                 return False
         return True
     elif isinstance(right, UnboundType):
         return True
     else:
         return False

 def visit_overloaded(self, left: Overloaded) -> bool:
     right = self.right
     if isinstance(right, Instance):
         return is_subtype(left.fallback, right)
     elif isinstance(right, CallableType) or is_named_instance(
             right, 'builtins.type'):
         for item in left.items():
             if is_subtype(item, right, self.check_type_parameter,
                           ignore_pos_arg_names=self.ignore_pos_arg_names):
                 return True
         return False
     elif isinstance(right, Overloaded):
         # TODO: this may be too restrictive
         if len(left.items()) != len(right.items()):
             return False
         for i in range(len(left.items())):
             if not is_subtype(left.items()[i], right.items()[i], self.check_type_parameter,
                               ignore_pos_arg_names=self.ignore_pos_arg_names):
                 return False
         return True
     elif isinstance(right, UnboundType):
         return True
     elif isinstance(right, TypeType):
         # All the items must have the same type object status, so
         # it's sufficient to query only (any) one of them.
         # This is unsound, we don't check the __init__ signature.
         return left.is_type_obj() and is_subtype(left.items()[0].ret_type, right.item)
     else:
         return False

 def visit_overloaded(self, t: Overloaded) -> Type:
     # This is more complex than most other cases. Here are some
     # examples that illustrate how this works.
     #
     # First let's define a concise notation:
     #  - Cn are callable types (for n in 1, 2, ...)
     #  - Ov(C1, C2, ...) is an overloaded type with items C1, C2, ...
     #  - Callable[[T, ...], S] is written as [T, ...] -> S.
     #
     # We want some basic properties to hold (assume Cn are all
     # unrelated via Any-similarity):
     #
     #   join(Ov(C1, C2), C1) == C1
     #   join(Ov(C1, C2), Ov(C1, C2)) == Ov(C1, C2)
     #   join(Ov(C1, C2), Ov(C1, C3)) == C1
     #   join(Ov(C2, C2), C3) == join of fallback types
     #
     # The presence of Any types makes things more interesting. The join is the
     # most general type we can get with respect to Any:
     #
     #   join(Ov([int] -> int, [str] -> str), [Any] -> str) == Any -> str
     #
     # We could use a simplification step that removes redundancies, but that's not
     # implemented right now. Consider this example, where we get a redundancy:
     #
     #   join(Ov([int, Any] -> Any, [str, Any] -> Any), [Any, int] -> Any) ==
     #       Ov([Any, int] -> Any, [Any, int] -> Any)
     #
     # TODO: Consider more cases of callable subtyping.
     result = []  # type: List[CallableType]
     s = self.s
     if isinstance(s, FunctionLike):
         # The interesting case where both types are function types.
         for t_item in t.items():
             for s_item in s.items():
                 if is_similar_callables(t_item, s_item):
                     if is_equivalent(t_item, s_item):
                         result.append(combine_similar_callables(t_item, s_item))
                     elif is_subtype(t_item, s_item):
                         result.append(s_item)
         if result:
             # TODO: Simplify redundancies from the result.
             if len(result) == 1:
                 return result[0]
             else:
                 return Overloaded(result)
         return join_types(t.fallback, s.fallback)
     elif isinstance(s, Instance) and s.type.is_protocol:
         call = unpack_callback_protocol(s)
         if call:
             return join_types(t, call)
     return join_types(t.fallback, s)

 def visit_overloaded(self, left: Overloaded) -> bool:
     right = self.right
     if is_named_instance(right, 'builtins.object'):
         return True
     elif isinstance(right, Callable) or is_named_instance(
                                              right, 'builtins.type'):
         for item in left.items():
             if is_subtype(item, right):
                 return True
         return False
     elif isinstance(right, Overloaded):
         # TODO: this may be too restrictive
         if len(left.items()) != len(right.items()):
             return False
         for i in range(len(left.items())):
             if not is_subtype(left.items()[i], right.items()[i]):
                 return False
         return True
     elif isinstance(right, UnboundType):
         return True
     else:
         return False

 def visit_overloaded(self, t: Overloaded) -> Type:
     items = [] # type: List[Callable]
     for item in t.items():
         items.append(cast(Callable, item.accept(self)))
     return Overloaded(items)

    def visit_overloaded(self, left: Overloaded) -> bool:
        right = self.right
        if isinstance(right, Instance):
            return is_subtype(left.fallback, right)
        elif isinstance(right, CallableType):
            for item in left.items():
                if is_subtype(item, right, self.check_type_parameter,
                              ignore_pos_arg_names=self.ignore_pos_arg_names):
                    return True
            return False
        elif isinstance(right, Overloaded):
            # Ensure each overload in the right side (the supertype) is accounted for.
            previous_match_left_index = -1
            matched_overloads = set()
            possible_invalid_overloads = set()

            for right_index, right_item in enumerate(right.items()):
                found_match = False

                for left_index, left_item in enumerate(left.items()):
                    subtype_match = is_subtype(left_item, right_item, self.check_type_parameter,
                                               ignore_pos_arg_names=self.ignore_pos_arg_names)

                    # Order matters: we need to make sure that the index of
                    # this item is at least the index of the previous one.
                    if subtype_match and previous_match_left_index <= left_index:
                        if not found_match:
                            # Update the index of the previous match.
                            previous_match_left_index = left_index
                            found_match = True
                            matched_overloads.add(left_item)
                            possible_invalid_overloads.discard(left_item)
                    else:
                        # If this one overlaps with the supertype in any way, but it wasn't
                        # an exact match, then it's a potential error.
                        if (is_callable_subtype(left_item, right_item, ignore_return=True,
                                            ignore_pos_arg_names=self.ignore_pos_arg_names) or
                                is_callable_subtype(right_item, left_item, ignore_return=True,
                                                ignore_pos_arg_names=self.ignore_pos_arg_names)):
                            # If this is an overload that's already been matched, there's no
                            # problem.
                            if left_item not in matched_overloads:
                                possible_invalid_overloads.add(left_item)

                if not found_match:
                    return False

            if possible_invalid_overloads:
                # There were potentially invalid overloads that were never matched to the
                # supertype.
                return False
            return True
        elif isinstance(right, UnboundType):
            return True
        elif isinstance(right, TypeType):
            # All the items must have the same type object status, so
            # it's sufficient to query only (any) one of them.
            # This is unsound, we don't check all the __init__ signatures.
            return left.is_type_obj() and is_subtype(left.items()[0], right)
        else:
            return False

 def visit_overloaded(self, t: Overloaded) -> Type:
     return t.items()[0].accept(self)

 def visit_overloaded(self, t: Overloaded) -> None:
     for item in t.items():
         item.accept(self)

 def visit_overloaded(self, template: Overloaded) -> List[Constraint]:
     res = []  # type: List[Constraint]
     for t in template.items():
         res.extend(infer_constraints(t, self.actual, self.direction))
     return res

 def visit_overloaded(self, typ: Overloaded) -> SnapshotItem:
     return ('Overloaded', snapshot_types(typ.items()))

 def visit_overloaded(self, t: Overloaded) -> None:
     for item in t.items():
         item.accept(self)
     # Fallback can be None for overloaded types that haven't been semantically analyzed.
     if t.fallback is not None:
         t.fallback.accept(self)

 def visit_overloaded(self, t: Overloaded) -> None:
     self.traverse_types(t.items())

 def visit_overloaded(self, t: types.Overloaded) -> Set[str]:
     return self._visit(t.items()) | self._visit(t.fallback)