QoL improvements to python_to_native and compiler_cache

typed_python/compiler/expression_conversion_context.py

@@ -119,7 +119,7 @@ def allocateClassMethodDispatchSlot(self, clsType, methodName, retType, argTuple
         # the first argument indicates whether this is an instance or type-level dispatch
         assert argTupleType.ElementTypes[0].Value in ('type', 'instance')
 
-        identHash = self.converter.hashObjectToIdentity(
+        identHash = self.converter.hash_object_to_identity(
             (clsType, methodName, retType, argTupleType, kwargTupleType)
         )
 
@@ -1141,7 +1141,7 @@ def call_py_function(self, f, args, kwargs, returnTypeOverload=None):
                 funcGlobals[f.__code__.co_freevars[i]] = f.__closure__[i].cell_contents
                 globalsInCells.append(f.__code__.co_freevars[i])
 
-        call_target = self.functionContext.converter.convert(
+        call_target = self.functionContext.converter.convert_python_to_native(
             f.__name__,
             f.__code__,
             funcGlobals,
@@ -1185,7 +1185,7 @@ def call_overload(self, overload, funcObj, args, kwargs, returnTypeOverload=None
         else:
             returnType = typeWrapper(overload.returnType) if overload.returnType is not None else None
 
-        call_target = self.functionContext.converter.convert(
+        call_target = self.functionContext.converter.convert_python_to_native(
             overload.name,
             overload.functionCode,
             overload.realizedGlobals,
@@ -1474,7 +1474,7 @@ def namedVariableLookup(self, name):
         return None
 
     def expressionAsFunctionCall(self, name, args, generatingFunction, identity, outputType=None, alwaysRaises=False):
-        callTarget = self.converter.defineNonPythonFunction(
+        callTarget = self.converter.define_non_python_function(
             name,
             ("expression", identity),
             typed_python.compiler.function_conversion_context.ExpressionFunctionConversionContext(

typed_python/compiler/function_conversion_context.py

@@ -621,17 +621,17 @@ def __iter__(self) -> generatorBaseclass:
 
         returnSlot.convert_copy_initialize(output)
 
-        context.converter.triggerVirtualDestructor(generatorSubclass)
+        context.converter.trigger_virtual_destructor(generatorSubclass)
 
-        context.converter.triggerVirtualMethodInstantiation(
+        context.converter.trigger_virtual_method_instantiation(
             generatorSubclass,
             "__fastnext__",
             PointerTo(T),
             Tuple("instance"),
             NamedTuple()
         )
 
-        context.converter.triggerVirtualMethodInstantiation(
+        context.converter.trigger_virtual_method_instantiation(
             generatorSubclass,
             "__next__",
             T,

typed_python/compiler/llvm_compiler.py

@@ -124,7 +124,7 @@ def buildSharedObject(self, functions):
             serializedGlobalVariableDefinitions,
             module.functionNameToType,
             module.globalDependencies,
-            {name: self.converter.totalFunctionComplexity(name) for name in functions},
+            {name: self.converter.total_function_complexity(name) for name in functions},
             {name: self.converter._functions_by_name[name] for name in functions},
             {name: SerializationContext().serialize(self.converter._function_definitions[name]) for name in functions},
         )

typed_python/compiler/llvm_compiler_test.py

@@ -154,7 +154,7 @@ def test_loaded_modules_persist():
         "    return f(x) * 100",
         "g(1000)",
         "def get_loaded_modules():",
-        "    return len(Runtime.singleton().converter.loadedUncachedModules)"
+        "    return len(Runtime.singleton().converter.loaded_uncached_modules)"
     ])
     VERSION1 = {'x.py': xmodule}
     assert evaluateExprInFreshProcess(VERSION1, 'x.get_loaded_modules()') == 1

typed_python/compiler/native_ast_to_llvm.py

@@ -516,7 +516,7 @@ def __init__(self,
         #  a list of the global LLVM names that the function depends on.
         self.global_names = []
         self.module = module
-        self.converter = converter
+        self.converter: Converter = converter
         self.builder = builder
         self.arg_assignments = arg_assignments
         self.output_type = output_type
@@ -665,24 +665,24 @@ def namedCallTargetToLLVM(self, target: native_ast.NamedCallTarget) -> TypedLLVM
             if func.module is not self.module:
                 # first, see if we'd like to inline this module
                 if (
-                    self.converter.totalFunctionComplexity(target.name) < CROSS_MODULE_INLINE_COMPLEXITY
+                    self.converter.total_function_complexity(target.name) < CROSS_MODULE_INLINE_COMPLEXITY
                 ):
-                    func = self.converter.repeatFunctionInModule(target.name, self.module)
+                    func = self.converter.repeat_function_in_module(target.name, self.module)
                 else:
                     if target.name not in self.external_function_references:
                         self.external_function_references[target.name] = \
                             llvmlite.ir.Function(self.module, func.function_type, func.name)
 
                     func = self.external_function_references[target.name]
         else:
-            assert self.compilerCache is not None and self.compilerCache.hasSymbol(target.name)
+            assert self.compilerCache is not None and self.compilerCache.has_symbol(target.name)
             # this function is defined in a shared object that we've loaded from a prior
             # invocation. Again, first make an inlining decision.
             if (
-                self.compilerCache.complexityForSymbol(target.name) < CROSS_MODULE_INLINE_COMPLEXITY
+                self.compilerCache.complexity_for_symbol(target.name) < CROSS_MODULE_INLINE_COMPLEXITY
             ):
-                self.converter.generateDefinition(target.name)
-                func = self.converter.repeatFunctionInModule(target.name, self.module)
+                self.converter.generate_definition(target.name)
+                func = self.converter.repeat_function_in_module(target.name, self.module)
             else:
                 if target.name not in self.external_function_references:
                     func_type = llvmlite.ir.FunctionType(
@@ -1518,7 +1518,7 @@ def __init__(self, compilerCache=None):
 
         self.compilerCache = compilerCache
 
-    def totalFunctionComplexity(self, name):
+    def total_function_complexity(self, name):
         """Return the total number of instructions contained in a function.
 
         The function must already have been defined in a prior pass. We use this
@@ -1535,19 +1535,19 @@ def totalFunctionComplexity(self, name):
 
         return res
 
-    def generateDefinition(self, name: str) -> None:
+    def generate_definition(self, name: str) -> None:
         """Pull the TypedCallTarget matching `name` from the cache, and use to rebuild
         the function definition. Add to _function_definitions and _functions_by_name.
         """
         assert self.compilerCache is not None
 
-        definition = self.compilerCache.getDefinition(name)
-        llvm_func = self.compilerCache.getIR(name)
+        definition = self.compilerCache.get_definition(name)
+        llvm_func = self.compilerCache.get_IR(name)
 
         self._functions_by_name[name] = llvm_func
         self._function_definitions[name] = definition
 
-    def repeatFunctionInModule(self, name, module):
+    def repeat_function_in_module(self, name, module):
         """Request that the function given by 'name' be inlined into 'module'.
 
         It must already have been defined in another module.