docs: public void introspect(IntrospectionWriter writer, String type, int methodId, boolean dumpCMP2xAccessIntent)
      {
          writer.begin(null);
          writer.println("Method signature  = " + methodSignature + ((type != null) ? ("  (" + type + ")") : ""));
          writer.println("Method index      = " + ((methodId != Integer.MAX_VALUE) ? methodId : "unknown"));
          writer.println("TX attribute      = " + MethodAttribUtils.TX_ATTR_STR[txAttr.getValue()]);
  
          if (asAttr != null)
          {
              writer.println("AS attribute      = " + asAttr.toString());
          }
  
          // d493211 start
          // Is this a EJB 1.x module?
          if (bmd.ivModuleVersion <= BeanMetaData.J2EE_EJB_VERSION_1_1)
          {
              // Yep, this is a 1.x module version, so old connection manager is being used.
              // Old connection manager does not allow isolation level to change once set
              // for a transaction.  So dump the isolation level that is used for CMP 1.x access
              // regardless of bean type being processed.  This is done since the first
              // method call in a transaction that is started by a EJB in a 1.x module
              // causes the isolation level for that TX to be set. See preInvokeActivate
              // method in EJSContainer to see the logic for setting TX isolation level.
              writer.println("CMP 1.x Isolation Level = " + MethodAttribUtils.getIsolationLevelString(isolationAttr));
  
              // If this is a CMP 1.x bean, then dump read only attribute for the CMP 1.x bean.
              // Does not apply for other bean types, so only do for CMP 1.x beans. See ContainerManagedBeanO
              // for CMP 1.x implementation since that is the only place that uses the read only attribute
              // (e.g. used to determine if dirty flag should be set for the CMP 1.x bean). Note, WAS does
              // NOT support CMP 2.x beans in a 1.x module, so we do not have to worry about CMP 2.x.
              if (bmd.cmpVersion == InternalConstants.CMP_VERSION_1_X)
              {
                  writer.println("CMP 1.x access intent(read-only attribute) = " + readOnlyAttr);
              }
          }
          else
          {
              // This is a 2.x or later module version, so new J2C connection manager is being used.
              // Is this a CMP 2.x bean and dumpCMP2xAccessIntent is true?
              if (bmd.cmpVersion == InternalConstants.CMP_VERSION_2_X && dumpCMP2xAccessIntent)
              {
                  introspectCMP2xAccessIntent(writer);
              }
              else
              {
                  // Not a CMP 2.x bean in 2.x module or later or dumpCMP2xAccessIntent is false.
                  // We know this is a 2.x or later module version. If this is a CMP 1.x bean, then dump the
                  // CMP 1.x isolation level and read only attribute.  Only do this for CMP 1.x rather
                  // than all EJB types since preInvokeActivate in EJSContainer only sets TX
                  // isolation level when module version is 2.x or later when the EJB type is CMP 1.x.
                  if (bmd.cmpVersion == InternalConstants.CMP_VERSION_1_X)
                  {
                      writer.println("CMP 1.x Isolation Level = " + MethodAttribUtils.getIsolationLevelString(isolationAttr));
                      writer.println("CMP 1.x access intent(read-only attribute) = " + readOnlyAttr);
                  }
              }
          }
          // d493211 end
          writer.println("isAsynchMethod    = " + ivAsynchMethod);
          writer.println("JDI signature     = " + jdiMethodSignature);
  
          //F743-1752CodRev start
          if (isSingletonSessionBean) //F743-1752.1
          {
  
              if (bmd.ivSingletonUsesBeanManagedConcurrency)
              {
                  writer.println("Singleton LockType       = Bean Managed");
              }
              else
              {
                  String lockType = null;
                  if (ivLockType != null)
                  {
                      lockType = ivLockType.name();
                  }
                  else
                  {
                      if (ivInterface == MethodInterface.LIFECYCLE_INTERCEPTOR)
                      {
                          lockType = "not applicable for lifecycle methods";
                      }
                  }
                  writer.println("Singleton LockType       = " + lockType);
                  writer.println("Singleton Access Timeout = " + ivAccessTimeout);
              }
          } //F743-1752CodRev end
          else if (isStatefulSessionBean)
          {
              // dump unique Stateful method data                          F743-22462
              writer.println("Stateful Access Timeout = " + ivAccessTimeout);
          }
  
          introspectDeclaredExceptions(writer);
          introspectSecurityInfo(writer);
          writer.end();
      }