def fix_function_overloads(self, stmts: List[Node]) -> List[Node]:
ret = [] # type: List[Node]
current_overload = []
current_overload_name = None
# mypy doesn't actually check that the decorator is literally @overload
for stmt in stmts:
if isinstance(stmt, Decorator) and stmt.name() == current_overload_name:
current_overload.append(stmt)
else:
if len(current_overload) == 1:
ret.append(current_overload[0])
elif len(current_overload) > 1:
ret.append(OverloadedFuncDef(current_overload))
if isinstance(stmt, Decorator):
current_overload = [stmt]
current_overload_name = stmt.name()
else:
current_overload = []
current_overload_name = None
ret.append(stmt)
if len(current_overload) == 1:
ret.append(current_overload[0])
elif len(current_overload) > 1:
ret.append(OverloadedFuncDef(current_overload))
return ret
def visit_overloaded_func_def(self, func: OverloadedFuncDef) -> None:
if self.sem.type is not None:
# Don't process methods during pass 1.
return
kind = self.kind_by_scope()
if kind == GDEF:
self.sem.check_no_global(func.name(), func, True)
func._fullname = self.sem.qualified_name(func.name())
if kind == GDEF:
self.sem.globals[func.name()] = SymbolTableNode(kind, func)
if func.impl:
impl = func.impl
# Also analyze the function body (in case there are conditional imports).
sem = self.sem
if isinstance(impl, FuncDef):
sem.function_stack.append(impl)
sem.scope.enter_function(func)
sem.enter()
impl.body.accept(self)
elif isinstance(impl, Decorator):
sem.function_stack.append(impl.func)
sem.scope.enter_function(func)
sem.enter()
impl.func.body.accept(self)
else:
assert False, "Implementation of an overload needs to be FuncDef or Decorator"
sem.leave()
sem.scope.leave()
sem.function_stack.pop()
def fix_function_overloads(self,
stmts: List[Statement]) -> List[Statement]:
ret: List[Statement] = []
current_overload: List[OverloadPart] = []
current_overload_name: Optional[str] = None
for stmt in stmts:
if (current_overload_name is not None
and isinstance(stmt, (Decorator, FuncDef))
and stmt.name == current_overload_name):
current_overload.append(stmt)
else:
if len(current_overload) == 1:
ret.append(current_overload[0])
elif len(current_overload) > 1:
ret.append(OverloadedFuncDef(current_overload))
if isinstance(stmt,
Decorator) and not unnamed_function(stmt.name):
current_overload = [stmt]
current_overload_name = stmt.name
else:
current_overload = []
current_overload_name = None
ret.append(stmt)
if len(current_overload) == 1:
ret.append(current_overload[0])
elif len(current_overload) > 1:
ret.append(OverloadedFuncDef(current_overload))
return ret
def visit_overloaded_func_def(self, func: OverloadedFuncDef) -> None:
if self.sem.type is not None:
# Don't process methods during pass 1.
return
kind = self.kind_by_scope()
if kind == GDEF:
self.sem.check_no_global(func.name(), func, True)
func._fullname = self.sem.qualified_name(func.name())
if kind == GDEF:
self.sem.globals[func.name()] = SymbolTableNode(kind, func)
if func.impl:
impl = func.impl
# Also analyze the function body (in case there are conditional imports).
sem = self.sem
if isinstance(impl, FuncDef):
sem.function_stack.append(impl)
sem.scope.enter_function(func)
sem.enter()
impl.body.accept(self)
elif isinstance(impl, Decorator):
sem.function_stack.append(impl.func)
sem.scope.enter_function(func)
sem.enter()
impl.func.body.accept(self)
else:
assert False, "Implementation of an overload needs to be FuncDef or Decorator"
sem.leave()
sem.scope.leave()
sem.function_stack.pop()
def visit_overloaded_func_def(self, node: OverloadedFuncDef) -> None:
if not self.recurse_into_functions:
return
# Revert change made during semantic analysis pass 2.
node.items = node.unanalyzed_items.copy()
node.is_final = False
super().visit_overloaded_func_def(node)
def visit_overloaded_func_def(self, node: OverloadedFuncDef) -> None:
if not self.recurse_into_functions:
return
# Revert change made during semantic analysis pass 2.
node.items = node.unanalyzed_items.copy()
node.is_final = False
super().visit_overloaded_func_def(node)
def fix_function_overloads(self,
stmts: List[Statement]) -> List[Statement]:
ret = [] # type: List[Statement]
current_overload = [] # type: List[OverloadPart]
current_overload_name = None
for stmt in stmts:
if (isinstance(stmt, Decorator)
and stmt.name() == current_overload_name):
current_overload.append(stmt)
elif (isinstance(stmt, FuncDef)
and stmt.name() == current_overload_name
and stmt.name() is not None):
ret.append(OverloadedFuncDef(current_overload + [stmt]))
current_overload = []
current_overload_name = None
else:
if len(current_overload) == 1:
ret.append(current_overload[0])
elif len(current_overload) > 1:
ret.append(OverloadedFuncDef(current_overload))
if isinstance(stmt, Decorator):
current_overload = [stmt]
current_overload_name = stmt.name()
else:
current_overload = []
current_overload_name = None
ret.append(stmt)
if len(current_overload) == 1:
ret.append(current_overload[0])
elif len(current_overload) > 1:
ret.append(OverloadedFuncDef(current_overload))
return ret
def visit_overloaded_func_def(self, node: OverloadedFuncDef) -> Node:
items = [self.visit_decorator(decorator) for decorator in node.items]
for newitem, olditem in zip(items, node.items):
newitem.line = olditem.line
new = OverloadedFuncDef(items)
new._fullname = node._fullname
new.type = self.type(node.type)
new.info = node.info
return new
def visit_overloaded_func_def(self, node: OverloadedFuncDef) -> Node:
items = [self.visit_decorator(decorator) for decorator in node.items]
for newitem, olditem in zip(items, node.items):
newitem.line = olditem.line
new = OverloadedFuncDef(items)
new._fullname = node._fullname
new.type = self.type(node.type)
new.info = node.info
return new
def visit_overloaded_func_def(self, node: OverloadedFuncDef) -> OverloadedFuncDef:
items = [cast(OverloadPart, item.accept(self)) for item in node.items]
for newitem, olditem in zip(items, node.items):
newitem.line = olditem.line
new = OverloadedFuncDef(items)
new._fullname = node._fullname
new.type = self.optional_type(node.type)
new.info = node.info
new.is_static = node.is_static
new.is_class = node.is_class
new.is_property = node.is_property
new.is_final = node.is_final
if node.impl:
new.impl = cast(OverloadPart, node.impl.accept(self))
return new
def visit_overloaded_func_def(self, o: OverloadedFuncDef) -> None:
if self.current_info is not None:
o.info = self.current_info
if o.type:
o.type.accept(self.type_fixer)
for item in o.items:
item.accept(self)
def visit_overloaded_func_def(self, o: OverloadedFuncDef) -> None:
if self.current_info is not None:
o.info = self.current_info
if o.type:
o.type.accept(self.type_fixer)
for item in o.items:
item.accept(self)
def visit_overloaded_func_def(self, node: OverloadedFuncDef) -> OverloadedFuncDef:
items = [cast(OverloadPart, item.accept(self)) for item in node.items]
for newitem, olditem in zip(items, node.items):
newitem.line = olditem.line
new = OverloadedFuncDef(items)
new._fullname = node._fullname
new.type = self.optional_type(node.type)
new.info = node.info
new.is_static = node.is_static
new.is_class = node.is_class
new.is_property = node.is_property
new.is_final = node.is_final
if node.impl:
new.impl = cast(OverloadPart, node.impl.accept(self))
return new
def visit_overloaded_func_def(
self, node: OverloadedFuncDef) -> OverloadedFuncDef:
items = [cast(OverloadPart, item.accept(self)) for item in node.items]
for newitem, olditem in zip(items, node.items):
newitem.line = olditem.line
new = OverloadedFuncDef(items)
new._fullname = node._fullname
new.type = self.type(node.type)
new.info = node.info
if node.impl:
new.impl = cast(OverloadPart, node.impl.accept(self))
return new
def visit_overloaded_func_def(self, node: OverloadedFuncDef) -> None:
if node.info:
node.info = self.fixup(node.info)
super().visit_overloaded_func_def(node)
