| from typing import Optional, Dict, Union |
| from mypy.types import TypeVarDef |
| from mypy.nodes import TypeVarExpr, SymbolTableNode |
| |
| |
| class TypeVarScope: |
| """Scope that holds bindings for type variables. Node fullname -> TypeVarDef.""" |
| |
| def __init__(self, |
| parent: 'Optional[TypeVarScope]' = None, |
| is_class_scope: bool = False, |
| prohibited: 'Optional[TypeVarScope]' = None) -> None: |
| """Initializer for TypeVarScope |
| |
| Parameters: |
| parent: the outer scope for this scope |
| is_class_scope: True if this represents a generic class |
| prohibited: Type variables that aren't strictly in scope exactly, |
| but can't be bound because they're part of an outer class's scope. |
| """ |
| self.scope = {} # type: Dict[str, TypeVarDef] |
| self.parent = parent |
| self.func_id = 0 |
| self.class_id = 0 |
| self.is_class_scope = is_class_scope |
| self.prohibited = prohibited |
| if parent is not None: |
| self.func_id = parent.func_id |
| self.class_id = parent.class_id |
| |
| def get_function_scope(self) -> 'Optional[TypeVarScope]': |
| """Get the nearest parent that's a function scope, not a class scope""" |
| it = self # type: Optional[TypeVarScope] |
| while it is not None and it.is_class_scope: |
| it = it.parent |
| return it |
| |
| def allow_binding(self, fullname: str) -> bool: |
| if fullname in self.scope: |
| return False |
| elif self.parent and not self.parent.allow_binding(fullname): |
| return False |
| elif self.prohibited and not self.prohibited.allow_binding(fullname): |
| return False |
| return True |
| |
| def method_frame(self) -> 'TypeVarScope': |
| """A new scope frame for binding a method""" |
| return TypeVarScope(self, False, None) |
| |
| def class_frame(self) -> 'TypeVarScope': |
| """A new scope frame for binding a class. Prohibits *this* class's tvars""" |
| return TypeVarScope(self.get_function_scope(), True, self) |
| |
| def bind_new(self, name: str, tvar_expr: TypeVarExpr) -> TypeVarDef: |
| if self.is_class_scope: |
| self.class_id += 1 |
| i = self.class_id |
| else: |
| self.func_id -= 1 |
| i = self.func_id |
| tvar_def = TypeVarDef(name, |
| tvar_expr.fullname(), |
| i, |
| values=tvar_expr.values, |
| upper_bound=tvar_expr.upper_bound, |
| variance=tvar_expr.variance, |
| line=tvar_expr.line, |
| column=tvar_expr.column) |
| self.scope[tvar_expr.fullname()] = tvar_def |
| return tvar_def |
| |
| def bind_existing(self, tvar_def: TypeVarDef) -> None: |
| self.scope[tvar_def.fullname] = tvar_def |
| |
| def get_binding(self, item: Union[str, SymbolTableNode]) -> Optional[TypeVarDef]: |
| fullname = item.fullname if isinstance(item, SymbolTableNode) else item |
| assert fullname is not None |
| if fullname in self.scope: |
| return self.scope[fullname] |
| elif self.parent is not None: |
| return self.parent.get_binding(fullname) |
| else: |
| return None |
| |
| def __str__(self) -> str: |
| me = ", ".join('{}: {}`{}'.format(k, v.name, v.id) for k, v in self.scope.items()) |
| if self.parent is None: |
| return me |
| return "{} <- {}".format(str(self.parent), me) |
