Put items, keys, and values in lists.

kernel/modelverse_jit/bytecode_interpreter.py

@@ -290,7 +290,7 @@ def interpret_bytecode_function(function_name, body_bytecode, local_arguments, k
     gc_root_node, = yield [("CN", [])]
     gc_root_edge, = yield [("CE", [task_root, gc_root_node])]
     interpreter = InterpreterState(gc_root_node, keyword_arguments)
-    for param_id, arg_node in local_arguments.items():
+    for param_id, arg_node in list(local_arguments.items()):
         yield [("CALL_ARGS", [interpreter.import_local, (param_id, arg_node)])]
 
     def __handle_return(exception):

kernel/modelverse_jit/bytecode_to_cfg.py

@@ -68,7 +68,7 @@ class AnalysisState(object):
                     has_value=False))
 
         self.root_node = self.current_block.append_definition(cfg_ir.AllocateRootNode())
-        for node_id, name in param_dict.items():
+        for node_id, name in list(param_dict.items()):
             variable = bytecode_ir.VariableNode(node_id, name)
             self.current_block.append_definition(cfg_ir.DeclareLocal(variable, self.root_node))
             param_i = self.current_block.append_definition(cfg_ir.ResolveLocal(variable))

kernel/modelverse_jit/cfg_optimization.py

@@ -69,7 +69,7 @@ def merge_blocks(entry_point):
             source.append_definition(target_def)
 
         source.flow = target.flow
-        for preds in predecessor_map.values():
+        for preds in list(predecessor_map.values()):
             if target in preds:
                 preds[preds.index(target)] = source
                 # preds.remove(target)
@@ -511,7 +511,7 @@ def elide_gc_protects(entry_point):
                         ineligible_defs.add(definition)
 
     # Elide all GC protections for definitions which are not in the `ineligible_defs` set.
-    for protected, protections in def_protections.items():
+    for protected, protections in list(def_protections.items()):
         if protected not in ineligible_defs:
             for protect_def in protections:
                 protect_def.redefine(cfg_ir.Literal(None))

kernel/modelverse_jit/cfg_ssa_construction.py

@@ -195,7 +195,7 @@ class SSAConstructionState(object):
         if self.has_sealed(block):
             return
 
-        for node_id, phi_def in self.incomplete_phis[block].items():
+        for node_id, phi_def in list(self.incomplete_phis[block].items()):
             self.add_phi_operands(node_id, phi_def)
 
         self.sealed_blocks.add(block)
@@ -251,7 +251,7 @@ class SSAConstructionState(object):
             # Find all pairs phis which are defined in the branch target block.
             applicable_pairs = [
                 (phi_def, operand_def)
-                for phi_def, operand_def in self.extra_phi_operands[block].items()
+                for phi_def, operand_def in list(self.extra_phi_operands[block].items())
                 if phi_def.block == branch.block]
 
             if len(applicable_pairs) == 0:

kernel/modelverse_jit/cfg_to_tree.py

@@ -236,16 +236,16 @@ def to_relooper_multiple_or_loop(graph_component):
         return to_relooper_loop(graph_component)
 
     next_entries = set(graph_component.entry_blocks)
-    for block_set in exclusive_entries.values():
+    for block_set in list(exclusive_entries.values()):
         for elem in block_set:
             directly_reachable = graph_component.get_directly_reachable_blocks(elem)
             directly_reachable.remove(elem)
             next_entries.update(directly_reachable)
 
-    next_entries.difference_update(exclusive_entries.keys())
+    next_entries.difference_update(list(exclusive_entries.keys()))
 
     result = MultipleLoopBlock({}, None)
-    for entry, exclusive_blocks in exclusive_entries.items():
+    for entry, exclusive_blocks in list(exclusive_entries.items()):
         other_blocks = set(graph_component.blocks)
         other_blocks.difference_update(exclusive_blocks)
         result.handled_blocks[entry] = reloop(
@@ -295,7 +295,7 @@ def find_inlinable_definitions(entry_point):
 
     # Find all definitions which are eligible for inlining.
     eligible_defs = set()
-    for definition, users in def_users.items():
+    for definition, users in list(def_users.items()):
         if len(users) == 1:
             single_user = next(iter(users))
             if def_blocks[single_user] == def_blocks[definition]:
@@ -543,7 +543,7 @@ class DependencyDefinitionScheduler(object):
         if len(self.dependency_graph) == 0:
             return None
 
-        for node in self.dependency_graph.keys():
+        for node in list(self.dependency_graph.keys()):
             if not self.has_dependents(node):
                 return node
 

kernel/modelverse_jit/intrinsics.py

@@ -486,15 +486,15 @@ def register_time_intrinsic(target_jit):
 
 def register_intrinsics(target_jit):
     """Registers all intrinsics in the module with the given JIT."""
-    for (key, value) in BINARY_INTRINSICS.items():
+    for (key, value) in list(BINARY_INTRINSICS.items()):
         target_jit.register_binary_intrinsic(key, value)
-    for (key, value) in UNARY_INTRINSICS.items():
+    for (key, value) in list(UNARY_INTRINSICS.items()):
         target_jit.register_unary_intrinsic(key, value)
-    for (key, value) in CAST_INTRINSICS.items():
+    for (key, value) in list(CAST_INTRINSICS.items()):
         target_jit.register_cast_intrinsic(key, value)
-    for (key, value) in MISC_INTRINSICS.items():
+    for (key, value) in list(MISC_INTRINSICS.items()):
         target_jit.register_intrinsic(key, value)
-    for (key, value) in MISC_CFG_INTRINSICS.items():
+    for (key, value) in list(MISC_CFG_INTRINSICS.items()):
         target_jit.register_cfg_intrinsic(key, value)
 
     register_time_intrinsic(target_jit)

kernel/modelverse_jit/jit.py

@@ -86,7 +86,7 @@ def create_function(
                 tree_ir.LoadLocalInstruction(jit_runtime.KWARGS_PARAMETER_NAME),
                 tree_ir.LiteralInstruction('task_root')),
             jit_runtime.LOCALS_EDGE_NAME))
-    for (key, val) in param_dict.items():
+    for (key, val) in list(param_dict.items()):
         arg_ptr = tree_ir.create_new_local_node(
             body_param_dict[key],
             tree_ir.LoadLocalInstruction(jit_runtime.LOCALS_NODE_NAME))
@@ -727,7 +727,7 @@ def compile_function_body_interpret(jit, function_name, body_id, task_root, head
     """Create a function that invokes the interpreter on the given function."""
     (parameter_ids, parameter_list, _), = yield [
         ("CALL_ARGS", [jit.jit_signature, (body_id,)])]
-    param_dict = dict(zip(parameter_ids, parameter_list))
+    param_dict = dict(list(zip(parameter_ids, parameter_list)))
     body_bytecode, = yield [("CALL_ARGS", [jit.jit_parse_bytecode, (body_id,)])]
     def __interpret_function(**kwargs):
         if header is not None:
@@ -737,7 +737,7 @@ def compile_function_body_interpret(jit, function_name, body_id, task_root, head
 
         local_args = {}
         inner_kwargs = dict(kwargs)
-        for param_id, name in param_dict.items():
+        for param_id, name in list(param_dict.items()):
             local_args[param_id] = inner_kwargs[name]
             del inner_kwargs[name]
 
@@ -754,8 +754,8 @@ def compile_function_body_baseline(
     """Have the baseline JIT compile the function with the given name and body id."""
     (parameter_ids, parameter_list, _), = yield [
         ("CALL_ARGS", [jit.jit_signature, (body_id,)])]
-    param_dict = dict(zip(parameter_ids, parameter_list))
-    body_param_dict = dict(zip(parameter_ids, [p + "_ptr" for p in parameter_list]))
+    param_dict = dict(list(zip(parameter_ids, parameter_list)))
+    body_param_dict = dict(list(zip(parameter_ids, [p + "_ptr" for p in parameter_list])))
     body_bytecode, = yield [("CALL_ARGS", [jit.jit_parse_bytecode, (body_id,)])]
     state = bytecode_to_tree.AnalysisState(
         jit, body_id, task_root, body_param_dict,
@@ -782,7 +782,7 @@ def compile_function_body_fast(jit, function_name, body_id, _):
     """Have the fast JIT compile the function with the given name and body id."""
     (parameter_ids, parameter_list, _), = yield [
         ("CALL_ARGS", [jit.jit_signature, (body_id,)])]
-    param_dict = dict(zip(parameter_ids, parameter_list))
+    param_dict = dict(list(zip(parameter_ids, parameter_list)))
     body_bytecode, = yield [("CALL_ARGS", [jit.jit_parse_bytecode, (body_id,)])]
     bytecode_analyzer = bytecode_to_cfg.AnalysisState(jit, function_name, param_dict)
     bytecode_analyzer.analyze(body_bytecode)

kernel/modelverse_jit/runtime.py

@@ -146,9 +146,9 @@ def interpret_function_body(body_id, named_arguments, **kwargs):
     # Put the parameters in the new stack frame's symbol table.
     (parameter_vars, parameter_names, _), = yield [
         ("CALL_ARGS", [kernel.jit.jit_signature, (body_id,)])]
-    parameter_dict = dict(zip(parameter_names, parameter_vars))
+    parameter_dict = dict(list(zip(parameter_names, parameter_vars)))
 
-    for (key, value) in named_arguments.items():
+    for (key, value) in list(named_arguments.items()):
         param_var = parameter_dict[key]
         variable, = yield [("CN", [])]
         yield [("CD", [variable, "value", value])]

kernel/modelverse_jit/source_map.py

@@ -20,7 +20,7 @@ class SourceMap(object):
     def __str__(self):
         return '\n'.join(
             ['%d: %s' % pair
-             for pair in sorted(self.lines.items(), key=lambda key: key[0])])
+             for pair in sorted(list(self.lines.items()), key=lambda key: key[0])])
 
 class SourceMapBuilder(object):
     """A type of object that makes it easy to build source maps for hierarchical instructions."""