Changed AST integration, added two simple analyses

.hypothesis/examples/233f06a9913318fc/2ae7c46f43f80ef4

@@ -0,0 +1 @@
+
	
*		

.hypothesis/examples/233f06a9913318fc/906354d4baa24db5

@@ -0,0 +1 @@
+
E		*	

.hypothesis/examples/233f06a9913318fc/97076c310a521f61

@@ -0,0 +1 @@
+
E		*	

.hypothesis/examples/233f06a9913318fc/b287960ff32fd9de

@@ -0,0 +1 @@
+
			
*

.hypothesis/examples/233f06a9913318fc/ba1cc6251a6626e0

@@ -0,0 +1 @@
+
	

*	

.hypothesis/examples/233f06a9913318fc/c19561aac3836435

@@ -0,0 +1 @@
+
	

	*

build/lib/dynapyt/instrument/IIDs.py

@@ -12,17 +12,21 @@ def __init__(self, file_path):
             file_path = "iids.json"
             self.next_iid = 1
             self.iid_to_location = {}
+            self.location_to_iid = {}
         else:
             with open(file_path, "r") as file:
                 json_object = json.load(file)
             self.next_iid = json_object["next_iid"]
-            self.iid_to_location = json_object["iid_to_location"]
+            self.iid_to_location = {int(k): v for k, v in json_object["iid_to_location"].items()}
         self.file_path = file_path
 
     def new(self, file, start_line, start_column, end_line, end_column):
-        self.iid_to_location[self.next_iid] = Location(file, start_line, start_column, end_line, end_column)
+        this_location = Location(file, start_line, start_column, end_line, end_column)
+        if this_location in self.location_to_iid:
+            return self.location_to_iid[this_location]
+        self.iid_to_location[self.next_iid] = this_location
         self.next_iid += 1
-        return self.next_iid
+        return self.next_iid - 1
 
     def store(self):
         all_data = {

build/lib/dynapyt/instrument/instrument.py

@@ -65,7 +65,10 @@ def instrument_file(file_path, iids, selected_hooks):
 
     module = importlib.import_module('dynapyt.analyses.' + args.analysis)
     class_ = getattr(module, args.analysis)
-    instance = class_()
+    try:
+        instance = class_(iids)
+    except:
+        instance = class_()
     method_list = [func for func in dir(instance) if callable(getattr(instance, func)) and not func.startswith("__")]
     selected_hooks = get_hooks_from_analysis(method_list)
     for file_path in files:

build/lib/dynapyt/runtime.py

@@ -1,4 +1,8 @@
+from sys import exc_info
 import libcst as cst
+from copy import copy
+from dynapyt.utils.Dynapyt_Unidefined import Dynapyt_Undefined
+from dynapyt.utils.hooks import snake
 
 analysis = None
 
@@ -16,11 +20,64 @@ def call_if_exists(f, *args):
 def _dynapyt_parse_to_ast_(code):
     return cst.parse_module(code)
 
-def _assign_(iid, right):
-    result = call_if_exists('assignment', iid, '', None, right)
-    return result if result != None else right
+def _assign_(dyn_ast, iid, right, left):
+    new_left = []
+    for l in left:
+        try:
+            new_left.append(l())
+        except (NameError, AttributeError, KeyError):
+            new_left.append(Dynapyt_Undefined())
+    res = call_if_exists('write', dyn_ast, iid, new_left, right)
+    result = call_if_exists('assignment', dyn_ast, iid, new_left, right)
+    if result != None:
+        return result
+    elif res != None:
+        return res
+    return right
+
+def _aug_assign_(dyn_ast, iid, left, opr, right):
+    operator = ['AddAssign', 'BitAndAssign', 'BitOrAssign', 'BitXorAssign', 'DivideAssign',
+            'FloorDivideAssign', 'LeftShiftAssign', 'MatrixMultiplyAssign', 'ModuloAssign',
+            'MultiplyAssign', 'PowerAssign', 'RightShiftAssign', 'SubtractAssign']
+    call_if_exists(snake(operator[opr][:-6]), dyn_ast, iid, left, right)
+    call_if_exists('binary_op', dyn_ast, iid, operator[opr][:-6], left, right, None)
+    call_if_exists('write', dyn_ast, iid, [left], right)
+    call_if_exists('assignment', dyn_ast, iid, [left], right)
+    result_high = call_if_exists('augmented_assignment', dyn_ast, iid, left, operator[opr], right)
+    result_low = call_if_exists(snake(operator[opr]), dyn_ast, iid, left, right)
+    if result_low != None:
+        right = result_low
+    elif result_high != None:
+        right = result_high
+    return right
+    # if opr == 0:
+    #     left += right
+    # elif opr == 1:
+    #     left &= right
+    # elif opr == 2:
+    #     left |= right
+    # elif opr == 3:
+    #     left ^= right
+    # elif opr == 4:
+    #     left /= right
+    # elif opr == 5:
+    #     left //= right
+    # elif opr == 6:
+    #     left <<= right
+    # elif opr == 7:
+    #     left @= right
+    # elif opr == 8:
+    #     left %= right
+    # elif opr == 9:
+    #     left *= right
+    # elif opr == 10:
+    #     left **= right
+    # elif opr == 11:
+    #     left >>= right
+    # elif opr == 12:
+    #     left -= right
 
-def _binary_op_(iid, left, opr, right):
+def _binary_op_(dyn_ast, iid, left, opr, right):
     bin_op = ['Add', 'BitAnd', 'BitOr', 'BitXor', 'Divide', 'FloorDivide',
         'LeftShift', 'MatrixMultiply', 'Modulo', 'Multiply', 'Power',
         'RightShift', 'Subtract', 'And', 'Or']
@@ -54,10 +111,15 @@ def _binary_op_(iid, left, opr, right):
         result = left and right
     elif opr == 14:
         result = left or right
-    result_new = call_if_exists('binary_op', iid, bin_op[opr], left, right, result)
-    return result_new if result_new != None else result
+    result_high = call_if_exists('binary_op', dyn_ast, iid, bin_op[opr], left, right, result)
+    result_low = call_if_exists(snake(bin_op[opr]), dyn_ast, iid, left, right, result)
+    if result_low != None:
+        return result_low
+    elif result_high != None:
+        return result_high
+    return result
 
-def _unary_op_(iid, opr, right):
+def _unary_op_(dyn_ast, iid, opr, right):
     un_op = ['BitInvert', 'Minus', 'Not', 'Plus']
     if opr == 0:
         result = ~ right
@@ -67,10 +129,15 @@ def _unary_op_(iid, opr, right):
         result = not right
     elif opr == 3:
         result = + right
-    result_new = call_if_exists('unary_op', iid, un_op[opr], right, result)
-    return result_new if result_new != None else result
+    result_high = call_if_exists('unary_op', dyn_ast, iid, un_op[opr], right, result)
+    result_low = call_if_exists(snake(un_op[opr]), dyn_ast, iid, right, result)
+    if result_low != None:
+        return result_low
+    elif result_high != None:
+        return result_high
+    return result
 
-def _comp_op_(iid, left, comparisons):
+def _comp_op_(dyn_ast, iid, left, comparisons):
     comp_op = ['Equal', 'GreaterThan', 'GreaterThanEqual', 'In', 'Is', 'LessThan',
         'LessThanEqual', 'NotEqual', 'IsNot', 'NotIn']
     l = left
@@ -96,62 +163,192 @@ def _comp_op_(iid, left, comparisons):
             tmp = l is not r
         elif op == 9:
             tmp = l not in r
+        result_high = call_if_exists('comparison', dyn_ast, iid, l, comp_op[op], r, tmp)
+        result_low = call_if_exists(snake(comp_op[op]), dyn_ast, iid, l, r, tmp)
+        if result_low != None:
+            tmp = result_low
+        elif result_high != None:
+            tmp = result_high
         result = result and tmp
-    result_new = call_if_exists('comparison', iid, left, [(comp_op[i], j) for i, j in comparisons], result)
-    return result_new if result_new != None else result
+        l = r
+    return result
 
-def _call_(iid, call):
-    call_if_exists('pre_call', iid)
+def _call_(dyn_ast, iid, call):
+    call_if_exists('pre_call', dyn_ast, iid)
     result = call()
-    call_if_exists('post_call', iid)
+    call_if_exists('post_call', dyn_ast, iid)
     return result
 
-def _literal_(iid, val):
-    res = call_if_exists('literal', iid, val)
+def _bool_(dyn_ast, iid, val):
+    res_high = call_if_exists('literal', dyn_ast, iid, val)
+    res_low = call_if_exists('boolean_literal', dyn_ast, iid, val)
+    if res_low != None:
+        return res_low
+    elif res_high != None:
+        return res_high
+    return val
+
+def _int_(dyn_ast, iid, val):
+    res_high = call_if_exists('literal', dyn_ast, iid, val)
+    res_low = call_if_exists('integer_literal', dyn_ast, iid, val)
+    if res_low != None:
+        return res_low
+    elif res_high != None:
+        return res_high
+    return val
+
+def _float_(dyn_ast, iid, val):
+    res_high = call_if_exists('literal', dyn_ast, iid, val)
+    res_low = call_if_exists('float_literal', dyn_ast, iid, val)
+    if res_low != None:
+        return res_low
+    elif res_high != None:
+        return res_high
+    return val
+
+def _str_(dyn_ast, iid, val):
+    res_high = call_if_exists('literal', dyn_ast, iid, val)
+    res_low = call_if_exists('string_literal', dyn_ast, iid, val)
+    if res_low != None:
+        return res_low
+    elif res_high != None:
+        return res_high
+    return val
+
+def _img_(dyn_ast, iid, val):
+    res_high = call_if_exists('literal', dyn_ast, iid, val)
+    res_low = call_if_exists('imaginary_literal', dyn_ast, iid, val)
+    if res_low != None:
+        return res_low
+    elif res_high != None:
+        return res_high
+    return val
+
+def _literal_(dyn_ast, iid, val):
+    res = call_if_exists('literal', dyn_ast, iid, val)
     return res if res != None else val
 
-def _delete_(iid, del_expr):
-    del_expr()
+def _delete_(dyn_ast, iid, del_target):
+    target = del_target()
+    call_if_exists('mem_access', dyn_ast, iid, target)
+    cancel = call_if_exists('delete', dyn_ast, iid, target)
+    if cancel:
+        pass
+    else:
+        del target
 
-def _raise_(iid, raise_arg):
-    raise_arg()
+def _attr_(dyn_ast, iid, base, attr):
+    val = getattr(base, attr)
+    result = call_if_exists('attribute', dyn_ast, iid, base, attr, val)
+    return result if result != None else val
+
+def _sub_(dyn_ast, iid, base, sl):
+    sub = []
+    for i in sl:
+        if not isinstance(i, tuple):
+            sub.append(i)
+        else:
+            sub.append(slice(i[0], i[1], i[2]))
+    if len(sub) == 1:
+        val = base[sub[0]]
+    else:
+        val = base[tuple(sub)]
+    result = call_if_exists('subscript', dyn_ast, iid, base, sl, val)
+    return result if result != None else val
+
+def _try_(dyn_ast, iid):
+    call_if_exists('enter_try', dyn_ast, iid)
+
+def _end_try_(dyn_ast, iid):
+    call_if_exists('clean_exit_try', dyn_ast, iid)
+
+def _exc_(dyn_ast, iid, exc=None, name=None):
+    call_if_exists('exception', dyn_ast, iid, exc, name)
+
+def _raise_(dyn_ast, iid, exc=None, cause=None):
+    exc, cause = call_if_exists('raise_stmt', dyn_ast, iid, exc(), cause)
+    if exc == None:
+        raise
+    else:
+        if cause == None:
+            raise exc
+        else:
+            raise exc from cause
 
 def _catch_(exception):
+    t, v, stack_trace = exc_info()
+    call_if_exists('uncaught_exception', exception, stack_trace)
     raise exception
 
-def _read_var_(iid, name_arg, var_arg):
+def _read_(dyn_ast, iid, var_arg):
     value = var_arg()
-    result = call_if_exists('read_var', iid, name_arg, value, False)
+    call_if_exists('mem_access', dyn_ast, iid, value)
+    result = call_if_exists('read', dyn_ast, iid, value)
     return result if result != None else value
 
-def _condition_(iid, val):
-    result = call_if_exists('condition', iid, val)
+def _condition_(dyn_ast, iid, val):
+    result = call_if_exists('condition', dyn_ast, iid, val)
     return result if result != None else val
 
-def _func_entry_(iid):
+def _func_entry_(dyn_ast, iid, args):
+    call_if_exists('func_enter', dyn_ast, iid, args)
+
+def _func_exit_(dyn_ast, iid):
+    call_if_exists('func_exit', dyn_ast, iid, None)
     return
 
-def _func_exit_(iid, return_val=None):
+def _return_(dyn_ast, iid, return_val=None):
+    result_high = call_if_exists('func_exit', dyn_ast, iid, return_val)
+    result_low = call_if_exists('return_stmt', dyn_ast, iid, return_val)
+    if result_low != None:
+        return result_low
+    elif result_high != None:
+        return result_high
     return return_val
 
-def _jump_(iid, is_break):
-    return True
+def _yield_(dyn_ast, iid, return_val=None):
+    result_high = call_if_exists('func_exit', dyn_ast, iid, return_val)
+    result_low = call_if_exists('yield_stmt', dyn_ast, iid, return_val)
+    if result_low != None:
+        return result_low
+    elif result_high != None:
+        return result_high
+    return return_val
+
+def _lambda_(dyn_ast, iid, args, expr):
+    _func_entry_(dyn_ast, iid, args)
+    res = expr()
+    return _return_(dyn_ast, iid, res)
+
+def _break_(dyn_ast, iid):
+    result = call_if_exists('break_stmt', dyn_ast, iid)
+    return result if result != None else True
 
-def _enter_ctrl_flow_(iid, condition):
-    result = call_if_exists('enter_ctrl_flow', iid, condition)
+def _continue_(dyn_ast, iid):
+    result = call_if_exists('continue_stmt', dyn_ast, iid)
+    return result if result != None else True
+
+def _enter_ctrl_flow_(dyn_ast, iid, condition):
+    result = call_if_exists('enter_ctrl_flow', dyn_ast, iid, condition)
     return result if result != None else condition
 
-def _exit_ctrl_flow_(iid):
-    call_if_exists('exit_ctrl_flow', iid)
+def _exit_ctrl_flow_(dyn_ast, iid):
+    call_if_exists('exit_ctrl_flow', dyn_ast, iid)
 
-def _gen_(iid, iterator):
+def _gen_(dyn_ast, iid, iterator):
     new_iter = iterator.__iter__()
     while True:
         try:
             it = next(new_iter)
-            result = _enter_ctrl_flow_(iid, True)
+            result = _enter_ctrl_flow_(dyn_ast, iid, True)
             if (result != None) and (result == False):
                 return
             yield it
         except StopIteration:
-            return
+            return
+
+def _expr_(dyn_ast, iid, expr):
+    call_if_exists('pre_expression', dyn_ast, iid)
+    result = expr()
+    new_result = call_if_exists('post_expression', dyn_ast, iid, result)
+    return new_result if new_result != None else result