def __init__(self, scc, **kwds):
super(StronglyConnectedCircularType, self).__init__(None, **kwds)
self.scc = scc
types = oset.OrderedSet(scc)
for type in scc:
self.add_children(type.children - types)
self.add_parents(type.parents - types)
self.types = scc
self.promotions = oset.OrderedSet(type for type in scc
if type.is_promotion)
self.reanalyzeable = oset.OrderedSet(type for type in scc
if type.is_reanalyze_circular)
def find_types(self, seen):
types = oset.OrderedSet([self])
seen.add(self)
seen.add(self.variable.deferred_type)
self.dfs(types, seen)
types.remove(self)
return types
def find_simple(self, seen):
types = oset.OrderedSet()
for type in self.types:
if type.is_promotion:
types.add(type.types)
else:
type.add(type)
return types
def __init__(self, variable, promote, types, assignment=False, **kwds):
super(PromotionType, self).__init__(variable, **kwds)
self.promote = promote
self.types = oset.OrderedSet(types)
self.assignment = assignment
variable.type = self
self.add_parents(type for type in types if type.is_unresolved)
self.count = PromotionType.count
PromotionType.count += 1
def _simplify(self, seen=None):
"""
Simplify a promotion type tree:
promote(int_, float_)
-> float_
promote(deferred(x), promote(float_, double), int_, promote(<self>))
-> promote(deferred(x), double)
promote(deferred(x), deferred(y))
-> promote(deferred(x), deferred(y))
"""
if seen is None:
seen = set()
# Find all types in the type graph and eliminate nested promotion types
types = self.find_types(seen)
# types = self.find_simple(seen)
resolved_types = [type for type in types if not type.is_unresolved]
unresolved_types = [type for type in types if type.is_unresolved]
self.get_partial_types(unresolved_types)
self.variable.type = self
if not resolved_types:
# Everything is deferred
self.resolved_type = None
return False
else:
# Simplify as much as possible
if self.assignment:
result_type, unresolved_types = promote_for_assignment(
self.promote, resolved_types, unresolved_types,
self.variable.name)
else:
result_type = promote_for_arithmetic(self.promote,
resolved_types)
self.resolved_type = result_type
if len(resolved_types) == len(types) or not unresolved_types:
self.variable.type = result_type
return True
else:
old_types = self.types
self.types = oset.OrderedSet([result_type] + unresolved_types)
return old_types != self.types
def kosaraju_strongly_connected(start_type, strongly_connected, seen):
"""
Find the strongly connected components in the connected graph starting at
start_type.
"""
stack = []
dfs(start_type, stack, set(seen))
seen = set(seen)
graph = oset.OrderedSet(stack)
while stack:
start = stack[-1]
scc = []
dfs(start, scc, seen, graph, parents=True)
if len(scc) > 1:
scc_type = StronglyConnectedCircularType(scc)
for type in scc_type.types:
strongly_connected[type] = scc_type
stack.pop()
else:
strongly_connected[scc[0]] = scc[0]
stack.pop()
def __init__(self, variable, **kwds):
super(UnresolvedType, self).__init__(**kwds)
self.variable = variable
self.assertions = []
self.parents = oset.OrderedSet()
self.children = oset.OrderedSet()