def and_builder(left: cst.BaseExpression, right: cst.BaseExpression) -> cst.BooleanOperation: return cst.BooleanOperation( left=left, operator=cst.And(), right=right, )
def visit_BooleanOperation(self, node: cst.BooleanOperation) -> None: if node in self.seen_boolean_operations: return None stack = tuple(self.unwrap(node)) operands, targets = self.collect_targets(stack) # If nothing gets collapsed, just exit from this short-path if len(operands) == len(stack): return None replacement = None for operand in operands: if operand in targets: matches = targets[operand] if len(matches) == 1: arg = cst.Arg(value=matches[0]) else: arg = cst.Arg(cst.Tuple([cst.Element(match) for match in matches])) operand = cst.Call(cst.Name("isinstance"), [cst.Arg(operand), arg]) if replacement is None: replacement = operand else: replacement = cst.BooleanOperation( left=replacement, right=operand, operator=cst.Or() ) if replacement is not None: self.report(node, replacement=replacement)
def boolean_op_with_whitespace(draw): # type: ignore # for BooleanOperation, some expressions require whitespace before # and/or after e.g. a or b whereas (1)or(2) is OK. left = draw(st.from_type(libcst.BaseExpression)) right = draw(st.from_type(libcst.BaseExpression)) op = draw(st.from_type(libcst.BaseBooleanOp)) if op.whitespace_before.empty and not left._safe_to_use_with_word_operator( ExpressionPosition.LEFT): # pragma: no cover op = op.with_changes(whitespace_before=libcst.SimpleWhitespace(" ")) if op.whitespace_after.empty and not right._safe_to_use_with_word_operator( ExpressionPosition.RIGHT): # pragma: no cover op = op.with_changes(whitespace_after=libcst.SimpleWhitespace(" ")) return libcst.BooleanOperation(left, op, right)
class BooleanOperationTest(CSTNodeTest): @data_provider( ( # Simple boolean operations # pyre-fixme[6]: Incompatible parameter type { "node": cst.BooleanOperation( cst.Name("foo"), cst.And(), cst.Name("bar") ), "code": "foo and bar", "parser": parse_expression, "expected_position": None, }, { "node": cst.BooleanOperation( cst.Name("foo"), cst.Or(), cst.Name("bar") ), "code": "foo or bar", "parser": parse_expression, "expected_position": None, }, # Parenthesized boolean operation { "node": cst.BooleanOperation( lpar=(cst.LeftParen(),), left=cst.Name("foo"), operator=cst.Or(), right=cst.Name("bar"), rpar=(cst.RightParen(),), ), "code": "(foo or bar)", "parser": parse_expression, "expected_position": None, }, { "node": cst.BooleanOperation( left=cst.Name( "foo", lpar=(cst.LeftParen(),), rpar=(cst.RightParen(),) ), operator=cst.Or( whitespace_before=cst.SimpleWhitespace(""), whitespace_after=cst.SimpleWhitespace(""), ), right=cst.Name( "bar", lpar=(cst.LeftParen(),), rpar=(cst.RightParen(),) ), ), "code": "(foo)or(bar)", "parser": parse_expression, "expected_position": CodeRange.create((1, 0), (1, 12)), }, # Make sure that spacing works { "node": cst.BooleanOperation( lpar=(cst.LeftParen(whitespace_after=cst.SimpleWhitespace(" ")),), left=cst.Name("foo"), operator=cst.And( whitespace_before=cst.SimpleWhitespace(" "), whitespace_after=cst.SimpleWhitespace(" "), ), right=cst.Name("bar"), rpar=(cst.RightParen(whitespace_before=cst.SimpleWhitespace(" ")),), ), "code": "( foo and bar )", "parser": parse_expression, "expected_position": None, }, ) ) def test_valid(self, **kwargs: Any) -> None: self.validate_node(**kwargs) @data_provider( ( { "get_node": lambda: cst.BooleanOperation( cst.Name("foo"), cst.And(), cst.Name("bar"), lpar=(cst.LeftParen(),) ), "expected_re": "left paren without right paren", }, { "get_node": lambda: cst.BooleanOperation( cst.Name("foo"), cst.And(), cst.Name("bar"), rpar=(cst.RightParen(),), ), "expected_re": "right paren without left paren", }, { "get_node": lambda: cst.BooleanOperation( left=cst.Name("foo"), operator=cst.Or( whitespace_before=cst.SimpleWhitespace(""), whitespace_after=cst.SimpleWhitespace(""), ), right=cst.Name("bar"), ), "expected_re": "at least one space around boolean operator", }, ) ) def test_invalid(self, **kwargs: Any) -> None: self.assert_invalid(**kwargs)