Python: annotate missing flow

python/ql/test/experimental/dataflow/coverage/classes.py

@@ -40,7 +40,7 @@ def OK():
 # object.__new__(cls[, ...])
 class With_new:
     def __new__(cls):
-        SINK1(cls)  # Flow not found
+        SINK1(cls)  #$ MISSING: arg1="With_new, l:41 -> cls"
         OK()  # Call not found
         return super().__new__(cls)
 
@@ -52,7 +52,7 @@ def test_new():
 # object.__init__(self[, ...])
 class With_init:
     def __init__(self):
-        SINK1(self)
+        SINK1(self)  #$ MISSING: arg1="with_init, l:60 -> self"
         OK()
 
 
@@ -63,7 +63,7 @@ def test_init():
 # object.__del__(self)
 class With_del:
     def __del__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_del, l:71 -> self"
         OK()  # Call not found
 
 
@@ -75,7 +75,7 @@ def test_del():
 # object.__repr__(self)
 class With_repr:
     def __repr__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_repr, l:84 -> self"
         OK()  # Call not found
         return "With_repr()"
 
@@ -88,7 +88,7 @@ def test_repr():
 # object.__str__(self)
 class With_str:
     def __str__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_str, l:97 -> self"
         OK()  # Call not found
         return "Awesome"
 
@@ -101,7 +101,7 @@ def test_str():
 # object.__bytes__(self)
 class With_bytes:
     def __bytes__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_bytes, l:110 -> self"
         OK()  # Call not found
         return b"Awesome"
 
@@ -114,8 +114,8 @@ def test_bytes():
 # object.__format__(self, format_spec)
 class With_format:
     def __format__(self, format_spec):
-        SINK2(format_spec)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(format_spec)  #$ MISSING: arg2="arg2, l:125 -> format_spec"
+        SINK1(self)  #$ MISSING: arg1="with_format, l:124 -> self"
         OK()  # Call not found
         return "Awesome"
 
@@ -139,8 +139,8 @@ def test_format_fstr():
 # object.__lt__(self, other)
 class With_lt:
     def __lt__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:150 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_lt, l:149 -> self"
         OK()  # Call not found
         return ""
 
@@ -154,8 +154,8 @@ def test_lt():
 # object.__le__(self, other)
 class With_le:
     def __le__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:165 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_le, l:164 -> self"
         OK()  # Call not found
         return ""
 
@@ -169,8 +169,8 @@ def test_le():
 # object.__eq__(self, other)
 class With_eq:
     def __eq__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="with_eq, l:180 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_eq, l:179 -> self"
         OK()  # Call not found
         return ""
 
@@ -183,8 +183,8 @@ def test_eq():
 # object.__ne__(self, other)
 class With_ne:
     def __ne__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="with_ne, l:194 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_ne, l:193 -> self"
         OK()  # Call not found
         return ""
 
@@ -197,8 +197,8 @@ def test_ne():
 # object.__gt__(self, other)
 class With_gt:
     def __gt__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:208 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_gt, l:207 -> self"
         OK()  # Call not found
         return ""
 
@@ -212,8 +212,8 @@ def test_gt():
 # object.__ge__(self, other)
 class With_ge:
     def __ge__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:223 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_ge, l:222 -> self"
         OK()  # Call not found
         return ""
 
@@ -227,7 +227,7 @@ def test_ge():
 # object.__hash__(self)
 class With_hash:
     def __hash__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_hash, l:236 -> self" arg1="with_hash, l:241 -> self" arg1="with_hash, l:246 -> self" arg1="with_hash, l:251 -> self"
         OK()  # Call not found
         return 0
 
@@ -255,7 +255,7 @@ def test_hash_dict():
 # object.__bool__(self)
 class With_bool:
     def __bool__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_bool, l:264 -> self" arg1="with_bool, l:269 -> self"
         OK()  # Call not found
         return True
 
@@ -275,8 +275,8 @@ def test_bool_if():
 # object.__getattr__(self, name)
 class With_getattr:
     def __getattr__(self, name):
-        SINK2(name)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(name)  #$ MISSING: arg2="with_getattr.arg2, l:286 -> name"
+        SINK1(self)  #$ MISSING: arg1="with_getattr, l:285 -> self"
         OK()  # Call not found
         return ""
 
@@ -289,8 +289,8 @@ def test_getattr():
 # object.__getattribute__(self, name)
 class With_getattribute:
     def __getattribute__(self, name):
-        SINK2(name)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(name)  #$ MISSING: arg2="arg2, l:300 -> name"
+        SINK1(self)  #$ MISSING: arg1="with_getattribute, l:299 -> self"
         OK()  # Call not found
         return ""
 
@@ -303,9 +303,9 @@ def test_getattribute():
 # object.__setattr__(self, name, value)
 class With_setattr:
     def __setattr__(self, name, value):
-        SINK3(value)  # Flow not found
-        SINK2(name)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK3(value)  #$ MISSING: arg3="arg3, l:314 -> value"
+        SINK2(name)  #$ MISSING: arg2="arg2, l:315 -> name"
+        SINK1(self)  #$ MISSING: arg1="with_setattr, l:313 -> self"
         OK()  # Call not found
 
 
@@ -318,8 +318,8 @@ def test_setattr():
 # object.__delattr__(self, name)
 class With_delattr:
     def __delattr__(self, name):
-        SINK2(name)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(name)  #$ MISSING: arg2="arg2, l:328 -> name"
+        SINK1(self)  #$ MISSING: arg1="with_delattr, l:327 -> self"
         OK()  # Call not found
 
 
@@ -331,7 +331,7 @@ def test_delattr():
 # object.__dir__(self)
 class With_dir:
     def __dir__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_dir, l:340 -> self"
         OK()  # Call not found
         return []
 
@@ -350,8 +350,8 @@ class Owner:
 class With_get:
     def __get__(self, instance, owner=None):
         SINK3(owner)  # Flow not testsed, use class `Owner` as source to test
-        SINK2(instance)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(instance)  #$ MISSING: arg2="arg2, l:365 -> instance"
+        SINK1(self)  #$ MISSING: arg1="with_get, l:363 -> self"
         OK()  # Call not found
         return ""
 
@@ -369,9 +369,9 @@ def test_get():
 # object.__set__(self, instance, value)
 class With_set:
     def __set__(self, instance, value):
-        SINK3(value)  # Flow not found
-        SINK2(instance)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK3(value)  #$ MISSING: arg3="arg3, l:382 -> value"
+        SINK2(instance)  #$ MISSING: arg2="arg2, l:381 -> instance"
+        SINK1(self)  #$ MISSING: arg1="with_set, l:379 -> self"
         OK()  # Call not found
 
 
@@ -386,8 +386,8 @@ def test_set():
 # object.__delete__(self, instance)
 class With_delete:
     def __delete__(self, instance):
-        SINK2(instance)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(instance)  #$ MISSING: arg2="arg2, l:397 -> instance"
+        SINK1(self)  #$ MISSING: arg1="with_delete, l:395 -> self"
         OK()  # Call not found
 
 
@@ -401,9 +401,9 @@ def test_delete():
 # object.__set_name__(self, owner, name)
 class With_set_name:
     def __set_name__(self, owner, name):
-        SINK3(name)  # Flow not found
-        SINK2(owner)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK3(name)  #$ MISSING: arg3="arg3, l:412 -> name"
+        SINK2(owner)  #$ MISSING: arg2="arg2, l:412 -> owner"
+        SINK1(self)  #$ MISSING: arg1="with_set_name, l:411 -> self"
         OK()  # Call not found
 
 
@@ -412,7 +412,7 @@ def test_set_name():
     type("arg2", (object,), dict(arg3=with_set_name))
 
 
-# 3.3.2.4. __slots__   // We are not testing the  suppression of -weakref_ and _dict_ here
+# 3.3.2.4. __slots__   // We are not testing the  suppression of __weakref__ and __dict__ here
 # object.__slots__
 # __weakref__
 # __dict__
@@ -421,7 +421,7 @@ def test_set_name():
 # classmethod object.__init_subclass__(cls)
 class With_init_subclass:
     def __init_subclass__(cls):
-        SINK1(cls)  # Flow not found
+        SINK1(cls)  #$ MISSING: arg1="Tuple[0], l:429 -> cls"
         OK()  # Call not found
 
 
@@ -441,7 +441,7 @@ class With_prepare(type):
     def __prepare__(name, bases, **kwds):
         SINK3(kwds)  # Flow not tested
         SINK2(bases)  # Flow not tested
-        SINK1(name)  # Flow not found
+        SINK1(name)  #$ MISSING: arg1="arg1, l:450 -> name"
         OK()  # Call not found
         return kwds
 
@@ -455,8 +455,8 @@ def test_prepare():
 # class.__instancecheck__(self, instance)
 class With_instancecheck:
     def __instancecheck__(self, instance):
-        SINK2(instance)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(instance)  #$ MISSING: arg2="arg2, l:466 -> instance"
+        SINK1(self)  #$ MISSING: arg1="with_instancecheck, l:465 -> self"
         OK()  # Call not found
         return True
 
@@ -470,8 +470,8 @@ def test_instancecheck():
 # class.__subclasscheck__(self, subclass)
 class With_subclasscheck:
     def __subclasscheck__(self, subclass):
-        SINK2(subclass)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(subclass)  #$ MISSING: arg2="arg2, l:481 -> subclass"
+        SINK1(self)  #$ MISSING: arg1="with_subclasscheck, l:480 -> self"
         OK()  # Call not found
         return True
 
@@ -486,8 +486,8 @@ def test_subclasscheck():
 # classmethod object.__class_getitem__(cls, key)
 class With_class_getitem:
     def __class_getitem__(cls, key):
-        SINK2(key)  # Flow not found
-        SINK1(cls)  # Flow not found
+        SINK2(key)  #$ MISSING: arg2="arg2, l:496 -> key"
+        SINK1(cls)  #$ MISSING: arg1="With_class_getitem, l:487 -> cls"
         OK()  # Call not found
         return object
 
@@ -501,7 +501,7 @@ def test_class_getitem():
 # object.__call__(self[, args...])
 class With_call:
     def __call__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_call, l:509 -> self"
         OK()  # Call not found
 
 
@@ -514,7 +514,7 @@ def test_call():
 # object.__len__(self)
 class With_len:
     def __len__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_len, l:523 -> self" arg1="with_len, l:528 -> self" arg1="with_len, l:533 -> self"
         OK()  # Call not found
         return 0
 
@@ -538,7 +538,7 @@ def test_len_if():
 # object.__length_hint__(self)
 class With_length_hint:
     def __length_hint__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_length_hint, l:549 -> self"
         OK()  # Call not found
         return 0
 
@@ -598,8 +598,8 @@ def test_delitem():
 # object.__missing__(self, key)
 class With_missing(dict):
     def __missing__(self, key):
-        SINK2(key)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(key)  #$ MISSING: arg2="arg2, l:609 -> key"
+        SINK1(self)  #$ MISSING: arg1="with_missing, l:608 -> self"
         OK()  # Call not found
         return ""
 
@@ -613,7 +613,7 @@ def test_missing():
 # object.__iter__(self)
 class With_iter:
     def __iter__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_iter, l:622 -> self"
         OK()  # Call not found
         return [].__iter__()
 
@@ -626,7 +626,7 @@ def test_iter():
 # object.__reversed__(self)
 class With_reversed:
     def __reversed__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_reversed, l:635 -> self"
         OK()  # Call not found
         return [].__iter__
 
@@ -639,8 +639,8 @@ def test_reversed():
 # object.__contains__(self, item)
 class With_contains:
     def __contains__(self, item):
-        SINK2(item)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(item)  #$ MISSING: arg2="arg2, l:650 -> item"
+        SINK1(self)  #$ MISSING: arg1="with_contains, l:649 -> self"
         OK()  # Call not found
         return True
 
@@ -760,8 +760,8 @@ def test_mod():
 # object.__divmod__(self, other)
 class With_divmod:
     def __divmod__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:771 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_divmod, l:770 -> self"
         OK()  # Call not found
         return self
 
@@ -871,8 +871,8 @@ def test_or():
 # object.__radd__(self, other)
 class With_radd:
     def __radd__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:882 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_radd, l:881 -> self"
         OK()  # Call not found
         return self
 
@@ -886,8 +886,8 @@ def test_radd():
 # object.__rsub__(self, other)
 class With_rsub:
     def __rsub__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:897 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rsub, l:896 -> self"
         OK()  # Call not found
         return self
 
@@ -901,8 +901,8 @@ def test_rsub():
 # object.__rmul__(self, other)
 class With_rmul:
     def __rmul__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:912 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rmul, l:911 -> self"
         OK()  # Call not found
         return self
 
@@ -916,8 +916,8 @@ def test_rmul():
 # object.__rmatmul__(self, other)
 class With_rmatmul:
     def __rmatmul__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:927 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rmatmul, l:926 -> self"
         OK()  # Call not found
         return self
 
@@ -931,8 +931,8 @@ def test_rmatmul():
 # object.__rtruediv__(self, other)
 class With_rtruediv:
     def __rtruediv__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:942 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rtruediv, l:941 -> self"
         OK()  # Call not found
         return self
 
@@ -946,8 +946,8 @@ def test_rtruediv():
 # object.__rfloordiv__(self, other)
 class With_rfloordiv:
     def __rfloordiv__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:957 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rfloordiv, l:956 -> self"
         OK()  # Call not found
         return self
 
@@ -961,8 +961,8 @@ def test_rfloordiv():
 # object.__rmod__(self, other)
 class With_rmod:
     def __rmod__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:972 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rmod, l:971 -> self"
         OK()  # Call not found
         return self
 
@@ -976,8 +976,8 @@ def test_rmod():
 # object.__rdivmod__(self, other)
 class With_rdivmod:
     def __rdivmod__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:987 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rdivmod, l:986 -> self"
         OK()  # Call not found
         return self
 
@@ -991,8 +991,8 @@ def test_rdivmod():
 # object.__rpow__(self, other[, modulo])
 class With_rpow:
     def __rpow__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1002 -> other" arg2="arg2, l:1008 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rpow, l:1001 -> self" arg1="with_rpow, l:1007 -> self"
         OK()  # Call not found
         return self
 
@@ -1012,8 +1012,8 @@ def test_rpow_op():
 # object.__rlshift__(self, other)
 class With_rlshift:
     def __rlshift__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1023 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rlshift, l:1022 -> self"
         OK()  # Call not found
         return self
 
@@ -1027,8 +1027,8 @@ def test_rlshift():
 # object.__rrshift__(self, other)
 class With_rrshift:
     def __rrshift__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1038 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rrshift, l:1037 -> self"
         OK()  # Call not found
         return self
 
@@ -1042,8 +1042,8 @@ def test_rrshift():
 # object.__rand__(self, other)
 class With_rand:
     def __rand__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1053 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rand, l:1052 -> self"
         OK()  # Call not found
         return self
 
@@ -1057,8 +1057,8 @@ def test_rand():
 # object.__rxor__(self, other)
 class With_rxor:
     def __rxor__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1068 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_rxor, l:1067 -> self"
         OK()  # Call not found
         return self
 
@@ -1072,8 +1072,8 @@ def test_rxor():
 # object.__ror__(self, other)
 class With_ror:
     def __ror__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1083 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_ror, l:1082 -> self"
         OK()  # Call not found
         return self
 
@@ -1087,8 +1087,8 @@ def test_ror():
 # object.__iadd__(self, other)
 class With_iadd:
     def __iadd__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1098 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_iadd, l:1097 -> self"
         OK()  # Call not found
         return self
 
@@ -1102,8 +1102,8 @@ def test_iadd():
 # object.__isub__(self, other)
 class With_isub:
     def __isub__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1113 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_isub, l:1112 -> self"
         OK()  # Call not found
         return self
 
@@ -1117,8 +1117,8 @@ def test_isub():
 # object.__imul__(self, other)
 class With_imul:
     def __imul__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1128 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_imul, l:1127 -> self"
         OK()  # Call not found
         return self
 
@@ -1132,8 +1132,8 @@ def test_imul():
 # object.__imatmul__(self, other)
 class With_imatmul:
     def __imatmul__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1143 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_imatmul, l:1142 -> self"
         OK()  # Call not found
         return self
 
@@ -1147,8 +1147,8 @@ def test_imatmul():
 # object.__itruediv__(self, other)
 class With_itruediv:
     def __itruediv__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1158 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_itruediv, l:1157 -> self"
         OK()  # Call not found
         return self
 
@@ -1162,8 +1162,8 @@ def test_itruediv():
 # object.__ifloordiv__(self, other)
 class With_ifloordiv:
     def __ifloordiv__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1173 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_ifloordiv, l:172 -> self"
         OK()  # Call not found
         return self
 
@@ -1177,8 +1177,8 @@ def test_ifloordiv():
 # object.__imod__(self, other)
 class With_imod:
     def __imod__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1188 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_imod, l:1187 -> self"
         OK()  # Call not found
         return self
 
@@ -1192,8 +1192,8 @@ def test_imod():
 # object.__ipow__(self, other[, modulo])
 class With_ipow:
     def __ipow__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1203 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_ipow, l:1202 -> self"
         OK()  # Call not found
         return self
 
@@ -1207,8 +1207,8 @@ def test_ipow():
 # object.__ilshift__(self, other)
 class With_ilshift:
     def __ilshift__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1218 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_ilshift, l:1217 -> self"
         OK()  # Call not found
         return self
 
@@ -1222,8 +1222,8 @@ def test_ilshift():
 # object.__irshift__(self, other)
 class With_irshift:
     def __irshift__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1233 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_irshift, l:1232 -> self"
         OK()  # Call not found
         return self
 
@@ -1237,8 +1237,8 @@ def test_irshift():
 # object.__iand__(self, other)
 class With_iand:
     def __iand__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1248 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_iand, l:1247 -> self"
         OK()  # Call not found
         return self
 
@@ -1252,8 +1252,8 @@ def test_iand():
 # object.__ixor__(self, other)
 class With_ixor:
     def __ixor__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1263 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_ixor, l:1262 -> self"
         OK()  # Call not found
         return self
 
@@ -1267,8 +1267,8 @@ def test_ixor():
 # object.__ior__(self, other)
 class With_ior:
     def __ior__(self, other):
-        SINK2(other)  # Flow not found
-        SINK1(self)  # Flow not found
+        SINK2(other)  #$ MISSING: arg2="arg2, l:1278 -> other"
+        SINK1(self)  #$ MISSING: arg1="with_ior, l:1277 -> self"
         OK()  # Call not found
         return self
 
@@ -1282,7 +1282,7 @@ def test_ior():
 # object.__neg__(self)
 class With_neg:
     def __neg__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_neg, l:1291 -> self"
         OK()  # Call not found
         return self
 
@@ -1295,7 +1295,7 @@ def test_neg():
 # object.__pos__(self)
 class With_pos:
     def __pos__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_pos, l:1303 -> self"
         OK()  # Call not found
         return self
 
@@ -1308,7 +1308,7 @@ def test_pos():
 # object.__abs__(self)
 class With_abs:
     def __abs__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_abs, l:1317 -> self"
         OK()  # Call not found
         return self
 
@@ -1321,7 +1321,7 @@ def test_abs():
 # object.__invert__(self)
 class With_invert:
     def __invert__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_invert, l:1330 -> self"
         OK()  # Call not found
         return self
 
@@ -1334,7 +1334,7 @@ def test_invert():
 # object.__complex__(self)
 class With_complex:
     def __complex__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_complex, l:1343 -> self"
         OK()  # Call not found
         return 0j
 
@@ -1347,7 +1347,7 @@ def test_complex():
 # object.__int__(self)
 class With_int:
     def __int__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_int, l:1356 -> self"
         OK()  # Call not found
         return 0
 
@@ -1360,7 +1360,7 @@ def test_int():
 # object.__float__(self)
 class With_float:
     def __float__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_float, l:1369 -> self"
         OK()  # Call not found
         return 0.0
 
@@ -1373,7 +1373,7 @@ def test_float():
 # object.__index__(self)
 class With_index:
     def __index__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_index, l:1384 -> self" arg1="with_index, l:1389 -> self" arg1="with_index, l:1394 -> self" arg1="with_index, l:1399 -> self" arg1="with_index, l:1404 -> self" arg1="with_index, l:1409 -> self" arg1="with_index, l:1414 -> self" arg1="with_index, l:1419 -> self"
         OK()  # Call not found
         return 0
 
@@ -1423,7 +1423,7 @@ def test_index_complex():
 # object.__round__(self[, ndigits])
 class With_round:
     def __round__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_round, l:1432 -> self"
         OK()  # Call not found
         return 0
 
@@ -1436,7 +1436,7 @@ def test_round():
 # object.__trunc__(self)
 class With_trunc:
     def __trunc__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_trunc, l:1445 -> self"
         OK()  # Call not found
         return 0
 
@@ -1451,7 +1451,7 @@ def test_trunc():
 # object.__floor__(self)
 class With_floor:
     def __floor__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_floor, l:1460 -> self"
         OK()  # Call not found
         return 0
 
@@ -1466,7 +1466,7 @@ def test_floor():
 # object.__ceil__(self)
 class With_ceil:
     def __ceil__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_ceil, l:147 -> self"
         OK()  # Call not found
         return 0
 
@@ -1482,7 +1482,7 @@ def test_ceil():
 # object.__enter__(self)
 class With_enter:
     def __enter__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1=".0, l:1494 -> self"
         OK()  # Call not found
         return
 
@@ -1504,7 +1504,7 @@ class With_exit:
         SINK4(traceback)  # Flow not tested
         SINK3(exc_value)  # Flow not tested
         SINK2(exc_type)  # Flow not tested
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1=".0, l:1513 -> self"
         OK()  # Call not found
         return
 
@@ -1519,7 +1519,7 @@ def test_exit():
 # object.__await__(self)
 class With_await:
     def __await__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_await, l:1528 -> self"
         OK()  # Call not found
         return (yield from asyncio.coroutine(lambda: "")())
 
@@ -1538,7 +1538,7 @@ async def atest_await():
 # object.__aiter__(self)
 class With_aiter:
     def __aiter__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_aiter, l:1550 -> self"
         OK()  # Call not found
         return self
 
@@ -1558,7 +1558,7 @@ class With_anext:
         return self
 
     async def __anext__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_anext, l:1567 -> self"
         OK()  # Call not found
         raise StopAsyncIteration
 
@@ -1573,7 +1573,7 @@ async def atest_anext():
 # object.__aenter__(self)
 class With_aenter:
     async def __aenter__(self):
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_aenter, l:1584 -> self"
         OK()  # Call not found
 
     async def __aexit__(self, exc_type, exc_value, traceback):
@@ -1595,7 +1595,7 @@ class With_aexit:
         SINK4(traceback)  # Flow not tested
         SINK3(exc_value)  # Flow not tested
         SINK2(exc_type)  # Flow not tested
-        SINK1(self)  # Flow not found
+        SINK1(self)  #$ MISSING: arg1="with_aexit, l:1603 -> self"
         OK()  # Call not found