Merge pull request #2894 from BekaValentine/python-objectapi-to-valueapi-iscomparisons

Python: ObjectAPI to ValueAPI: IsComparisons

Author: calumgrant

python/ql/src/Expressions/IsComparisons.qll

@@ -28,14 +28,14 @@ predicate probablySingleton(ClassValue cls) {
 
 predicate invalid_to_use_is_portably(ClassValue c) {
     overrides_eq_or_cmp(c) and
-    /* Exclude type/builtin-function/bool as it is legitimate to compare them using 'is' but they implement __eq__ */
+    // Exclude type/builtin-function/bool as it is legitimate to compare them using 'is' but they implement __eq__
     not c = Value::named("type") and not c = ClassValue::builtinFunction() and not c = Value::named("bool") and
-    /* OK to compare with 'is' if a singleton */
+    // OK to compare with 'is' if a singleton
     not probablySingleton(c)
 }
 
 predicate simple_constant(ControlFlowNode f) {
-    exists(Object obj | f.refersTo(obj) |  obj = theTrueObject() or obj = theFalseObject() or obj = theNoneObject())
+    exists(Value val | f.pointsTo(val) |  val = Value::named("True") or val = Value::named("False") or val = Value::named("None"))
 }
 
 private predicate cpython_interned_value(Expr e) {
@@ -66,14 +66,14 @@ private predicate universally_interned_value(Expr e) {
 
 predicate cpython_interned_constant(Expr e) {
     exists(Expr const | 
-        e.refersTo(_, const) | 
+        e.pointsTo(_, const) | 
         cpython_interned_value(const)
     )
 }
 
 predicate universally_interned_constant(Expr e) {
     exists(Expr const | 
-        e.refersTo(_, const) | 
+        e.pointsTo(_, const) | 
         universally_interned_value(const)
     )
 }
@@ -95,7 +95,7 @@ private predicate comparison_one_type(Compare comp, Cmpop op, ClassValue cls) {
 }
 
 predicate invalid_portable_is_comparison(Compare comp, Cmpop op, ClassValue cls) {
-    /* OK to use 'is' when defining '__eq__' */
+    // OK to use 'is' when defining '__eq__'
     not exists(Function eq | eq.getName() = "__eq__" or eq.getName() = "__ne__" | eq = comp.getScope().getScope*())
     and
     (
@@ -107,24 +107,24 @@ predicate invalid_portable_is_comparison(Compare comp, Cmpop op, ClassValue cls)
         )
     )
     and
-    /* OK to use 'is' when comparing items from a known set of objects */
-    not exists(Expr left, Expr right, Object obj |
+    // OK to use 'is' when comparing items from a known set of objects
+    not exists(Expr left, Expr right, Value val |
         comp.compares(left, op, right) and
-        exists(ImmutableLiteral il | il.getLiteralObject() = obj) |
-        left.refersTo(obj) and right.refersTo(obj)
+        exists(ImmutableLiteral il | il.getLiteralValue() = val) |
+        left.pointsTo(val) and right.pointsTo(val)
         or
-        /* Simple constant in module, probably some sort of sentinel */
+        // Simple constant in module, probably some sort of sentinel
         exists(AstNode origin |
-            not left.refersTo(_) and right.refersTo(obj, origin) and
+            not left.pointsTo(_) and right.pointsTo(val, origin) and
             origin.getScope().getEnclosingModule() = comp.getScope().getEnclosingModule()
         )
     )
     and
-    /* OK to use 'is' when comparing with a member of an enum */
+    // OK to use 'is' when comparing with a member of an enum
     not exists(Expr left, Expr right, AstNode origin |
         comp.compares(left, op, right) and
         enum_member(origin) |
-        left.refersTo(_, origin) or right.refersTo(_, origin)
+        left.pointsTo(_, origin) or right.pointsTo(_, origin)
     )
 }
 
@@ -135,4 +135,3 @@ private predicate enum_member(AstNode obj) {
         asgn.getValue() = obj
     )
 }
-