Understanding Python type annotation after indexing

I made a typo in my code and replaced an = with a :, which resulted in a line of code that looked like:

data = {}
data["teapot"]: "turtle"

To my surprise, this did not produce a syntax error, but I don't understand what it's doing.

I then dumped the abstract syntax tree and it appears that it is some sort of type hint, although not one I've been able to find an example of elsewhere:

>>> import ast
>>> print(ast.dump(ast.parse("data['x']: 'turtle'"), indent=2))
Module(
  body=[
    AnnAssign(
      target=Subscript(
        value=Name(id='data', ctx=Load()),
        slice=Constant(value='x'),
        ctx=Store()),
      annotation=Constant(value='turtle'),
      simple=0)],
  type_ignores=[])

What does this code mean? If it is, as I guess based on the AST, a type hint, does it have any practical use?

This comes from a combination of two features of type annotation syntax.

First, you can put a type hint after any expression that could syntactically be the target of an assignment. This includes identifiers (e.g. data), indexed expressions (e.g. data["teapot"]), attributes (e.g. data.teapot). It doesn't have to be an actual assignment; it's common to put type hints for variables at the beginning of a function or class, and fill in the value later.

Second, the type name can be a string literal, because this is used for forward references to types that haven't yet been defined. Forward references are needed when you have circular or recursive chains of type hints, to solve the chicken-and-egg problem.

So your example fits this case

data["teapot"]: "turtle"

It simply declares that the eventual value of data["teapot"] will be of the type named turtle, which may not yet be defined.

Type hint in python is a way to write python in a statically typed manner. It generally has little effect on the runtime (technically still used but rare). More often, you use it with a static type checker like mypy, pylint or PyCharm IDE.

Using quote is doing forward declaration. See also: https://stackoverflow.com/questions/46458470/should-you-put-quotes-around-type-annotations-in-python

Your code snippet is similar to the one here: https://stackoverflow.com/questions/74308012/type-hints-without-value-assignment-in-python. However, it does not seem to actually add any annotations:

a: int = 1
b: float
c = {}
c['foo']: str

print(__annotations__)
# results in
# {'a': <class 'int'>, 'b': <class 'float'>}

As for practical use, Pylint throws an error when checking, so this is probably not a standard syntax. Interstingly, expressions like 1+2+3: int or f(x): float results in SyntaxError: illegal target for annotation at runtime, but not in this case. I'm guessing it's possible for some static type checker to use this syntax to annotate individual elements in arrays and dictionaries.