def find_duplicates_without_smart_filter(all_blocks): duplicates = [] seen_blocks = {} for _, block in all_blocks: tokens = tokens_info(block) if tokens in seen_blocks: duplicates.append((seen_blocks[tokens], block, "")) else: seen_blocks[tokens] = block return duplicates
def has_same_tests(expr): """ For an if-statement or an if-expression, checks whether any combination of its tests are syntactically equivalent. If duplicate operands are found, return them. :rtype: lal.Expr|None """ tests = {} all_tests = list_tests(expr) if len(all_tests) > 1: for test in all_tests: tokens = tokens_info(test) if tokens in tests: return (tests[tokens], test) tests[tokens] = test
def has_same_operands(expr): """ For a logic relation, checks whether any combination of its sub-operands are syntactically equivalent. If duplicate operands are found, return them. :rtype: lal.Expr|None """ ops = {} all_ops = list_operands(expr) if len(all_ops) > 1: for op in all_ops: tokens = tokens_info(op) if tokens in ops: return (ops[tokens], op) ops[tokens] = op
def has_same_operands(expr): """ For a logic relation, checks whether any combination of its sub-operands are syntactically equivalent. If a duplicate operand is found, return it. :rtype: lal.Expr|None """ ops = {} all_ops = list_left_unequal_operands(expr) if len(all_ops) > 1: for op in all_ops: (op_left, op_right) = op tokens = tokens_info(op_left) if tokens in ops: return (op_left, ops[tokens], op_right) ops[tokens] = op_right
def find_duplicates_with_smart_filter(all_blocks): duplicates = [] seen_blocks = {} for cond, block in all_blocks: # Find interesting elements in the condition that leads to this # block. cond_interests = interesting_elements_in(cond) block_tokens = tokens_info(block) block_info = seen_blocks.get(block_tokens) if block_info is not None: # If we have seen this block already # Retrieve the interesting elements in the condition that lead # to the original block. orig_cond_interests, block_interests, orig_block = block_info # Compute the symmetric difference between the two sets of # interesting elements (get those that are in one of them but # not in both). interests_diff = orig_cond_interests.symmetric_difference( cond_interests) # Try to find in the block itself occurrences of the # interesting elements that appear only in one of the # conditions. block_occurrences = frozenset(e for e in block_interests if e in interests_diff) # This may mean that one of the two blocks was not updated # properly, so register it. if len(block_occurrences) > 0: # Compute the set of interesting elements that appear # in one of the condition but not in the duplicated block. unused_elems = interests_diff - block_occurrences if len(unused_elems) == 1: # If there is only one, maybe the user forgot to use # that variable in the block where this element appears # in the condition. # Retrieve the sole element and create the message. unused_elem = next(iter(unused_elems)) msg = _additional_msg_format.format(unused_elem) if unused_elem in orig_cond_interests: # If the unused element appears in the condition # of the first block, that means the first block # is probably the duplicate. duplicates.append((block, orig_block, msg)) else: # If the unused element appears in the condition # of the second block, that means the second block # is probably the duplicate. duplicates.append((orig_block, block, msg)) else: duplicates.append((orig_block, block, "")) else: seen_blocks[block_tokens] = (cond_interests, interesting_elements_in(block), block) return duplicates