anchor.diff:        }
       });
   
  -    if (info.isEmpty && !shouldKeep(libEntity)) return null;
       result.libraries.add(info);
       return info;
     }
   
  -  GlobalTypeInferenceMemberResult _resultOfMember(MemberEntity e) =>
  -      _globalInferenceResults.resultOfMember(e);
  -
     AbstractValue _resultOfParameter(Local e) =>
         _globalInferenceResults.resultOfParameter(e);
   
     FieldInfo visitField(ir.Field field, {FieldEntity fieldEntity}) {
  -    AbstractValue inferredType = _resultOfMember(fieldEntity).type;
  -    // If a field has an empty inferred type it is never used.
  -    if (inferredType == null ||
  -        closedWorld.abstractValueDomain
  -            .isEmpty(inferredType)
  -            .isDefinitelyTrue) {
  -      return null;
  -    }
  -
  -    int size = dumpInfoTask.sizeOf(fieldEntity);
  -    List<CodeSpan> code = dumpInfoTask.codeOf(fieldEntity);
  -
  -    // TODO(het): Why doesn't `size` account for the code size already?
  -    if (code != null) size += code.length;
  -
       FieldInfo info = FieldInfo(
           name: field.name.text,
           type: field.type.toStringInternal(),
  -        inferredType: '$inferredType',
  -        code: code,
  -        outputUnit: _unitInfoForMember(fieldEntity),
  -        isConst: field.isConst);
  +        inferredType: null,
  +        code: null,
  +        outputUnit: null,
  +        isConst: field.isConst,
  +        size: null);
       _entityToInfo[fieldEntity] = info;
  -    FieldAnalysisData fieldData =
  -        closedWorld.fieldAnalysis.getFieldData(fieldEntity);
  -    if (fieldData.initialValue != null) {
  -      info.initializer = _constantToInfo[fieldData.initialValue];
  -    }
   
       if (compiler.options.experimentCallInstrumentation) {
         // We use field.hashCode because it is globally unique and it is
  
positive.code:       info.coverageId = '${field.hashCode}';
      }
  
      int closureSize = _addClosureInfo(info, fieldEntity);
      info.size = size + closureSize;
  
      result.fields.add(info);
      return info;
    }
  
    ClassTypeInfo visitClassType(ClassEntity clazz) {
      // Omit class type if it is not needed.
      ClassTypeInfo classTypeInfo = ClassTypeInfo(
          name: clazz.name, outputUnit: _unitInfoForClassType(clazz));
  
      // TODO(joshualitt): Get accurate size information for class types.
      classTypeInfo.size = 0;
  
      bool isNeeded =
          compiler.backendStrategy.emitterTask.neededClassTypes.contains(clazz);
      if (!isNeeded) {
        return null;
      }
  
      result.classTypes.add(classTypeInfo);
      return classTypeInfo;
    }
  
negative.code:       final classEntity = environment.lookupClass(libEntity, clazz.name);
        if (classEntity == null) return;
  
        ClassTypeInfo classTypeInfo = visitClassType(clazz);
        if (classTypeInfo != null) {
          info.classTypes.add(classTypeInfo);
          classTypeInfo.parent = info;
  