New semantic analyzer: Clean-up logic for classes in functions

[ilevkivskyi]

While working on #6421 I looked again at logic for storing symbols for local (function- or method-level) classes in prepare_class_def(). The logic is too ad-hoc and needs to be cleaned up. Here are some points that should be fixed:

• defn.fullname and info.fullname() should always coincide
• info.fullname() prefix should coincide with the symbol table where the info is actually stored (for serialization)
• things should work for double nested classes
• things should work in fine-grained mode

I think the logic should be as following. Consider this example:

class Out:
    def meth(self) -> None:
        class In:
            def meth(self) -> None:
                class C: pass

The class C should be stored in its local namespace under name 'C'. In addition it should be stored in the namespace of __main__.Out under name 'C@5'. info.fullname() and defn.fullname should be both '__main__.Out.C@5'.

[MatthieuDartiailh]

What is the current status of this ? I saw that a couple of PRs addressed part of the issue but #7281 is not fixed and I am wondering how much of the initial comment still applies after three PR related to this issue. I added typing to a project but this issue will prevent downstream package to benefit of it so I may be interested in helping.

[MatthieuDartiailh]

Also how should the system behaves for a class defined in a function ? Should the symbol be stored on the function or at the global level ?

[JukkaL]

I'm not sure if anybody is up to date on what still needs to be done (if anything). To get started with this, you could try to document the current behavior and then we can discuss how it might need to be modified.

[MatthieuDartiailh]

Thanks @JukkaL ! Any pointer on the best way to inspect mypy internal after parsing a file, I am new to mypy internals ?

[MatthieuDartiailh]

I inspected the nodes stored in the result object returned by mypy.build.build run on the following example(using mypy at 05571b1, point at which I cloned the repo):

from collections import namedtuple

class A:
    pass


def make_class() -> type:
    class Inner:
        pass

    return Inner


B = make_class()


class Out:
    def meth(self) -> type:
        class In:
            def meth(self) -> type:
                class C(namedtuple("_C", ("a")), A): pass
                return C

        return In

D = Out().meth()

E = Out().meth()().meth()

I see that the following is true:

• defn.name is always the class short name
• defn.fullname is always the fully qualified name including the line number for nested classes
• those matches what is found on the node

I am not sure where to look for the info and to figure out where things are stored, since there was a concern of global storage vs storage on the surrounding class. Any pointer appreciated.