docs: private void checkFieldInitialization(ClassTree tree, VisitorState state) {
      FieldInitEntities entities = collectEntities(tree, state);
      Symbol.ClassSymbol classSymbol = ASTHelpers.getSymbol(tree);
      class2Entities.put(classSymbol, entities);
      // set of all non-null instance fields f such that *some* constructor does not initialize f
      Set<Symbol> notInitializedInConstructors;
      SetMultimap<MethodTree, Symbol> constructorInitInfo;
      if (entities.constructors().isEmpty()) {
        constructorInitInfo = null;
        notInitializedInConstructors = entities.nonnullInstanceFields();
      } else {
        constructorInitInfo = checkConstructorInitialization(entities, state);
        notInitializedInConstructors = ImmutableSet.copyOf(constructorInitInfo.values());
      }
      class2ConstructorUninit.putAll(classSymbol, notInitializedInConstructors);
      Set<Symbol> notInitializedAtAll =
          notAssignedInAnyInitializer(entities, notInitializedInConstructors, state);
      SetMultimap<Element, Element> errorFieldsForInitializer = LinkedHashMultimap.create();
      // non-null if we have a single initializer method
      Symbol.MethodSymbol singleInitializerMethod = null;
      if (entities.instanceInitializerMethods().size() == 1) {
        singleInitializerMethod =
            ASTHelpers.getSymbol(entities.instanceInitializerMethods().iterator().next());
      }
      for (Symbol uninitField : notInitializedAtAll) {
        if (singleInitializerMethod != null) {
          // report it on the initializer
          errorFieldsForInitializer.put(singleInitializerMethod, uninitField);
        } else if (constructorInitInfo == null) {
          // report it on the field, except in the case where the class is externalInit and
          // we have no initializer methods
          if (!(isExternalInit(classSymbol) && entities.instanceInitializerMethods().isEmpty())) {
            errorBuilder.reportInitErrorOnField(
                uninitField, state, buildDescription(getTreesInstance(state).getTree(uninitField)));
          }
        } else {
          // report it on each constructor that does not initialize it
          for (MethodTree methodTree : constructorInitInfo.keySet()) {
            Set<Symbol> uninitFieldsForConstructor = constructorInitInfo.get(methodTree);
            if (uninitFieldsForConstructor.contains(uninitField)) {
              errorFieldsForInitializer.put(ASTHelpers.getSymbol(methodTree), uninitField);
            }
          }
        }
      }
      for (Element constructorElement : errorFieldsForInitializer.keySet()) {
        errorBuilder.reportInitializerError(
            (Symbol.MethodSymbol) constructorElement,
            errMsgForInitializer(errorFieldsForInitializer.get(constructorElement)),
            state,
            buildDescription(getTreesInstance(state).getTree(constructorElement)));
      }
      // For static fields
      Set<Symbol> notInitializedStaticFields = notInitializedStatic(entities, state);
      for (Symbol uninitSField : notInitializedStaticFields) {
        // Always report it on the field for static fields (can't do @SuppressWarnings on a static
        // initialization block
        // anyways).
        errorBuilder.reportInitErrorOnField(
            uninitSField, state, buildDescription(getTreesInstance(state).getTree(uninitSField)));
      }
    }