docs: @Override
      public void visit(int version,
                        int access,
                        String classResourceName,
                        String signature,
                        String superClassResourceName,
                        String interfaceResourceNames[]) {
  
          Object[] logParms;
          if (tc.isDebugEnabled()) {
              logParms = new Object[] { getHashText(), classResourceName };
              Tr.debug(tc, MessageFormat.format("[ {0} ] [ {1} ]", logParms));
          } else {
              logParms = null;
          }
  
          String className = getClassNameFromPartialResourceName(classResourceName);
  
          if (logParms != null) {
              logParms[1] = className + ".class";
          }
  
          if (isPackageName(className)) {
              if ((logParms != null) && tc.isDebugEnabled()) {
                  Tr.debug(tc, MessageFormat.format("[ {0} ] [ {1} ] Package load", logParms));
              }
  
              isClass = false; // Need to remember this for when recording package annotations.
  
              className = stripPackageNameFromClassName(className);
  
              String externalClassName = stripPackageNameFromClassName(getExternalName());
  
              // Note: The package is NOT recorded as a scanned package.
              //       if the package name does not match.
  
              if (!className.equals(externalClassName)) {
                  //  When allowable, we need to add a new message to the repository for the following warning...
                  // Tr.warning(tc, "ANNO_TARGETS_CLASS_MISMATCH", getHashText(), externalClassName);
                  if (tc.isDebugEnabled()) {
                      Tr.debug(tc, "Class name mismatch", getHashText(), externalClassName);
                  }
                  throw VISIT_ENDED_PACKAGE_MISMATCH;
              }
  
              i_className = internClassName(className, Util_InternMap.DO_FORCE); // Remember this for recording annotations.
  
              // if ( !i_recordScannedPackageName(name) ) {
              //     name = null;
              //
              //     Tr.warning(tc, "ANNO_TARGETS_DUPLICATE_PACKAGE", getHashText(), name); // CWWKC0054W
              //     throw VISIT_ENDED_DUPLICATE_PACKAGE;
              // }
  
          } else {
              if (logParms != null && tc.isDebugEnabled()) {
                  Tr.debug(tc, MessageFormat.format("[ {0} ] [ {1} ] Class load", logParms));
              }
  
              isClass = true; // Need to remember this for when recording class annotations.
  
              // Note: The class is NOT recorded as a scanned class when
              //       the internal name was not valid.  If the class was
              //       being processed as an referenced class, the class
              //       will need to be removed from the pending referenced
              //       classes lists by an alternate step.
  
              if (!className.equals(getExternalName())) {
                  //  When allowable, we need to add a new message to the repository for the following warning...
                  //Tr.warning(tc, "ANNO_TARGETS_CLASS_MISMATCH", getHashText(), className); // TODO: CWWKC????W
                  if (tc.isDebugEnabled()) {
                      Tr.debug(tc, "Class name mismatch", getHashText(), className);
                  }
  
                  throw VISIT_ENDED_CLASS_MISMATCH;
              }
  
              i_className = internClassName(className); // Remember this for recording annotations.
  
              if (!i_recordScannedClassName(i_className)) {
                  Tr.warning(tc, "ANNO_TARGETS_DUPLICATE_CLASS", getHashText(), i_className); // CWWKC0055W
                  throw VISIT_ENDED_DUPLICATE_CLASS;
              }
  
              i_removeReferencedClassName(i_className);
  
              if (superClassResourceName != null) {
                  superClassResourceName = getClassNameFromPartialResourceName(superClassResourceName);
  
                  String i_superclassName = internClassName(superClassResourceName);
  
                  i_recordSuperclassName(i_className, i_superclassName);
                  i_recordReferencedClassName(i_superclassName);
              }
  
              if ((interfaceResourceNames != null) && (interfaceResourceNames.length > 0)) {
                  String[] i_interfaceNames = new String[interfaceResourceNames.length];
  
                  for (int nameNo = 0; nameNo < interfaceResourceNames.length; nameNo++) {
                      String nextInterfaceResourceName = interfaceResourceNames[nameNo];
  
                      String nextInterfaceName = getClassNameFromPartialResourceName(nextInterfaceResourceName);
  
                      String i_nextInterfaceName = internClassName(nextInterfaceName);
  
                      i_interfaceNames[nameNo] = i_nextInterfaceName;
                  }
  
                  i_recordInterfaceNames(i_className, i_interfaceNames);
  
                  for (String i_interfaceName : i_interfaceNames) {
                      i_recordReferencedClassName(i_interfaceName);
                  }
              }
          }
      }