Python L.detuplify方法代码示例

# 需要导入模块: from incoq.compiler.incast import L [as 别名]
# 或者: from incoq.compiler.incast.L import detuplify [as 别名]
 def is_join(self, comp):
     lhs_vars = self.lhs_vars_from_clauses(comp.clauses)
     try:
         res_vars = L.detuplify(comp.resexp)
     except ValueError:
         return False
     return sorted(res_vars) == sorted(lhs_vars)

# 需要导入模块: from incoq.compiler.incast import L [as 别名]
# 或者: from incoq.compiler.incast.L import detuplify [as 别名]
 def visit_DictLookup(self, node):
     node = self.generic_visit(node)
     
     # Only simple map lookups are allowed.
     assert isinstance(node.value, L.Name)
     assert L.is_tuple_of_names(node.key)
     assert node.default is None
     map = node.value.id
     keyvars = L.detuplify(node.key)
     
     var = self.repls.get(node, None)
     if var is None:
         mask = L.mapmask_from_len(len(keyvars))
         rel = N.SA_name(map, mask)
         
         # Create a fresh variable.
         self.repls[node] = var = next(self.fresh_names)
         
         # Construct a clause to bind it.
         vars = list(keyvars) + [var]
         new_clause = L.SetFromMapMember(vars, rel, map, mask)
         self.new_clauses.append(new_clause)
         
         # Construct a corresponding SetFromMap invariant.
         sfm = SetFromMapInvariant(rel, map, mask)
         self.sfm_invs.add(sfm)
     
     return L.Name(var)

# 需要导入模块: from incoq.compiler.incast import L [as 别名]
# 或者: from incoq.compiler.incast.L import detuplify [as 别名]
 def visit_Member(self, node):
     # For clauses that wrap around another clause, like
     # WithoutMember, reorient the target and iter before recursing.
     handled = False
     
     # <target> in <expr> - {<elem>}
     if (isinstance(node.iter, L.BinOp) and
         isinstance(node.iter.op, L.Sub) and
         isinstance(node.iter.right, L.Set) and
         len(node.iter.right.elts) == 1):
         inner_clause = L.Member(node.target, node.iter.left)
         node = L.WithoutMember(inner_clause, node.iter.right.elts[0])
         handled = True
     
     node = self.generic_visit(node)
     if handled:
         return node
     
     # <vars> in {<elem>}
     if (L.is_tuple_of_names(node.target) and
         isinstance(node.iter, L.Set) and
         len(node.iter.elts) == 1):
         return L.SingMember(L.detuplify(node.target),
                             node.iter.elts[0])
     
     return node

# 需要导入模块: from incoq.compiler.incast import L [as 别名]
# 或者: from incoq.compiler.incast.L import detuplify [as 别名]
 def visit_Member(self, node):
     node = self.generic_visit(node)
     
     if (L.is_tuple_of_names(node.target) and
         isinstance(node.iter, L.Query)):
         node = L.VarsMember(L.detuplify(node.target), node.iter)
     
     return node

# 需要导入模块: from incoq.compiler.incast import L [as 别名]
# 或者: from incoq.compiler.incast.L import detuplify [as 别名]
 def Tuple_helper(self, node):
     if not L.is_tuple_of_names(node):
         raise L.ProgramError('Non-simple tuple expression: {}'
                              .format(node))
     elts = L.detuplify(node)
     
     name = self.tuple_namer(elts)
     clause = L.TUPMember(name, elts)
     self.objrels.TUPs.append(len(elts))
     self.after_clauses.insert(0, clause)
     return name

# 需要导入模块: from incoq.compiler.incast import L [as 别名]
# 或者: from incoq.compiler.incast.L import detuplify [as 别名]
 def visit_DecompFor(self, node):
     ct = self.clausetools
     
     node = super().generic_visit(node)
     
     # Skip if the RHS isn't a comprehension query for which
     # expansion was requested.
     if not (isinstance(node.iter, L.Query) and
             node.iter.name in self.queries and
             isinstance(node.iter.query, L.Comp)):
         return node
     comp = node.iter.query
     
     # Check that it's a join and the variables match the loop target.
     if not (ct.is_join(comp) and
             L.detuplify(comp.resexp) == node.vars):
         return node
     
     return ct.get_code_for_clauses(comp.clauses, (), node.body)