--- a/js/src/jsinfer.cpp
+++ b/js/src/jsinfer.cpp
@@ -3991,17 +3991,16 @@ TypeZone::sweep(FreeOp *fop, bool releas
             comp->types.sweep(fop);
     }
 
     {
         gcstats::AutoPhase ap2(rt->gcStats, gcstats::PHASE_CLEAR_SCRIPT_ANALYSIS);
         for (CellIterUnderGC i(zone(), FINALIZE_SCRIPT); !i.done(); i.next()) {
             JSScript *script = i.get<JSScript>();
             script->clearAnalysis();
-            script->clearPropertyReadTypes();
         }
     }
 
     {
         gcstats::AutoPhase ap2(rt->gcStats, gcstats::PHASE_FREE_TI_ARENA);
         rt->freeLifoAlloc.transferFrom(&oldAlloc);
     }
 }

--- a/js/src/jsinfer.h
+++ b/js/src/jsinfer.h
@@ -107,17 +107,16 @@ namespace jit {
 }
 
 namespace analyze {
     class ScriptAnalysis;
 }
 
 namespace types {
 
-class TypeCallsite;
 class TypeCompartment;
 class TypeSet;
 
 /* Type set entry for either a JSObject with singleton type or a non-singleton TypeObject. */
 struct TypeObjectKey {
     static intptr_t keyBits(TypeObjectKey *obj) { return (intptr_t) obj; }
     static TypeObjectKey *getKey(TypeObjectKey *obj) { return obj; }
 };
@@ -1136,23 +1135,16 @@ class TypeScript
 
     /*
      * List mapping indexes of bytecode type sets to the offset of the opcode
      * they correspond to. Cleared on each GC.
      */
     uint32_t *bytecodeMap;
 
   public:
-    /*
-     * Array of type sets storing the possible inputs to property reads.
-     * Generated the first time the script is analyzed by inference and kept
-     * after analysis purges.
-     */
-    HeapTypeSet *propertyReadTypes;
-
     /* Array of type type sets for variables and JOF_TYPESET ops. */
     TypeSet *typeArray() const { return (TypeSet *) (uintptr_t(this) + sizeof(TypeScript)); }
 
     static inline unsigned NumTypeSets(JSScript *script);
 
     static inline StackTypeSet *ThisTypes(JSScript *script);
     static inline StackTypeSet *ArgTypes(JSScript *script, unsigned i);
 

--- a/js/src/jsinferinlines.h
+++ b/js/src/jsinferinlines.h
@@ -1554,23 +1554,16 @@ inline void
 JSScript::clearAnalysis()
 {
     if (types) {
         types->analysis = NULL;
         types->bytecodeMap = NULL;
     }
 }
 
-inline void
-JSScript::clearPropertyReadTypes()
-{
-    if (types && types->propertyReadTypes)
-        types->propertyReadTypes = NULL;
-}
-
 namespace js {
 
 template <>
 struct GCMethods<const types::Type>
 {
     static types::Type initial() { return types::Type::UnknownType(); }
     static ThingRootKind kind() { return THING_ROOT_TYPE; }
     static bool poisoned(const types::Type &v) {

--- a/js/src/jsscript.h
+++ b/js/src/jsscript.h
@@ -837,18 +837,16 @@ class JSScript : public js::gc::Barriere
 
     /* Ensure the script has type inference analysis information. */
     inline bool ensureRanInference(JSContext *cx);
 
     inline bool hasAnalysis();
     inline void clearAnalysis();
     inline js::analyze::ScriptAnalysis *analysis();
 
-    inline void clearPropertyReadTypes();
-
     inline js::GlobalObject &global() const;
     js::GlobalObject &uninlinedGlobal() const;
 
     /* See StaticScopeIter comment. */
     JSObject *enclosingStaticScope() const {
         if (isCallsiteClone)
             return NULL;
         return enclosingScopeOrOriginalFunction_;