Merge pull request #2820 from RasmusWL/python-modernise-statements

Python: modernise Statements/ queries

Author: tausbn

python/ql/src/Statements/AssertLiteralConstant.ql

@@ -26,7 +26,5 @@ where
         value = test.(NameConstant).toString()
     ) and
     /* Exclude asserts appearing at the end of a chain of `elif`s */
-    not exists(If i | 
-        i.getElif().getAnOrelse() = a
-    )
+    not exists(If i | i.getElif().getAnOrelse() = a)
 select a, "Assert of literal constant " + value + "."

python/ql/src/Statements/AssertOnTuple.ql

@@ -14,11 +14,14 @@
 import python
 
 from Assert a, string b, string non
-where a.getTest() instanceof Tuple and
-			(if exists(((Tuple)a.getTest()).getAnElt()) then
-			    (b = "True" and non = "non-")
-       else
-          (b = "False" and non = "")
-      )
+where
+    a.getTest() instanceof Tuple and
+    (
+        if exists(a.getTest().(Tuple).getAnElt())
+        then (
+            b = "True" and non = "non-"
+        ) else (
+            b = "False" and non = ""
+        )
+    )
 select a, "Assertion of " + non + "empty tuple is always " + b + "."
-

python/ql/src/Statements/BreakOrReturnInFinally.ql

@@ -15,13 +15,13 @@
 import python
 
 from Stmt s, string kind
-where 
-s instanceof Return and kind = "return" and exists(Try t | t.getFinalbody().contains(s))
-or
-s instanceof Break and kind = "break" and
-exists(Try t | t.getFinalbody().contains(s) |
-    not exists(For loop | loop.contains(s) and t.getFinalbody().contains(loop))
-    and
-    not exists(While loop | loop.contains(s) and t.getFinalbody().contains(loop))
-)
+where
+    s instanceof Return and kind = "return" and exists(Try t | t.getFinalbody().contains(s))
+    or
+    s instanceof Break and
+    kind = "break" and
+    exists(Try t | t.getFinalbody().contains(s) |
+        not exists(For loop | loop.contains(s) and t.getFinalbody().contains(loop)) and
+        not exists(While loop | loop.contains(s) and t.getFinalbody().contains(loop))
+    )
 select s, "'" + kind + "' in a finally block will swallow any exceptions raised."

python/ql/src/Statements/C_StyleParentheses.ql

@@ -14,19 +14,22 @@
 import python
 
 from Expr e, Location l, string kind, string what
-where e.isParenthesized() and
-not e instanceof Tuple and
-(
-    exists(If i | i.getTest() = e) and kind = "if" and what = "condition"
-    or
-    exists(While w | w.getTest() = e) and kind = "while" and what = "condition"
-    or
-    exists(Return r | r.getValue() = e) and kind = "return" and what = "value"
-    or
-    exists(Assert a | a.getTest() = e and not exists(a.getMsg())) and kind = "assert" and what = "test"
-)
-and
-// These require parentheses
-(not e instanceof Yield and not e instanceof YieldFrom and not e instanceof GeneratorExp) and
-l = e.getLocation() and l.getStartLine() = l.getEndLine()
+where
+    e.isParenthesized() and
+    not e instanceof Tuple and
+    (
+        exists(If i | i.getTest() = e) and kind = "if" and what = "condition"
+        or
+        exists(While w | w.getTest() = e) and kind = "while" and what = "condition"
+        or
+        exists(Return r | r.getValue() = e) and kind = "return" and what = "value"
+        or
+        exists(Assert a | a.getTest() = e and not exists(a.getMsg())) and
+        kind = "assert" and
+        what = "test"
+    ) and
+    // These require parentheses
+    (not e instanceof Yield and not e instanceof YieldFrom and not e instanceof GeneratorExp) and
+    l = e.getLocation() and
+    l.getStartLine() = l.getEndLine()
 select e, "Parenthesized " + what + " in '" + kind + "' statement."

python/ql/src/Statements/ConstantInConditional.ql

@@ -15,16 +15,15 @@
 
 import python
 
-
 predicate is_condition(Expr cond) {
-	exists(If i | i.getTest() = cond) or
-	exists(IfExp ie | ie.getTest() = cond)
+    exists(If i | i.getTest() = cond) or
+    exists(IfExp ie | ie.getTest() = cond)
 }
 
 /* Treat certain unmodified builtins as constants as well. */
 predicate effective_constant(Name cond) {
     exists(GlobalVariable var | var = cond.getVariable() and not exists(NameNode f | f.defines(var)) |
-                                var.getId() = "True" or var.getId() = "False" or var.getId() = "NotImplemented"
+        var.getId() = "True" or var.getId() = "False" or var.getId() = "NotImplemented"
     )
 }
 
@@ -34,9 +33,10 @@ predicate test_makes_code_unreachable(Expr cond) {
     exists(While w | w.getTest() = cond and w.getStmt(0).isUnreachable())
 }
 
-
 from Expr cond
-where is_condition(cond) and (cond.isConstant() or effective_constant(cond)) and 
-/* Ignore cases where test makes code unreachable, as that is handled in different query */
-not test_makes_code_unreachable(cond)
+where
+    is_condition(cond) and
+    (cond.isConstant() or effective_constant(cond)) and
+    /* Ignore cases where test makes code unreachable, as that is handled in different query */
+    not test_makes_code_unreachable(cond)
 select cond, "Testing a constant will always give the same result."

python/ql/src/Statements/DocStrings.ql

@@ -9,7 +9,9 @@
  * @precision medium
  * @id py/missing-docstring
  */
-/* NOTE: precision of 'medium' reflects the lack of precision in the underlying rule.
+
+/*
+ * NOTE: precision of 'medium' reflects the lack of precision in the underlying rule.
  * Do we care whether a function has a docstring? That often depends on the reader of that docstring.
  */
 
@@ -18,25 +20,26 @@ import python
 predicate needs_docstring(Scope s) {
     s.isPublic() and
     (
-      not s instanceof Function
-      or
-      function_needs_docstring(s)
+        not s instanceof Function
+        or
+        function_needs_docstring(s)
     )
 }
 
 predicate function_needs_docstring(Function f) {
-    not exists(FunctionObject fo, FunctionObject base | fo.overrides(base) and fo.getFunction() = f |
-               not function_needs_docstring(base.getFunction())) and
+    not exists(FunctionValue fo, FunctionValue base | fo.overrides(base) and fo.getScope() = f |
+        not function_needs_docstring(base.getScope())
+    ) and
     f.getName() != "lambda" and
-    (f.getMetrics().getNumberOfLinesOfCode() - count(f.getADecorator())) > 2
-    and not exists(PythonPropertyObject p | 
+    (f.getMetrics().getNumberOfLinesOfCode() - count(f.getADecorator())) > 2 and
+    not exists(PythonPropertyObject p |
         p.getGetter().getFunction() = f or
         p.getSetter().getFunction() = f
     )
 }
 
 string scope_type(Scope s) {
-    result = "Module" and s instanceof Module and not ((Module)s).isPackage()
+    result = "Module" and s instanceof Module and not s.(Module).isPackage()
     or
     result = "Class" and s instanceof Class
     or
@@ -46,5 +49,3 @@ string scope_type(Scope s) {
 from Scope s
 where needs_docstring(s) and not exists(s.getDocString())
 select s, scope_type(s) + " " + s.getName() + " does not have a docstring"
-
-

python/ql/src/Statements/ExecUsed.ql

@@ -19,9 +19,9 @@ string message() {
 }
 
 predicate exec_function_call(Call c) {
-    exists(GlobalVariable exec | exec = ((Name)c.getFunc()).getVariable() and exec.getId() = "exec")
+    exists(GlobalVariable exec | exec = c.getFunc().(Name).getVariable() and exec.getId() = "exec")
 }
 
 from AstNode exec
 where exec_function_call(exec) or exec instanceof Exec
-select exec, message()
+select exec, message()

python/ql/src/Statements/IterableStringOrSequence.ql

@@ -13,18 +13,20 @@
 
 import python
 
-predicate is_a_string_type(ClassObject seqtype) {
-    seqtype = theBytesType() and major_version() = 2
-    or 
-    seqtype = theUnicodeType() 
+predicate has_string_type(Value v) {
+    v.getClass() = ClassValue::str()
+    or
+    v.getClass() = ClassValue::unicode() and major_version() = 2
 }
 
-from For loop, ControlFlowNode iter, Object str, Object seq, ControlFlowNode seq_origin, ClassObject strtype, ClassObject seqtype, ControlFlowNode str_origin
-where loop.getIter().getAFlowNode() = iter and
-iter.refersTo(str, strtype, str_origin) and 
-iter.refersTo(seq, seqtype, seq_origin) and 
-is_a_string_type(strtype) and 
-seqtype.isIterable() and
-not is_a_string_type(seqtype)
-
-select loop, "Iteration over $@, of class " + seqtype.getName() + ", may also iterate over $@.", seq_origin, "sequence", str_origin, "string"
+from
+    For loop, ControlFlowNode iter, Value str, Value seq, ControlFlowNode seq_origin, ControlFlowNode str_origin
+where
+    loop.getIter().getAFlowNode() = iter and
+    iter.pointsTo(str, str_origin) and
+    iter.pointsTo(seq, seq_origin) and
+    has_string_type(str) and
+    seq.getClass().isIterable() and
+    not has_string_type(seq)
+select loop, "Iteration over $@, of class " + seq.getClass().getName() + ", may also iterate over $@.",
+    seq_origin, "sequence", str_origin, "string"

python/ql/src/Statements/MismatchInMultipleAssignment.ql

@@ -14,18 +14,19 @@
 
 import python
 
-private  int len(ExprList el) {
-	result = count(el.getAnItem())
-}
+private int len(ExprList el) { result = count(el.getAnItem()) }
 
 predicate mismatched(Assign a, int lcount, int rcount, Location loc, string sequenceType) {
     exists(ExprList l, ExprList r |
-        (a.getATarget().(Tuple).getElts() = l or
-         a.getATarget().(List).getElts() = l)
-        and
-        ((a.getValue().(Tuple).getElts() = r and sequenceType = "tuple") or
-         (a.getValue().(List).getElts() = r and sequenceType = "list"))
-        and
+        (
+            a.getATarget().(Tuple).getElts() = l or
+            a.getATarget().(List).getElts() = l
+        ) and
+        (
+            a.getValue().(Tuple).getElts() = r and sequenceType = "tuple"
+            or
+            a.getValue().(List).getElts() = r and sequenceType = "list"
+        ) and
         loc = a.getValue().getLocation() and
         lcount = len(l) and
         rcount = len(r) and
@@ -35,24 +36,26 @@ predicate mismatched(Assign a, int lcount, int rcount, Location loc, string sequ
 }
 
 predicate mismatched_tuple_rhs(Assign a, int lcount, int rcount, Location loc) {
-    exists(ExprList l, TupleObject r, AstNode origin |
-        (a.getATarget().(Tuple).getElts() = l or
-         a.getATarget().(List).getElts() = l)
-        and
-        a.getValue().refersTo(r, origin) and
+    exists(ExprList l, TupleValue r, AstNode origin |
+        (
+            a.getATarget().(Tuple).getElts() = l or
+            a.getATarget().(List).getElts() = l
+        ) and
+        a.getValue().pointsTo(r, origin) and
         loc = origin.getLocation() and
         lcount = len(l) and
-        rcount = r.getLength() and
+        rcount = r.length() and
         lcount != rcount and
         not exists(Starred s | l.getAnItem() = s)
     )
 }
 
-
 from Assign a, int lcount, int rcount, Location loc, string sequenceType
 where
     mismatched(a, lcount, rcount, loc, sequenceType)
     or
     mismatched_tuple_rhs(a, lcount, rcount, loc) and
     sequenceType = "tuple"
-select a, "Left hand side of assignment contains " + lcount + " variables, but right hand side is a $@ of length " + rcount + "." , loc, sequenceType
+select a,
+    "Left hand side of assignment contains " + lcount +
+        " variables, but right hand side is a $@ of length " + rcount + ".", loc, sequenceType

python/ql/src/Statements/ModificationOfLocals.ql

@@ -12,24 +12,18 @@
 
 import python
 
-Object aFunctionLocalsObject() {
-    exists(Call c, Name n, GlobalVariable v |
-        c = result.getOrigin() and
-        n = c.getFunc() and
-        n.getVariable() = v and
-        v.getId() = "locals" and
-        c.getScope() instanceof FastLocalsFunction
-    )
+predicate originIsLocals(ControlFlowNode n) {
+    n.pointsTo(_, _, Value::named("locals").getACall())
 }
 
-
-
 predicate modification_of_locals(ControlFlowNode f) {
-    f.(SubscriptNode).getObject().refersTo(aFunctionLocalsObject()) and (f.isStore() or f.isDelete())
+    originIsLocals(f.(SubscriptNode).getObject()) and
+    (f.isStore() or f.isDelete())
     or
     exists(string mname, AttrNode attr |
         attr = f.(CallNode).getFunction() and
-        attr.getObject(mname).refersTo(aFunctionLocalsObject(), _) |
+        originIsLocals(attr.getObject(mname))
+    |
         mname = "pop" or
         mname = "popitem" or
         mname = "update" or
@@ -39,5 +33,4 @@ predicate modification_of_locals(ControlFlowNode f) {
 
 from AstNode a, ControlFlowNode f
 where modification_of_locals(f) and a = f.getNode()
-
 select a, "Modification of the locals() dictionary will have no effect on the local variables."