diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/GenerateHtmlDoc.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/GenerateHtmlDoc.java
index 859bc95..d8d787e 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/GenerateHtmlDoc.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/GenerateHtmlDoc.java
@@ -14,6 +14,7 @@
 import com.android.tools.r8.graph.FieldAccessFlags;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedClasses.ClassAnnotation;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedClasses.FieldAnnotation;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedClasses.MethodAnnotation;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedClasses.SupportedClass;
 import com.android.tools.r8.utils.AndroidApiLevel;
@@ -24,7 +25,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
-import java.util.stream.StreamSupport;
 
 public class GenerateHtmlDoc extends AbstractGenerateFiles {
 
@@ -92,7 +92,8 @@
   private abstract static class SourceBuilder<B extends GenerateHtmlDoc.SourceBuilder> {
 
     protected final DexClass clazz;
-    protected List<DexEncodedField> fields = new ArrayList<>();
+    protected Map<DexEncodedField, FieldAnnotation> fields =
+        new TreeMap<>(Comparator.comparing(DexEncodedField::getReference));
     protected Map<DexEncodedMethod, MethodAnnotation> constructors =
         new TreeMap<>(Comparator.comparing(DexEncodedMethod::getReference));
     protected Map<DexEncodedMethod, MethodAnnotation> methods =
@@ -110,8 +111,8 @@
 
     public abstract B self();
 
-    private B addField(DexEncodedField field) {
-      fields.add(field);
+    private B addField(DexEncodedField field, FieldAnnotation fieldAnnotation) {
+      fields.put(field, fieldAnnotation);
       return self();
     }
 
@@ -396,6 +397,18 @@
       return this;
     }
 
+    private String getTextAnnotations(FieldAnnotation annotation) {
+      if (annotation == null) {
+        return "";
+      }
+      StringBuilder stringBuilder = new StringBuilder();
+      if (annotation.unsupportedInMinApiRange) {
+        stringBuilder.append(SUP_3);
+        unsupportedInMinApiRange = true;
+      }
+      return stringBuilder.toString();
+    }
+
     private String getTextAnnotations(MethodAnnotation annotation) {
       if (annotation == null) {
         return "";
@@ -434,13 +447,14 @@
               "ul style=\"list-style-position:inside; list-style-type: none !important;"
                   + " margin-left:0px;padding-left:0px !important;\"");
       if (!fields.isEmpty()) {
-        for (DexEncodedField field : fields) {
+        for (DexEncodedField field : fields.keySet()) {
           builder.appendLiCode(
               accessFlags(field.accessFlags)
                   + " "
                   + typeInPackage(field.getReference().type)
                   + " "
-                  + field.getReference().name);
+                  + field.getReference().name
+                  + getTextAnnotations(fields.get(field)));
         }
       }
       if (!constructors.isEmpty()) {
@@ -514,15 +528,13 @@
     DexClass clazz = supportedClass.getClazz();
     SourceBuilder<HTMLSourceBuilder> builder =
         new HTMLSourceBuilder(clazz, supportedClass.getClassAnnotation());
-    // We need to extend to support fields.
-    StreamSupport.stream(clazz.fields().spliterator(), false)
-        .filter(field -> field.accessFlags.isPublic() || field.accessFlags.isProtected())
-        .sorted(Comparator.comparing(DexEncodedField::toSourceString))
-        .forEach(builder::addField);
+    supportedClass.forEachFieldAndAnnotation(
+        (field, fieldAnnotation) -> {
+          builder.addField(field, fieldAnnotation);
+        });
     supportedClass.forEachMethodAndAnnotation(
         (method, methodAnnotation) -> {
-          if ((method.accessFlags.isPublic() || method.accessFlags.isProtected())
-              && !method.accessFlags.isBridge()) {
+          if (!method.accessFlags.isBridge()) {
             builder.addMethod(method, methodAnnotation);
           }
         });
@@ -534,7 +546,7 @@
     PrintStream ps = new PrintStream(Files.newOutputStream(outputDirectory.resolve("apis.html")));
 
     SupportedClasses supportedClasses =
-        new SupportedMethodsGenerator(options)
+        new SupportedClassesGenerator(options)
             .run(desugaredLibraryImplementation, desugaredLibrarySpecificationPath);
 
     // Full classes added.
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/GenerateLintFiles.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/GenerateLintFiles.java
index b7a1a27..0f35e69 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/GenerateLintFiles.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/GenerateLintFiles.java
@@ -244,7 +244,7 @@
     AndroidApiLevel compilationLevel =
         desugaredLibrarySpecification.getRequiredCompilationApiLevel();
     SupportedClasses supportedMethods =
-        new SupportedMethodsGenerator(options)
+        new SupportedClassesGenerator(options)
             .run(desugaredLibraryImplementation, desugaredLibrarySpecificationPath);
     System.out.println("Generating lint files for compile API " + compilationLevel);
     generateLintFiles(compilationLevel, AndroidApiLevel.B, supportedMethods);
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/SupportedClasses.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/SupportedClasses.java
index 32f1bf9..ed82660 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/SupportedClasses.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/SupportedClasses.java
@@ -5,7 +5,9 @@
 package com.android.tools.r8.ir.desugar.desugaredlibrary.lint;
 
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.google.common.collect.ImmutableList;
@@ -36,17 +38,23 @@
     private final DexClass clazz;
     private final ClassAnnotation classAnnotation;
     private final List<DexEncodedMethod> supportedMethods;
+    private final List<DexEncodedField> supportedFields;
     private final Map<DexMethod, MethodAnnotation> methodAnnotations;
+    private final Map<DexField, FieldAnnotation> fieldAnnotations;
 
     private SupportedClass(
         DexClass clazz,
         ClassAnnotation classAnnotation,
         List<DexEncodedMethod> supportedMethods,
-        Map<DexMethod, MethodAnnotation> methodAnnotations) {
+        List<DexEncodedField> supportedFields,
+        Map<DexMethod, MethodAnnotation> methodAnnotations,
+        Map<DexField, FieldAnnotation> fieldAnnotations) {
       this.clazz = clazz;
       this.classAnnotation = classAnnotation;
       this.supportedMethods = supportedMethods;
+      this.supportedFields = supportedFields;
       this.methodAnnotations = methodAnnotations;
+      this.fieldAnnotations = fieldAnnotations;
     }
 
     public DexType getType() {
@@ -76,6 +84,16 @@
       return methodAnnotations.get(method);
     }
 
+    public void forEachFieldAndAnnotation(BiConsumer<DexEncodedField, FieldAnnotation> biConsumer) {
+      for (DexEncodedField supportedField : supportedFields) {
+        biConsumer.accept(supportedField, getFieldAnnotation(supportedField.getReference()));
+      }
+    }
+
+    public FieldAnnotation getFieldAnnotation(DexField field) {
+      return fieldAnnotations.get(field);
+    }
+
     static Builder builder(DexClass clazz) {
       return new Builder(clazz);
     }
@@ -84,26 +102,39 @@
 
       private final DexClass clazz;
       private ClassAnnotation classAnnotation;
-      private final Map<DexMethod, DexEncodedMethod> supportedMethods = new IdentityHashMap<>();
+      private final List<DexEncodedMethod> supportedMethods = new ArrayList<>();
+      private final List<DexEncodedField> supportedFields = new ArrayList<>();
       private final Map<DexMethod, MethodAnnotation> methodAnnotations = new HashMap<>();
+      private final Map<DexField, FieldAnnotation> fieldAnnotations = new HashMap<>();
 
       private Builder(DexClass clazz) {
         this.clazz = clazz;
       }
 
       void forEachMethods(BiConsumer<DexClass, Collection<DexEncodedMethod>> biConsumer) {
-        biConsumer.accept(clazz, supportedMethods.values());
+        biConsumer.accept(clazz, supportedMethods);
       }
 
       void forEachMethod(BiConsumer<DexClass, DexEncodedMethod> biConsumer) {
-        for (DexEncodedMethod dexEncodedMethod : supportedMethods.values()) {
+        for (DexEncodedMethod dexEncodedMethod : supportedMethods) {
           biConsumer.accept(clazz, dexEncodedMethod);
         }
       }
 
+      void forEachField(BiConsumer<DexClass, DexEncodedField> biConsumer) {
+        for (DexEncodedField dexEncodedField : supportedFields) {
+          biConsumer.accept(clazz, dexEncodedField);
+        }
+      }
+
       void addSupportedMethod(DexEncodedMethod method) {
         assert method.getHolderType() == clazz.type;
-        supportedMethods.put(method.getReference(), method);
+        supportedMethods.add(method);
+      }
+
+      void addSupportedField(DexEncodedField field) {
+        assert field.getHolderType() == clazz.type;
+        supportedFields.add(field);
       }
 
       void annotateClass(ClassAnnotation annotation) {
@@ -119,18 +150,26 @@
         methodAnnotations.put(method, annotation.combine(prev));
       }
 
+      void annotateField(DexField field, FieldAnnotation annotation) {
+        assert field.getHolderType() == clazz.type;
+        FieldAnnotation prev = fieldAnnotations.getOrDefault(field, FieldAnnotation.getDefault());
+        fieldAnnotations.put(field, annotation.combine(prev));
+      }
+
       MethodAnnotation getMethodAnnotation(DexMethod method) {
         return methodAnnotations.get(method);
       }
 
       SupportedClass build() {
-        List<DexEncodedMethod> supportedMethodsSorted = new ArrayList<>(supportedMethods.values());
-        supportedMethodsSorted.sort(Comparator.comparing(DexEncodedMethod::getReference));
+        supportedMethods.sort(Comparator.comparing(DexEncodedMethod::getReference));
+        supportedFields.sort(Comparator.comparing(DexEncodedField::getReference));
         return new SupportedClass(
             clazz,
             classAnnotation,
-            ImmutableList.copyOf(supportedMethodsSorted),
-            methodAnnotations);
+            ImmutableList.copyOf(supportedMethods),
+            ImmutableList.copyOf(supportedFields),
+            methodAnnotations,
+            fieldAnnotations);
       }
     }
   }
@@ -155,6 +194,12 @@
           .forEach(classBuilder -> classBuilder.forEachMethod(biConsumer));
     }
 
+    void forEachClassAndField(BiConsumer<DexClass, DexEncodedField> biConsumer) {
+      supportedClassBuilders
+          .values()
+          .forEach(classBuilder -> classBuilder.forEachField(biConsumer));
+    }
+
     void addSupportedMethod(DexClass holder, DexEncodedMethod method) {
       SupportedClass.Builder classBuilder =
           supportedClassBuilders.computeIfAbsent(
@@ -162,6 +207,13 @@
       classBuilder.addSupportedMethod(method);
     }
 
+    void addSupportedField(DexClass holder, DexEncodedField field) {
+      SupportedClass.Builder classBuilder =
+          supportedClassBuilders.computeIfAbsent(
+              holder.type, clazz -> SupportedClass.builder(holder));
+      classBuilder.addSupportedField(field);
+    }
+
     void annotateClass(DexType type, ClassAnnotation annotation) {
       SupportedClass.Builder classBuilder = supportedClassBuilders.get(type);
       assert classBuilder != null;
@@ -174,6 +226,12 @@
       classBuilder.annotateMethod(method, annotation);
     }
 
+    void annotateField(DexField field, FieldAnnotation annotation) {
+      SupportedClass.Builder classBuilder = supportedClassBuilders.get(field.getHolderType());
+      assert classBuilder != null;
+      classBuilder.annotateField(field, annotation);
+    }
+
     void annotateMethodIfPresent(DexMethod method, MethodAnnotation annotation) {
       SupportedClass.Builder classBuilder = supportedClassBuilders.get(method.getHolderType());
       if (classBuilder == null) {
@@ -219,62 +277,17 @@
     }
   }
 
-  public static class MethodAnnotation {
-
-    private static final MethodAnnotation COVARIANT_RETURN_SUPPORTED =
-        new MethodAnnotation(false, false, true, false, -1, -1);
-    private static final MethodAnnotation DEFAULT =
-        new MethodAnnotation(false, false, false, false, -1, -1);
-    private static final MethodAnnotation PARALLEL_STREAM_METHOD =
-        new MethodAnnotation(true, false, false, false, -1, -1);
-    private static final MethodAnnotation MISSING_FROM_LATEST_ANDROID_JAR =
-        new MethodAnnotation(false, true, false, false, -1, -1);
-
-    // ParallelStream methods are not supported when the runtime api level is strictly below 21.
-    final boolean parallelStreamMethod;
-    // Methods not in the latest android jar but still fully supported.
-    final boolean missingFromLatestAndroidJar;
-    // Methods not supported in a given min api range.
+  public abstract static class MemberAnnotation {
     final boolean unsupportedInMinApiRange;
-    final boolean covariantReturnSupported;
     final int minRange;
     final int maxRange;
 
-    MethodAnnotation(
-        boolean parallelStreamMethod,
-        boolean missingFromLatestAndroidJar,
-        boolean covariantReturnSupported,
-        boolean unsupportedInMinApiRange,
-        int minRange,
-        int maxRange) {
-      this.parallelStreamMethod = parallelStreamMethod;
-      this.missingFromLatestAndroidJar = missingFromLatestAndroidJar;
-      this.covariantReturnSupported = covariantReturnSupported;
+    MemberAnnotation(boolean unsupportedInMinApiRange, int minRange, int maxRange) {
       this.unsupportedInMinApiRange = unsupportedInMinApiRange;
       this.minRange = minRange;
       this.maxRange = maxRange;
     }
 
-    public static MethodAnnotation getCovariantReturnSupported() {
-      return COVARIANT_RETURN_SUPPORTED;
-    }
-
-    public static MethodAnnotation getDefault() {
-      return DEFAULT;
-    }
-
-    public static MethodAnnotation getParallelStreamMethod() {
-      return PARALLEL_STREAM_METHOD;
-    }
-
-    public static MethodAnnotation getMissingFromLatestAndroidJar() {
-      return MISSING_FROM_LATEST_ANDROID_JAR;
-    }
-
-    public static MethodAnnotation createMissingInMinApi(int api) {
-      return new MethodAnnotation(false, false, false, true, api, api);
-    }
-
     public boolean isUnsupportedInMinApiRange() {
       return unsupportedInMinApiRange;
     }
@@ -287,17 +300,7 @@
       return maxRange;
     }
 
-    public boolean isCovariantReturnSupported() {
-      return covariantReturnSupported;
-    }
-
-    public MethodAnnotation combine(MethodAnnotation other) {
-      if (this == getDefault()) {
-        return other;
-      }
-      if (other == getDefault()) {
-        return this;
-      }
+    int combineRange(MemberAnnotation other) {
       int newMin, newMax;
       if (!unsupportedInMinApiRange && !other.unsupportedInMinApiRange) {
         newMin = newMax = -1;
@@ -325,6 +328,106 @@
           }
         }
       }
+      assert newMax < (1 << 15) && newMin < (1 << 15);
+      return (newMax << 16) + newMin;
+    }
+  }
+
+  public static class FieldAnnotation extends MemberAnnotation {
+
+    private static final FieldAnnotation DEFAULT = new FieldAnnotation(false, -1, -1);
+
+    FieldAnnotation(boolean unsupportedInMinApiRange, int minRange, int maxRange) {
+      super(unsupportedInMinApiRange, minRange, maxRange);
+    }
+
+    public static FieldAnnotation getDefault() {
+      return DEFAULT;
+    }
+
+    public static FieldAnnotation createMissingInMinApi(int api) {
+      return new FieldAnnotation(true, api, api);
+    }
+
+    public FieldAnnotation combine(FieldAnnotation other) {
+      if (this == getDefault()) {
+        return other;
+      }
+      if (other == getDefault()) {
+        return this;
+      }
+      int newRange = combineRange(other);
+      int newMax = newRange >> 16;
+      int newMin = newRange & 0xFF;
+      return new FieldAnnotation(
+          unsupportedInMinApiRange || other.unsupportedInMinApiRange, newMin, newMax);
+    }
+  }
+
+  public static class MethodAnnotation extends MemberAnnotation {
+
+    private static final MethodAnnotation COVARIANT_RETURN_SUPPORTED =
+        new MethodAnnotation(false, false, true, false, -1, -1);
+    private static final MethodAnnotation DEFAULT =
+        new MethodAnnotation(false, false, false, false, -1, -1);
+    private static final MethodAnnotation PARALLEL_STREAM_METHOD =
+        new MethodAnnotation(true, false, false, false, -1, -1);
+    private static final MethodAnnotation MISSING_FROM_LATEST_ANDROID_JAR =
+        new MethodAnnotation(false, true, false, false, -1, -1);
+
+    // ParallelStream methods are not supported when the runtime api level is strictly below 21.
+    final boolean parallelStreamMethod;
+    // Methods not in the latest android jar but still fully supported.
+    final boolean missingFromLatestAndroidJar;
+    // Methods not supported in a given min api range.
+    final boolean covariantReturnSupported;
+    MethodAnnotation(
+        boolean parallelStreamMethod,
+        boolean missingFromLatestAndroidJar,
+        boolean covariantReturnSupported,
+        boolean unsupportedInMinApiRange,
+        int minRange,
+        int maxRange) {
+      super(unsupportedInMinApiRange, minRange, maxRange);
+      this.parallelStreamMethod = parallelStreamMethod;
+      this.missingFromLatestAndroidJar = missingFromLatestAndroidJar;
+      this.covariantReturnSupported = covariantReturnSupported;
+    }
+
+    public static MethodAnnotation getCovariantReturnSupported() {
+      return COVARIANT_RETURN_SUPPORTED;
+    }
+
+    public static MethodAnnotation getDefault() {
+      return DEFAULT;
+    }
+
+    public static MethodAnnotation getParallelStreamMethod() {
+      return PARALLEL_STREAM_METHOD;
+    }
+
+    public static MethodAnnotation getMissingFromLatestAndroidJar() {
+      return MISSING_FROM_LATEST_ANDROID_JAR;
+    }
+
+    public static MethodAnnotation createMissingInMinApi(int api) {
+      return new MethodAnnotation(false, false, false, true, api, api);
+    }
+
+    public boolean isCovariantReturnSupported() {
+      return covariantReturnSupported;
+    }
+
+    public MethodAnnotation combine(MethodAnnotation other) {
+      if (this == getDefault()) {
+        return other;
+      }
+      if (other == getDefault()) {
+        return this;
+      }
+      int newRange = combineRange(other);
+      int newMax = newRange >> 16;
+      int newMin = newRange & 0xFF;
       return new MethodAnnotation(
           parallelStreamMethod || other.parallelStreamMethod,
           missingFromLatestAndroidJar || other.missingFromLatestAndroidJar,
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/SupportedMethodsGenerator.java b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/SupportedClassesGenerator.java
similarity index 87%
rename from src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/SupportedMethodsGenerator.java
rename to src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/SupportedClassesGenerator.java
index 752262f..d6c50b4 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/SupportedMethodsGenerator.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/desugaredlibrary/lint/SupportedClassesGenerator.java
@@ -15,12 +15,14 @@
 import com.android.tools.r8.graph.AppInfoWithClassHierarchy;
 import com.android.tools.r8.graph.DexApplication;
 import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexProgramClass;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.DirectMappedDexApplication;
+import com.android.tools.r8.graph.FieldResolutionResult;
 import com.android.tools.r8.graph.MethodAccessFlags;
 import com.android.tools.r8.graph.MethodResolutionResult;
 import com.android.tools.r8.ir.desugar.BackportedMethodRewriter;
@@ -28,6 +30,7 @@
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibrarySpecification;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.DesugaredLibrarySpecificationParser;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedClasses.ClassAnnotation;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedClasses.FieldAnnotation;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedClasses.MethodAnnotation;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.machinespecification.MachineDesugaredLibrarySpecification;
 import com.android.tools.r8.shaking.MainDexInfo;
@@ -47,13 +50,13 @@
 import java.util.Set;
 import java.util.concurrent.ExecutorService;
 
-public class SupportedMethodsGenerator {
+public class SupportedClassesGenerator {
 
   private static final String ANDROID_JAR_PATTERN = "third_party/android_jar/lib-v%d/android.jar";
 
   private final InternalOptions options;
 
-  public SupportedMethodsGenerator(InternalOptions options) {
+  public SupportedClassesGenerator(InternalOptions options) {
     this.options = options;
   }
 
@@ -61,7 +64,7 @@
       throws IOException {
     SupportedClasses.Builder builder = SupportedClasses.builder();
     // First analyze everything which is supported when desugaring for api 1.
-    collectSupportedMethodsInB(desugaredLibraryImplementation, specification, builder);
+    collectSupportedMembersInB(desugaredLibraryImplementation, specification, builder);
     // Second annotate all apis which are partially and/or fully supported.
     AndroidApp library =
         AndroidApp.builder()
@@ -71,7 +74,7 @@
         new ApplicationReader(library, options, Timing.empty()).read().toDirect();
     annotateMethodsNotOnLatestAndroidJar(appForMax, builder);
     annotateParallelMethods(builder);
-    annotatePartialDesugaringMethods(builder, specification);
+    annotatePartialDesugaringMembers(builder, specification);
     annotateClasses(builder, appForMax);
     return builder.build();
   }
@@ -103,7 +106,7 @@
         });
   }
 
-  private void annotatePartialDesugaringMethods(
+  private void annotatePartialDesugaringMembers(
       SupportedClasses.Builder builder, Path specification) throws IOException {
     for (int api = AndroidApiLevel.K.getLevel();
         api <= MAX_TESTED_ANDROID_API_LEVEL.getLevel();
@@ -149,8 +152,7 @@
             if (machineSpecification.getEmulatedInterfaces().containsKey(dexMethod.getHolderType())
                 && encodedMethod.isStatic()) {
               // Static methods on emulated interfaces are always supported if the emulated
-              // interface is
-              // supported.
+              // interface is supported.
               return;
             }
             MethodResolutionResult methodResolutionResult =
@@ -163,6 +165,23 @@
               builder.annotateMethod(dexMethod, MethodAnnotation.createMissingInMinApi(finalApi));
             }
           });
+
+      builder.forEachClassAndField(
+          (clazz, encodedField) -> {
+            if (machineSpecification.isContextTypeMaintainedOrRewritten(
+                    encodedField.getHolderType())
+                || machineSpecification
+                    .getStaticFieldRetarget()
+                    .containsKey(encodedField.getReference())) {
+              return;
+            }
+            FieldResolutionResult fieldResolutionResult =
+                appInfo.resolveField(encodedField.getReference());
+            if (fieldResolutionResult.isFailedResolution()) {
+              builder.annotateField(
+                  encodedField.getReference(), FieldAnnotation.createMissingInMinApi(finalApi));
+            }
+          });
     }
   }
 
@@ -193,7 +212,7 @@
     return Paths.get(jar);
   }
 
-  private void collectSupportedMethodsInB(
+  private void collectSupportedMembersInB(
       Collection<Path> desugaredLibraryImplementation,
       Path specification,
       SupportedClasses.Builder builder)
@@ -264,6 +283,12 @@
             builder.addSupportedMethod(clazz, method);
           }
           addBackports(clazz, backports, builder, amendedAppForMax);
+          for (DexEncodedField field : clazz.fields()) {
+            if (!field.isPublic() && !field.isProtected()) {
+              continue;
+            }
+            builder.addSupportedField(clazz, field);
+          }
         }
       }
     }
@@ -284,6 +309,24 @@
           assert dexEncodedMethod != null;
           builder.addSupportedMethod(dexClass, dexEncodedMethod);
         });
+
+    machineSpecification
+        .getStaticFieldRetarget()
+        .forEach(
+            (field, rewritten) -> {
+              DexClass dexClass = implementationApplication.definitionFor(field.getHolderType());
+              if (dexClass != null) {
+                DexEncodedField dexEncodedField = dexClass.lookupField(field);
+                if (dexEncodedField != null) {
+                  builder.addSupportedField(dexClass, dexEncodedField);
+                  return;
+                }
+              }
+              dexClass = amendedAppForMax.definitionFor(field.getHolderType());
+              DexEncodedField dexEncodedField = dexClass.lookupField(field);
+              assert dexEncodedField != null;
+              builder.addSupportedField(dexClass, dexEncodedField);
+            });
   }
 
   private void addBackports(
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/PartialDesugaringTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/PartialDesugaringTest.java
index 7240267..6e3ea69 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/PartialDesugaringTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/PartialDesugaringTest.java
@@ -4,6 +4,7 @@
 
 package com.android.tools.r8.desugar.desugaredlibrary;
 
+import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK11;
 import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK11_MINIMAL;
 import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK11_PATH;
 import static com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification.JDK8;
@@ -12,9 +13,12 @@
 
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.desugar.desugaredlibrary.test.LibraryDesugaringSpecification;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexMember;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedClasses;
-import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedMethodsGenerator;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedClasses.MemberAnnotation;
+import com.android.tools.r8.ir.desugar.desugaredlibrary.lint.SupportedClassesGenerator;
 import com.android.tools.r8.utils.AndroidApiLevel;
 import com.android.tools.r8.utils.InternalOptions;
 import com.google.common.collect.ImmutableList;
@@ -116,36 +120,66 @@
               + " java.time.format.DateTimeFormatterBuilder.appendGenericZoneText(java.time.format.TextStyle,"
               + " java.util.Set)");
 
+  private static final Set<String> FAILURES_JAPANESE_ERA =
+      ImmutableSet.of("Field java.time.chrono.JapaneseEra java.time.chrono.JapaneseEra.REIWA");
+
   @Test
   public void test() throws Exception {
     SupportedClasses supportedClasses =
-        new SupportedMethodsGenerator(new InternalOptions())
+        new SupportedClassesGenerator(new InternalOptions())
             .run(librarySpecification.getDesugarJdkLibs(), librarySpecification.getSpecification());
 
     for (AndroidApiLevel api : getRelevantApiLevels()) {
-      Set<DexMethod> localFailures = Sets.newIdentityHashSet();
+
+      Set<DexMethod> localMethodFailures = Sets.newIdentityHashSet();
+      Set<DexField> localFieldFailures = Sets.newIdentityHashSet();
+
       supportedClasses.forEachClass(
-          supportedClass ->
-              supportedClass.forEachMethodAndAnnotation(
-                  (method, annotation) -> {
-                    if (annotation != null && annotation.isUnsupportedInMinApiRange()) {
-                      if (api.getLevel() >= annotation.getMinRange()
-                          && api.getLevel() <= annotation.getMaxRange()) {
-                        localFailures.add(method.getReference());
-                      }
-                    }
-                  }));
-      Set<String> expectedFailures = getExpectedFailures(api);
-      Set<String> apiFailuresString =
-          localFailures.stream().map(DexMethod::toString).collect(Collectors.toSet());
-      if (!expectedFailures.equals(apiFailuresString)) {
-        System.out.println("Failure for api " + api);
-        assertEquals(expectedFailures, apiFailuresString);
-      }
+          supportedClass -> {
+            supportedClass.forEachMethodAndAnnotation(
+                (method, annotation) -> {
+                  if (missingFromRange(api, annotation)) {
+                    localMethodFailures.add(method.getReference());
+                  }
+                });
+            supportedClass.forEachFieldAndAnnotation(
+                (field, annotation) -> {
+                  if (missingFromRange(api, annotation)) {
+                    localFieldFailures.add(field.getReference());
+                  }
+                });
+          });
+
+      assertStringEqualsAtApi(localFieldFailures, getExpectedFieldFailures(api), api);
+      assertStringEqualsAtApi(localMethodFailures, getExpectedMethodFailures(api), api);
     }
   }
 
-  private Set<String> getExpectedFailures(AndroidApiLevel api) {
+  private void assertStringEqualsAtApi(
+      Set<? extends DexMember<?, ?>> found, Set<String> expected, AndroidApiLevel api) {
+    Set<String> apiFailuresString =
+        found.stream().map(DexMember::toString).collect(Collectors.toSet());
+    assertEquals("Failure for api " + api, expected, apiFailuresString);
+  }
+
+  private boolean missingFromRange(AndroidApiLevel api, MemberAnnotation annotation) {
+    if (annotation != null && annotation.isUnsupportedInMinApiRange()) {
+      return api.getLevel() >= annotation.getMinRange()
+          && api.getLevel() <= annotation.getMaxRange();
+    }
+    return false;
+  }
+
+  private Set<String> getExpectedFieldFailures(AndroidApiLevel api) {
+    if (librarySpecification == JDK11 || librarySpecification == JDK11_PATH) {
+      if (api.isGreaterThanOrEqualTo(AndroidApiLevel.O) && api.isLessThan(AndroidApiLevel.R)) {
+        return FAILURES_JAPANESE_ERA;
+      }
+    }
+    return ImmutableSet.of();
+  }
+
+  private Set<String> getExpectedMethodFailures(AndroidApiLevel api) {
     Set<String> expectedFailures = new HashSet<>();
     boolean jdk11NonMinimal = librarySpecification != JDK8 && librarySpecification != JDK11_MINIMAL;
     if (jdk11NonMinimal && api.isGreaterThanOrEqualTo(AndroidApiLevel.N)) {