Deduplicate Preloader's checked arg types maps

Summary:
No need to have both of them, we can keep the one with the strong references and
compute hir::Type objects out of it whenever we want.

Reviewed By: mpage

Differential Revision: D78560496

fbshipit-source-id: b2d97148dc1083872caa9b3ecc09db79bff2681c

Author: alexmalyshev

Jit/hir/preload.cpp

@@ -253,7 +253,8 @@ const NativeTarget& Preloader::invokeNativeTarget(BorrowedRef<> target) const {
 }
 
 Type Preloader::checkArgType(long local_idx) const {
-  return map_get(check_arg_types_, local_idx, TObject);
+  auto it = check_arg_types_.find(local_idx);
+  return it != check_arg_types_.end() ? it->second.toHir() : TObject;
 }
 
 PyObject** Preloader::getGlobalCache(BorrowedRef<> name_obj) const {
@@ -290,7 +291,7 @@ std::unique_ptr<Function> Preloader::makeFunction() const {
   irfunc->return_type = return_type_;
   irfunc->has_primitive_args = has_primitive_args_;
   irfunc->has_primitive_first_arg = has_primitive_first_arg_;
-  for (auto& [local, preloaded_type] : check_arg_pytypes_) {
+  for (auto& [local, preloaded_type] : check_arg_types_) {
     irfunc->typed_args.emplace_back(
         local,
         preloaded_type.type,
@@ -493,8 +494,7 @@ bool Preloader::preloadStatic() {
         preloaded_type.type != reinterpret_cast<PyTypeObject*>(&PyObject_Type),
         "shouldn't generate type checks for object");
     Type type = preloaded_type.toHir();
-    check_arg_types_.emplace(local, type);
-    check_arg_pytypes_.emplace(local, std::move(preloaded_type));
+    check_arg_types_.emplace(local, std::move(preloaded_type));
     if (type <= TPrimitive) {
       has_primitive_args_ = true;
       if (local == 0) {

Jit/hir/preload.h

@@ -185,22 +185,7 @@ class Preloader {
     return has_primitive_args_;
   }
 
-  std::unique_ptr<InvokeTarget> resolve_target_descr(
-      BorrowedRef<> descr,
-      int opcode);
-
  private:
-  BorrowedRef<> constArg(BytecodeInstruction& bc_instr) const;
-  PyObject** getGlobalCache(BorrowedRef<> name) const;
-  bool canCacheGlobals() const;
-  bool preload();
-
-  // Preload information only relevant to Static Python functions.
-  bool preloadStatic();
-
-  // Check if a code object is for the top-level code in a module.
-  bool isModuleCodeObject() const;
-
   explicit Preloader(
       BorrowedRef<PyCodeObject> code,
       BorrowedRef<PyDictObject> builtins,
@@ -215,6 +200,21 @@ class Preloader {
     JIT_CHECK(PyCode_Check(code_), "Expected PyCodeObject");
   }
 
+  BorrowedRef<> constArg(BytecodeInstruction& bc_instr) const;
+  PyObject** getGlobalCache(BorrowedRef<> name) const;
+  bool canCacheGlobals() const;
+  bool preload();
+
+  // Preload information only relevant to Static Python functions.
+  bool preloadStatic();
+
+  // Check if a code object is for the top-level code in a module.
+  bool isModuleCodeObject() const;
+
+  std::unique_ptr<InvokeTarget> resolve_target_descr(
+      BorrowedRef<> descr,
+      int opcode);
+
   Ref<PyCodeObject> code_;
   Ref<PyDictObject> builtins_;
   Ref<PyDictObject> globals_;
@@ -227,9 +227,11 @@ class Preloader {
   InvokeTargetMap func_targets_;
   InvokeTargetMap meth_targets_;
   std::unordered_map<PyObject*, std::unique_ptr<NativeTarget>> native_targets_;
-  // keyed by locals index
-  std::unordered_map<long, Type> check_arg_types_;
-  std::map<long, OwnedType> check_arg_pytypes_;
+
+  // Maps locals (by their index) to their type.  This type must be checked at
+  // the start of the function.
+  std::map<long, OwnedType> check_arg_types_;
+
   // keyed by name index, names borrowed from code object
   GlobalNamesMap global_names_;
   Type return_type_{TObject};