Remove all builtins.unicode references

docs/source/mypy_daemon.rst

@@ -228,11 +228,6 @@ command.
  Only allow some fraction of types in the suggested signature to be ``Any`` types.
  The fraction ranges from ``0`` (same as ``--no-any``) to ``1``.
 
-.. option:: --try-text
-
- Try also using ``unicode`` wherever ``str`` is inferred. This flag may be useful
- for annotating Python 2/3 straddling code.
-
 .. option:: --callsites
 
  Only find call sites for a given function instead of suggesting a type.

mypy/dmypy/client.py

@@ -161,9 +161,6 @@ def __init__(self, prog: str) -> None:
  type=float,
  help="Allow anys in types if they go above a certain score (scores are from 0-1)",
 )
-p.add_argument(
- "--try-text", action="store_true", help="Try using unicode wherever str is inferred"
-)
 p.add_argument(
  "--callsites", action="store_true", help="Find callsites instead of suggesting a type"
 )
@@ -525,7 +522,6 @@ def do_suggest(args: argparse.Namespace) -> None:
  no_errors=args.no_errors,
  no_any=args.no_any,
  flex_any=args.flex_any,
- try_text=args.try_text,
  use_fixme=args.use_fixme,
  max_guesses=args.max_guesses,
  )

mypy/exprtotype.py

@@ -168,13 +168,9 @@ def expr_to_unanalyzed_type(
  column=expr.column,
  )
  elif isinstance(expr, StrExpr):
- return parse_type_string(
- expr.value, "builtins.str", expr.line, expr.column, assume_str_is_unicode=True
- )
+ return parse_type_string(expr.value, "builtins.str", expr.line, expr.column)
  elif isinstance(expr, BytesExpr):
- return parse_type_string(
- expr.value, "builtins.bytes", expr.line, expr.column, assume_str_is_unicode=False
- )
+ return parse_type_string(expr.value, "builtins.bytes", expr.line, expr.column)
  elif isinstance(expr, UnaryExpr):
  typ = expr_to_unanalyzed_type(expr.expr, options, allow_new_syntax)
  if isinstance(typ, RawExpressionType):

mypy/fastparse.py

@@ -331,11 +331,7 @@ def parse_type_ignore_tag(tag: Optional[str]) -> Optional[List[str]]:
 
 
 def parse_type_comment(
- type_comment: str,
- line: int,
- column: int,
- errors: Optional[Errors],
- assume_str_is_unicode: bool = True,
+ type_comment: str, line: int, column: int, errors: Optional[Errors]
 ) -> Tuple[Optional[List[str]], Optional[ProperType]]:
  """Parse type portion of a type comment (+ optional type ignore).
 
@@ -366,44 +362,21 @@ def parse_type_comment(
  ignored = None
  assert isinstance(typ, ast3_Expression)
  converted = TypeConverter(
- errors,
- line=line,
- override_column=column,
- assume_str_is_unicode=assume_str_is_unicode,
- is_evaluated=False,
+ errors, line=line, override_column=column, is_evaluated=False
  ).visit(typ.body)
  return ignored, converted
 
 
 def parse_type_string(
- expr_string: str,
- expr_fallback_name: str,
- line: int,
- column: int,
- assume_str_is_unicode: bool = True,
+ expr_string: str, expr_fallback_name: str, line: int, column: int
 ) -> ProperType:
- """Parses a type that was originally present inside of an explicit string,
- byte string, or unicode string.
+ """Parses a type that was originally present inside of an explicit string.
 
  For example, suppose we have the type `Foo["blah"]`. We should parse the
  string expression "blah" using this function.
-
- If `assume_str_is_unicode` is set to true, this function will assume that
- `Foo["blah"]` is equivalent to `Foo[u"blah"]`. Otherwise, it assumes it's
- equivalent to `Foo[b"blah"]`.
-
- The caller is responsible for keeping track of the context in which the
- type string was encountered (e.g. in Python 3 code, Python 2 code, Python 2
- code with unicode_literals...) and setting `assume_str_is_unicode` accordingly.
  """
  try:
- _, node = parse_type_comment(
- expr_string.strip(),
- line=line,
- column=column,
- errors=None,
- assume_str_is_unicode=assume_str_is_unicode,
- )
+ _, node = parse_type_comment(expr_string.strip(), line=line, column=column, errors=None)
  if isinstance(node, UnboundType) and node.original_str_expr is None:
  node.original_str_expr = expr_string
  node.original_str_fallback = expr_fallback_name
@@ -1743,14 +1716,12 @@ def __init__(
  errors: Optional[Errors],
  line: int = -1,
  override_column: int = -1,
- assume_str_is_unicode: bool = True,
  is_evaluated: bool = True,
  ) -> None:
  self.errors = errors
  self.line = line
  self.override_column = override_column
  self.node_stack: List[AST] = []
- self.assume_str_is_unicode = assume_str_is_unicode
  self.is_evaluated = is_evaluated
 
  def convert_column(self, column: int) -> int:
@@ -1921,22 +1892,7 @@ def visit_Constant(self, n: Constant) -> Type:
  return UnboundType("None", line=self.line)
  if isinstance(val, str):
  # Parse forward reference.
- if (n.kind and "u" in n.kind) or self.assume_str_is_unicode:
- return parse_type_string(
- n.s,
- "builtins.unicode",
- self.line,
- n.col_offset,
- assume_str_is_unicode=self.assume_str_is_unicode,
- )
- else:
- return parse_type_string(
- n.s,
- "builtins.str",
- self.line,
- n.col_offset,
- assume_str_is_unicode=self.assume_str_is_unicode,
- )
+ return parse_type_string(n.s, "builtins.str", self.line, n.col_offset)
  if val is Ellipsis:
  # '...' is valid in some types.
  return EllipsisType(line=self.line)
@@ -1990,34 +1946,7 @@ def visit_Num(self, n: Num) -> Type:
 
  # Str(string s)
  def visit_Str(self, n: Str) -> Type:
- # Note: we transform these fallback types into the correct types in
- # 'typeanal.py' -- specifically in the named_type_with_normalized_str method.
- # If we're analyzing Python 3, that function will translate 'builtins.unicode'
- # into 'builtins.str'. In contrast, if we're analyzing Python 2 code, we'll
- # translate 'builtins.bytes' in the method below into 'builtins.str'.
-
- # Do a getattr because the field doesn't exist in 3.8 (where
- # this method doesn't actually ever run.) We can't just do
- # an attribute access with a `# type: ignore` because it would be
- # unused on < 3.8.
- kind: str = getattr(n, "kind") # noqa
-
- if "u" in kind or self.assume_str_is_unicode:
- return parse_type_string(
- n.s,
- "builtins.unicode",
- self.line,
- n.col_offset,
- assume_str_is_unicode=self.assume_str_is_unicode,
- )
- else:
- return parse_type_string(
- n.s,
- "builtins.str",
- self.line,
- n.col_offset,
- assume_str_is_unicode=self.assume_str_is_unicode,
- )
+ return parse_type_string(n.s, "builtins.str", self.line, n.col_offset)
 
  # Bytes(bytes s)
  def visit_Bytes(self, n: Bytes) -> Type:

mypy/plugins/ctypes.py

@@ -23,26 +23,6 @@
 )
 
 
-def _get_bytes_type(api: "mypy.plugin.CheckerPluginInterface") -> Instance:
- """Return the type corresponding to bytes on the current Python version.
-
- This is bytes in Python 3, and str in Python 2.
- """
- return api.named_generic_type(
- "builtins.bytes" if api.options.python_version >= (3,) else "builtins.str", []
- )
-
-
-def _get_text_type(api: "mypy.plugin.CheckerPluginInterface") -> Instance:
- """Return the type corresponding to Text on the current Python version.
-
- This is str in Python 3, and unicode in Python 2.
- """
- return api.named_generic_type(
- "builtins.str" if api.options.python_version >= (3,) else "builtins.unicode", []
- )
-
-
 def _find_simplecdata_base_arg(
  tp: Instance, api: "mypy.plugin.CheckerPluginInterface"
 ) -> Optional[ProperType]:
@@ -221,9 +201,9 @@ def array_value_callback(ctx: "mypy.plugin.AttributeContext") -> Type:
  if isinstance(tp, AnyType):
  types.append(AnyType(TypeOfAny.from_another_any, source_any=tp))
  elif isinstance(tp, Instance) and tp.type.fullname == "ctypes.c_char":
- types.append(_get_bytes_type(ctx.api))
+ types.append(ctx.api.named_generic_type("builtins.bytes", []))
  elif isinstance(tp, Instance) and tp.type.fullname == "ctypes.c_wchar":
- types.append(_get_text_type(ctx.api))
+ types.append(ctx.api.named_generic_type("builtins.str", []))
  else:
  ctx.api.msg.fail(
  'Array attribute "value" is only available'
@@ -245,7 +225,7 @@ def array_raw_callback(ctx: "mypy.plugin.AttributeContext") -> Type:
  or isinstance(tp, Instance)
  and tp.type.fullname == "ctypes.c_char"
  ):
- types.append(_get_bytes_type(ctx.api))
+ types.append(ctx.api.named_generic_type("builtins.bytes", []))
  else:
  ctx.api.msg.fail(
  'Array attribute "raw" is only available'

mypy/stubgen.py

@@ -308,7 +308,7 @@ def args_str(self, args: Iterable[Type]) -> str:
  The main difference from list_str is the preservation of quotes for string
  arguments
  """
- types = ["builtins.bytes", "builtins.unicode"]
+ types = ["builtins.bytes", "builtins.str"]
  res = []
  for arg in args:
  arg_str = arg.accept(self)

mypy/suggestions.py

@@ -249,7 +249,6 @@ def __init__(
  json: bool,
  no_errors: bool = False,
  no_any: bool = False,
- try_text: bool = False,
  flex_any: Optional[float] = None,
  use_fixme: Optional[str] = None,
  max_guesses: Optional[int] = None,
@@ -262,7 +261,6 @@ def __init__(
 
  self.give_json = json
  self.no_errors = no_errors
- self.try_text = try_text
  self.flex_any = flex_any
  if no_any:
  self.flex_any = 1.0
@@ -401,12 +399,6 @@ def get_default_arg_types(self, fdef: FuncDef) -> List[Optional[Type]]:
  for arg in fdef.arguments
  ]
 
- def add_adjustments(self, typs: List[Type]) -> List[Type]:
- if not self.try_text or self.manager.options.python_version[0] != 2:
- return typs
- translator = StrToText(self.named_type)
- return dedup(typs + [tp.accept(translator) for tp in typs])
-
  def get_guesses(
  self,
  is_method: bool,
@@ -420,7 +412,6 @@ def get_guesses(
  This focuses just on the argument types, and doesn't change the provided return type.
  """
  options = self.get_args(is_method, base, defaults, callsites, uses)
- options = [self.add_adjustments(tps) for tps in options]
 
  # Take the first `max_guesses` guesses.
  product = itertools.islice(itertools.product(*options), 0, self.max_guesses)
@@ -775,8 +766,6 @@ def score_type(self, t: Type, arg_pos: bool) -> int:
  return 10
  if isinstance(t, CallableType) and (has_any_type(t) or is_tricky_callable(t)):
  return 10
- if self.try_text and isinstance(t, Instance) and t.type.fullname == "builtins.str":
- return 1
  return 0
 
  def score_callable(self, t: CallableType) -> int:
@@ -909,23 +898,6 @@ def visit_callable_type(self, t: CallableType) -> str:
  return f"Callable[{arg_str}, {t.ret_type.accept(self)}]"
 
 
-class StrToText(TypeTranslator):
- def __init__(self, named_type: Callable[[str], Instance]) -> None:
- self.text_type = named_type("builtins.unicode")
-
- def visit_type_alias_type(self, t: TypeAliasType) -> Type:
- exp_t = get_proper_type(t)
- if isinstance(exp_t, Instance) and exp_t.type.fullname == "builtins.str":
- return self.text_type
- return t.copy_modified(args=[a.accept(self) for a in t.args])
-
- def visit_instance(self, t: Instance) -> Type:
- if t.type.fullname == "builtins.str":
- return self.text_type
- else:
- return super().visit_instance(t)
-
-
 TType = TypeVar("TType", bound=Type)
 
 

mypy/test/testfinegrained.py

@@ -292,7 +292,6 @@ def maybe_suggest(self, step: int, server: Server, src: str, tmp_dir: str) -> Li
  callsites = "--callsites" in flags
  no_any = "--no-any" in flags
  no_errors = "--no-errors" in flags
- try_text = "--try-text" in flags
  m = re.match("--flex-any=([0-9.]+)", flags)
  flex_any = float(m.group(1)) if m else None
  m = re.match(r"--use-fixme=(\w+)", flags)
@@ -304,7 +303,6 @@ def maybe_suggest(self, step: int, server: Server, src: str, tmp_dir: str) -> Li
  json=json,
  no_any=no_any,
  no_errors=no_errors,
- try_text=try_text,
  flex_any=flex_any,
  use_fixme=use_fixme,
  callsites=callsites,

mypy/typeanal.py

@@ -1162,7 +1162,7 @@ def analyze_literal_param(self, idx: int, arg: Type, ctx: Context) -> Optional[L
  return [
  LiteralType(
  value=arg.original_str_expr,
- fallback=self.named_type_with_normalized_str(arg.original_str_fallback),
+ fallback=self.named_type(arg.original_str_fallback),
  line=arg.line,
  column=arg.column,
  )
@@ -1210,7 +1210,7 @@ def analyze_literal_param(self, idx: int, arg: Type, ctx: Context) -> Optional[L
  return None
 
  # Remap bytes and unicode into the appropriate type for the correct Python version
- fallback = self.named_type_with_normalized_str(arg.base_type_name)
+ fallback = self.named_type(arg.base_type_name)
  assert isinstance(fallback, Instance)
  return [LiteralType(arg.literal_value, fallback, line=arg.line, column=arg.column)]
  elif isinstance(arg, (NoneType, LiteralType)):
@@ -1357,17 +1357,6 @@ def anal_var_def(self, var_def: TypeVarLikeType) -> TypeVarLikeType:
  def anal_var_defs(self, var_defs: Sequence[TypeVarLikeType]) -> List[TypeVarLikeType]:
  return [self.anal_var_def(vd) for vd in var_defs]
 
- def named_type_with_normalized_str(self, fully_qualified_name: str) -> Instance:
- """Does almost the same thing as `named_type`, except that we immediately
- unalias `builtins.bytes` and `builtins.unicode` to `builtins.str` as appropriate.
- """
- python_version = self.options.python_version
- if python_version[0] == 2 and fully_qualified_name == "builtins.bytes":
- fully_qualified_name = "builtins.str"
- if python_version[0] >= 3 and fully_qualified_name == "builtins.unicode":
- fully_qualified_name = "builtins.str"
- return self.named_type(fully_qualified_name)
-
  def named_type(
  self,
  fully_qualified_name: str,

mypy/types.py

@@ -2406,10 +2406,6 @@ def value_repr(self) -> str:
  # Note: 'builtins.bytes' only appears in Python 3, so we want to
  # explicitly prefix with a "b"
  return "b" + raw
- elif fallback_name == "builtins.unicode":
- # Similarly, 'builtins.unicode' only appears in Python 2, where we also
- # want to explicitly prefix
- return "u" + raw
  else:
  # 'builtins.str' could mean either depending on context, but either way
  # we don't prefix: it's the "native" string. And of course, if value is