--- a/js/src/jit/IonCode.h
+++ b/js/src/jit/IonCode.h
@@ -14,27 +14,27 @@
 
 #include "gc/Heap.h"
 #include "jit/ExecutableAllocator.h"
 #include "jit/ICStubSpace.h"
 #include "jit/IonOptimizationLevels.h"
 #include "jit/IonTypes.h"
 #include "js/UbiNode.h"
 #include "vm/TraceLogging.h"
-#include "vm/TypeInference.h"
 
 namespace js {
 namespace jit {
 
-class MacroAssembler;
 class IonBuilder;
+class JitAllocPolicy;
 class JitCode;
+class MacroAssembler;
 
-typedef Vector<JSObject*, 4, JitAllocPolicy> ObjectVector;
-typedef Vector<TraceLoggerEvent, 0, SystemAllocPolicy> TraceLoggerEventVector;
+using ObjectVector = Vector<JSObject*, 4, JitAllocPolicy>;
+using TraceLoggerEventVector = Vector<TraceLoggerEvent, 0, SystemAllocPolicy>;
 
 // Header at start of raw code buffer
 struct JitCodeHeader
 {
     // Link back to corresponding gcthing
     JitCode*    jitCode_;
 
     // !!! NOTE !!!

--- a/js/src/jit/IonTypes.h
+++ b/js/src/jit/IonTypes.h
@@ -5,24 +5,48 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef jit_IonTypes_h
 #define jit_IonTypes_h
 
 #include "mozilla/HashFunctions.h"
 
 #include <algorithm>
+#include <stdint.h>
 
 #include "jsfriendapi.h"
 #include "jstypes.h"
 
 #include "js/Value.h"
 #include "vm/StringType.h"
 
 namespace js {
+
+// Each IonScript has a unique compilation id. This is used to sweep/ignore
+// constraints for IonScripts that have been invalidated/destroyed.
+class IonCompilationId
+{
+    // Use two 32-bit integers instead of uint64_t to avoid 8-byte alignment on
+    // some 32-bit platforms.
+    uint32_t idLo_;
+    uint32_t idHi_;
+
+  public:
+    explicit IonCompilationId(uint64_t id)
+      : idLo_(id & UINT32_MAX),
+        idHi_(id >> 32)
+    {}
+    bool operator==(const IonCompilationId& other) const {
+        return idLo_ == other.idLo_ && idHi_ == other.idHi_;
+    }
+    bool operator!=(const IonCompilationId& other) const {
+        return !operator==(other);
+    }
+};
+
 namespace jit {
 
 typedef uint32_t RecoverOffset;
 typedef uint32_t SnapshotOffset;
 typedef uint32_t BailoutId;
 
 // The maximum size of any buffer associated with an assembler or code object.
 // This is chosen to not overflow a signed integer, leaving room for an extra

--- a/js/src/vm/TypeInference.h
+++ b/js/src/vm/TypeInference.h
@@ -1183,38 +1183,16 @@ class TypeNewScript
 };
 
 /* Is this a reasonable PC to be doing inlining on? */
 inline bool isInlinableCall(jsbytecode* pc);
 
 bool
 ClassCanHaveExtraProperties(const Class* clasp);
 
-// Each IonScript has a unique compilation id. This is used to sweep/ignore
-// constraints for IonScripts that have been invalidated/destroyed.
-class IonCompilationId
-{
-    // Use two 32-bit integers instead of uint64_t to avoid 8-byte alignment on
-    // some 32-bit platforms.
-    uint32_t idLo_;
-    uint32_t idHi_;
-
-  public:
-    explicit IonCompilationId(uint64_t id)
-      : idLo_(id & UINT32_MAX),
-        idHi_(id >> 32)
-    {}
-    bool operator==(const IonCompilationId& other) const {
-        return idLo_ == other.idLo_ && idHi_ == other.idHi_;
-    }
-    bool operator!=(const IonCompilationId& other) const {
-        return !operator==(other);
-    }
-};
-
 class RecompileInfo
 {
     JSScript* script_;
     IonCompilationId id_;
 
   public:
     RecompileInfo(JSScript* script, IonCompilationId id)
       : script_(script),