overlay[local]

module;

import python

/** The base class for operators */

class Operator extends Operator_ {

/** Gets the name of the special method used to implement this operator */

string getSpecialMethodName() { none() }

}

/* Unary Expression and its operators */

/** A unary expression: (`+x`), (`-x`) or (`~x`) */

class UnaryExpr extends UnaryExpr_ {

override Expr getASubExpression() { result = this.getOperand() }

}

/** A unary operator: `+`, `-`, `~` or `not` */

class Unaryop extends Unaryop_ {

/** Gets the name of the special method used to implement this operator */

string getSpecialMethodName() { none() }

}

/** An invert (`~`) unary operator */

class Invert extends Invert_ {

override string getSpecialMethodName() { result = "__invert__" }

}

/** A positive (`+`) unary operator */

class UAdd extends UAdd_ {

override string getSpecialMethodName() { result = "__pos__" }

}

/** A negation (`-`) unary operator */

class USub extends USub_ {

override string getSpecialMethodName() { result = "__neg__" }

}

/** A `not` unary operator */

class Not extends Not_ {

override string getSpecialMethodName() { none() }

}

/* Binary Operation and its operators */

/** A binary expression, such as `x + y` */

class BinaryExpr extends BinaryExpr_ {

override Expr getASubExpression() { result = this.getLeft() or result = this.getRight() }

}

/** A power (`**`) binary operator */

class Pow extends Pow_ {

override string getSpecialMethodName() { result = "__pow__" }

}

/** A right shift (`>>`) binary operator */

class RShift extends RShift_ {

override string getSpecialMethodName() { result = "__rshift__" }

}

/** A subtract (`-`) binary operator */

class Sub extends Sub_ {

override string getSpecialMethodName() { result = "__sub__" }

}

/** A bitwise and (`&`) binary operator */

class BitAnd extends BitAnd_ {

override string getSpecialMethodName() { result = "__and__" }

}

/** A bitwise or (`|`) binary operator */

class BitOr extends BitOr_ {

override string getSpecialMethodName() { result = "__or__" }

}

/** A bitwise exclusive-or (`^`) binary operator */

class BitXor extends BitXor_ {

override string getSpecialMethodName() { result = "__xor__" }

}

/** An add (`+`) binary operator */

class Add extends Add_ {

override string getSpecialMethodName() { result = "__add__" }

}

/** An (true) divide (`/`) binary operator */

class Div extends Div_ {

override string getSpecialMethodName() {

result = "__truediv__"

or

major_version() = 2 and result = "__div__"

}

}

/** An floor divide (`//`) binary operator */

class FloorDiv extends FloorDiv_ {

override string getSpecialMethodName() { result = "__floordiv__" }

}

/** A left shift (`<<`) binary operator */

class LShift extends LShift_ {

override string getSpecialMethodName() { result = "__lshift__" }

}

/** A modulo (`%`) binary operator, which includes string formatting */

class Mod extends Mod_ {

override string getSpecialMethodName() { result = "__mod__" }

}

/** A multiplication (`*`) binary operator */

class Mult extends Mult_ {

override string getSpecialMethodName() { result = "__mul__" }

}

/** A matrix multiplication (`@`) binary operator */

class MatMult extends MatMult_ {

override string getSpecialMethodName() { result = "__matmul__" }

}

/* Comparison Operation and its operators */

/** A comparison operation, such as `x<y` */

class Compare extends Compare_ {

override Expr getASubExpression() { result = this.getLeft() or result = this.getAComparator() }

/**

* Whether as part of this comparison 'left' is compared with 'right' using the operator 'op'.

* For example, the comparison `a<b<c` compares(`a`, `b`, `<`) and compares(`b`, `c`, `<`).

*/

predicate compares(Expr left, Cmpop op, Expr right) {

this.getLeft() = left and this.getComparator(0) = right and op = this.getOp(0)

or

exists(int n |

this.getComparator(n) = left and this.getComparator(n + 1) = right and op = this.getOp(n + 1)

)

}

}

/** A list of comparison operators in a comparison */

class CmpopList extends CmpopList_ { }

/** A comparison operator */

abstract class Cmpop extends Cmpop_ {

string getSymbol() { none() }

string getSpecialMethodName() { none() }

}

/** A greater than (`>`) comparison operator */

class Gt extends Gt_ {

override string getSymbol() { result = ">" }

override string getSpecialMethodName() { result = "__gt__" }

}

/** A greater than or equals (`>=`) comparison operator */

class GtE extends GtE_ {

override string getSymbol() { result = ">=" }

override string getSpecialMethodName() { result = "__ge__" }

}

/** An `in` comparison operator */

class In extends In_ {

override string getSymbol() { result = "in" }

}

/** An `is` comparison operator */

class Is extends Is_ {

override string getSymbol() { result = "is" }

}

/** An `is not` comparison operator */

class IsNot extends IsNot_ {

override string getSymbol() { result = "is not" }

}

/** An equals (`==`) comparison operator */

class Eq extends Eq_ {

override string getSymbol() { result = "==" }

override string getSpecialMethodName() { result = "__eq__" }

}

/** A less than (`<`) comparison operator */

class Lt extends Lt_ {

override string getSymbol() { result = "<" }

override string getSpecialMethodName() { result = "__lt__" }

}

/** A less than or equals (`<=`) comparison operator */

class LtE extends LtE_ {

override string getSymbol() { result = "<=" }

override string getSpecialMethodName() { result = "__le__" }

}

/** A not equals (`!=`) comparison operator */

class NotEq extends NotEq_ {

override string getSymbol() { result = "!=" }

override string getSpecialMethodName() { result = "__ne__" }

}

/** An `not in` comparison operator */

class NotIn extends NotIn_ {

override string getSymbol() { result = "not in" }

}

/* Boolean Operation (and/or) and its operators */

/** A boolean shortcut (and/or) operation */

class BoolExpr extends BoolExpr_ {

override Expr getASubExpression() { result = this.getAValue() }

string getOperator() {

this.getOp() instanceof And and result = "and"

or

this.getOp() instanceof Or and result = "or"

}

/** Whether part evaluates to partIsTrue if this evaluates to wholeIsTrue */

predicate impliesValue(Expr part, boolean partIsTrue, boolean wholeIsTrue) {

if this.getOp() instanceof And

then (

wholeIsTrue = true and partIsTrue = true and part = this.getAValue()

or

wholeIsTrue = true and this.getAValue().(BoolExpr).impliesValue(part, partIsTrue, true)

) else (

wholeIsTrue = false and partIsTrue = false and part = this.getAValue()

or

wholeIsTrue = false and this.getAValue().(BoolExpr).impliesValue(part, partIsTrue, false)

)

}

}

/** A short circuit boolean operator, and/or */

class Boolop extends Boolop_ { }

/** An `and` boolean operator */

class And extends And_ { }

/** An `or` boolean operator */

class Or extends Or_ { }