Ejemplo n.º 1
0
 def visit_none_type(self, t: NoneTyp) -> Type:
     if not isinstance(self.s, Void) and not isinstance(self.s, ErrorType):
         return t
     else:
         return ErrorType()
Ejemplo n.º 2
0
 def visit_void(self, t: Void) -> Type:
     if isinstance(self.s, Void):
         return t
     else:
         return ErrorType()
Ejemplo n.º 3
0
    def __init__(self, variance: int = COVARIANT) -> None:
        # The 'object' class
        self.oi = self.make_type_info('builtins.object')  # class object
        self.o = Instance(self.oi, [])  # object

        # Type variables (these are effectively global)

        def make_type_var(name: str, id: int, values: List[Type],
                          upper_bound: Type, variance: int) -> TypeVarType:
            return TypeVarType(
                TypeVarDef(name, id, values, upper_bound, variance))

        self.t = make_type_var('T', 1, [], self.o,
                               variance)  # T`1 (type variable)
        self.tf = make_type_var('T', -1, [], self.o,
                                variance)  # T`-1 (type variable)
        self.tf2 = make_type_var('T', -2, [], self.o,
                                 variance)  # T`-2 (type variable)
        self.s = make_type_var('S', 2, [], self.o,
                               variance)  # S`2 (type variable)
        self.s1 = make_type_var('S', 1, [], self.o,
                                variance)  # S`1 (type variable)
        self.sf = make_type_var('S', -2, [], self.o,
                                variance)  # S`-2 (type variable)
        self.sf1 = make_type_var('S', -1, [], self.o,
                                 variance)  # S`-1 (type variable)

        # Simple types
        self.anyt = AnyType()
        self.err = ErrorType()
        self.nonet = NoneTyp()
        self.uninhabited = UninhabitedType()

        # Abstract class TypeInfos

        # class F
        self.fi = self.make_type_info('F', is_abstract=True)

        # class F2
        self.f2i = self.make_type_info('F2', is_abstract=True)

        # class F3(F)
        self.f3i = self.make_type_info('F3', is_abstract=True, mro=[self.fi])

        # Class TypeInfos
        self.std_tuplei = self.make_type_info('builtins.tuple')  # class tuple
        self.type_typei = self.make_type_info('builtins.type')  # class type
        self.functioni = self.make_type_info(
            'builtins.function')  # function TODO
        self.ai = self.make_type_info('A', mro=[self.oi])  # class A
        self.bi = self.make_type_info('B', mro=[self.ai,
                                                self.oi])  # class B(A)
        self.ci = self.make_type_info('C', mro=[self.ai,
                                                self.oi])  # class C(A)
        self.di = self.make_type_info('D', mro=[self.oi])  # class D
        # class E(F)
        self.ei = self.make_type_info('E', mro=[self.fi, self.oi])
        # class E2(F2, F)
        self.e2i = self.make_type_info('E2', mro=[self.f2i, self.fi, self.oi])
        # class E3(F, F2)
        self.e3i = self.make_type_info('E3', mro=[self.fi, self.f2i, self.oi])

        # Generic class TypeInfos
        # G[T]
        self.gi = self.make_type_info('G',
                                      mro=[self.oi],
                                      typevars=['T'],
                                      variances=[variance])
        # G2[T]
        self.g2i = self.make_type_info('G2',
                                       mro=[self.oi],
                                       typevars=['T'],
                                       variances=[variance])
        # H[S, T]
        self.hi = self.make_type_info('H',
                                      mro=[self.oi],
                                      typevars=['S', 'T'],
                                      variances=[variance, variance])
        # GS[T, S] <: G[S]
        self.gsi = self.make_type_info('GS',
                                       mro=[self.gi, self.oi],
                                       typevars=['T', 'S'],
                                       variances=[variance, variance],
                                       bases=[Instance(self.gi, [self.s])])
        # GS2[S] <: G[S]
        self.gs2i = self.make_type_info('GS2',
                                        mro=[self.gi, self.oi],
                                        typevars=['S'],
                                        variances=[variance],
                                        bases=[Instance(self.gi, [self.s1])])
        # list[T]
        self.std_listi = self.make_type_info('builtins.list',
                                             mro=[self.oi],
                                             typevars=['T'],
                                             variances=[variance])

        # Instance types
        self.std_tuple = Instance(self.std_tuplei, [])  # tuple
        self.type_type = Instance(self.type_typei, [])  # type
        self.function = Instance(self.functioni, [])  # function TODO
        self.a = Instance(self.ai, [])  # A
        self.b = Instance(self.bi, [])  # B
        self.c = Instance(self.ci, [])  # C
        self.d = Instance(self.di, [])  # D

        self.e = Instance(self.ei, [])  # E
        self.e2 = Instance(self.e2i, [])  # E2
        self.e3 = Instance(self.e3i, [])  # E3

        self.f = Instance(self.fi, [])  # F
        self.f2 = Instance(self.f2i, [])  # F2
        self.f3 = Instance(self.f3i, [])  # F3

        # Generic instance types
        self.ga = Instance(self.gi, [self.a])  # G[A]
        self.gb = Instance(self.gi, [self.b])  # G[B]
        self.gd = Instance(self.gi, [self.d])  # G[D]
        self.go = Instance(self.gi, [self.o])  # G[object]
        self.gt = Instance(self.gi, [self.t])  # G[T`1]
        self.gtf = Instance(self.gi, [self.tf])  # G[T`-1]
        self.gtf2 = Instance(self.gi, [self.tf2])  # G[T`-2]
        self.gs = Instance(self.gi, [self.s])  # G[S]
        self.gdyn = Instance(self.gi, [self.anyt])  # G[Any]

        self.g2a = Instance(self.g2i, [self.a])  # G2[A]

        self.gsaa = Instance(self.gsi, [self.a, self.a])  # GS[A, A]
        self.gsab = Instance(self.gsi, [self.a, self.b])  # GS[A, B]
        self.gsba = Instance(self.gsi, [self.b, self.a])  # GS[B, A]

        self.gs2a = Instance(self.gs2i, [self.a])  # GS2[A]
        self.gs2b = Instance(self.gs2i, [self.b])  # GS2[B]
        self.gs2d = Instance(self.gs2i, [self.d])  # GS2[D]

        self.hab = Instance(self.hi, [self.a, self.b])  # H[A, B]
        self.haa = Instance(self.hi, [self.a, self.a])  # H[A, A]
        self.hbb = Instance(self.hi, [self.b, self.b])  # H[B, B]
        self.hts = Instance(self.hi, [self.t, self.s])  # H[T, S]
        self.had = Instance(self.hi, [self.a, self.d])  # H[A, D]

        self.lsta = Instance(self.std_listi, [self.a])  # List[A]
        self.lstb = Instance(self.std_listi, [self.b])  # List[B]

        self.type_a = TypeType(self.a)
        self.type_b = TypeType(self.b)
        self.type_c = TypeType(self.c)
        self.type_d = TypeType(self.d)
        self.type_t = TypeType(self.t)
        self.type_any = TypeType(self.anyt)
Ejemplo n.º 4
0
 def visit_uninhabited_type(self, t: UninhabitedType) -> Type:
     if not isinstance(self.s, Void) and not isinstance(self.s, ErrorType):
         return t
     else:
         return ErrorType()
Ejemplo n.º 5
0
 def visit_unbound_type(self, t: UnboundType) -> Type:
     if isinstance(self.s, Void) or isinstance(self.s, ErrorType):
         return ErrorType()
     else:
         return AnyType()
Ejemplo n.º 6
0
    def __init__(self):
        # The 'object' class
        self.oi = self.make_type_info('builtins.object')  # class object
        self.o = Instance(self.oi, [])  # object

        # Type variables
        self.t = TypeVar('T', 1, [], self.o)  # T`1 (type variable)
        self.tf = TypeVar('T', -1, [], self.o)  # T`-1 (type variable)
        self.tf2 = TypeVar('T', -2, [], self.o)  # T`-2 (type variable)
        self.s = TypeVar('S', 2, [], self.o)  # S`2 (type variable)
        self.s1 = TypeVar('S', 1, [], self.o)  # S`1 (type variable)
        self.sf = TypeVar('S', -2, [], self.o)  # S`-2 (type variable)
        self.sf1 = TypeVar('S', -1, [], self.o)  # S`-1 (type variable)

        # Simple types
        self.anyt = AnyType()
        self.void = Void()
        self.err = ErrorType()
        self.nonet = NoneTyp()

        # Abstract class TypeInfos

        # class F
        self.fi = self.make_type_info('F', is_abstract=True)

        # class F2
        self.f2i = self.make_type_info('F2', is_abstract=True)

        # class F3(F)
        self.f3i = self.make_type_info('F3', is_abstract=True, mro=[self.fi])

        # Class TypeInfos
        self.std_tuplei = self.make_type_info('builtins.tuple')  # class tuple
        self.type_typei = self.make_type_info('builtins.type')  # class type
        self.std_functioni = self.make_type_info(
            'builtins.function')  # function TODO
        self.ai = self.make_type_info('A', mro=[self.oi])  # class A
        self.bi = self.make_type_info('B', mro=[self.ai,
                                                self.oi])  # class B(A)
        self.ci = self.make_type_info('C', mro=[self.ai,
                                                self.oi])  # class C(A)
        self.di = self.make_type_info('D', mro=[self.oi])  # class D
        # class E(F)
        self.ei = self.make_type_info('E', mro=[self.fi, self.oi])
        # class E2(F2, F)
        self.e2i = self.make_type_info('E2', mro=[self.f2i, self.fi, self.oi])
        # class E3(F, F2)
        self.e3i = self.make_type_info('E3', mro=[self.fi, self.f2i, self.oi])

        # Generic class TypeInfos
        # G[T]
        self.gi = self.make_type_info('G', mro=[self.oi], typevars=['T'])
        # G2[T]
        self.g2i = self.make_type_info('G2', mro=[self.oi], typevars=['T'])
        # H[S, T]
        self.hi = self.make_type_info('H', mro=[self.oi], typevars=['S', 'T'])
        # GS[T, S] <: G[S]
        self.gsi = self.make_type_info('GS',
                                       mro=[self.gi, self.oi],
                                       typevars=['T', 'S'],
                                       bases=[Instance(self.gi, [self.s])])
        # GS2[S] <: G[S]
        self.gs2i = self.make_type_info('GS2',
                                        mro=[self.gi, self.oi],
                                        typevars=['S'],
                                        bases=[Instance(self.gi, [self.s1])])
        # list[T]
        self.std_listi = self.make_type_info('builtins.list',
                                             mro=[self.oi],
                                             typevars=['T'])

        # Instance types
        self.std_tuple = Instance(self.std_tuplei, [])  # tuple
        self.type_type = Instance(self.type_typei, [])  # type
        self.std_function = Instance(self.std_functioni, [])  # function TODO
        self.a = Instance(self.ai, [])  # A
        self.b = Instance(self.bi, [])  # B
        self.c = Instance(self.ci, [])  # C
        self.d = Instance(self.di, [])  # D

        self.e = Instance(self.ei, [])  # E
        self.e2 = Instance(self.e2i, [])  # E2
        self.e3 = Instance(self.e3i, [])  # E3

        self.f = Instance(self.fi, [])  # F
        self.f2 = Instance(self.f2i, [])  # F2
        self.f3 = Instance(self.f3i, [])  # F3

        # Generic instance types
        self.ga = Instance(self.gi, [self.a])  # G[A]
        self.gb = Instance(self.gi, [self.b])  # G[B]
        self.go = Instance(self.gi, [self.o])  # G[object]
        self.gt = Instance(self.gi, [self.t])  # G[T`1]
        self.gtf = Instance(self.gi, [self.tf])  # G[T`-1]
        self.gtf2 = Instance(self.gi, [self.tf2])  # G[T`-2]
        self.gs = Instance(self.gi, [self.s])  # G[S]
        self.gdyn = Instance(self.gi, [self.anyt])  # G[Any]

        self.g2a = Instance(self.g2i, [self.a])  # G2[A]

        self.gsab = Instance(self.gsi, [self.a, self.b])  # GS[A, B]
        self.gsba = Instance(self.gsi, [self.b, self.a])  # GS[B, A]

        self.gs2a = Instance(self.gs2i, [self.a])  # GS2[A]

        self.hab = Instance(self.hi, [self.a, self.b])  # H[A, B]
        self.haa = Instance(self.hi, [self.a, self.a])  # H[A, A]
        self.hbb = Instance(self.hi, [self.b, self.b])  # H[B, B]
        self.hts = Instance(self.hi, [self.t, self.s])  # H[T, S]

        self.lsta = Instance(self.std_listi, [self.a])  # List[A]
        self.lstb = Instance(self.std_listi, [self.b])  # List[B]