docs: private MethodDataWrapper initializeBeanMethodMD(boolean isEntity,
                                                       MethodInterface methodInterface,
                                                       Class<?> interfaceClass,
                                                       Class<?>[] businessInterfaceClasses, // F743-24429
                                                       Method beanMethods[],
                                                       Method implMethods[], // d494984
                                                       String[] entityNoTxAttrMethods,
                                                       String[] entityNoTxAttrMethodSignatures, //PQ63130
                                                       List<?> accessIntentList,
                                                       List<?> isoLevelList,
                                                       List<ContainerTransaction> transactionList,
                                                       List<MethodPermission> securityList,
                                                       ExcludeList excludeList,
                                                       List<ActivitySessionMethod> activitySessionList,
                                                       BeanMetaData bmd,
                                                       ByteCodeMetaData byteCodeMetaData) throws EJBConfigurationException {
          //--------------------------------------------------------
          // Initialize per-method attributes (include place-holder
          // for remove()  method at end of per-method attribute
          // tables)
          //--------------------------------------------------------
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
  
          if (isTraceOn && tc.isEntryEnabled())
              Tr.entry(tc, "initializeBeanMethodMetadata: " + methodInterface + ", " + beanMethods.length);
  
          int metaMethodElementKind = methodInterface.getValue(); // d162441
  
          int numMethods = beanMethods.length;
  
          boolean checkAppConfigCustom = bmd.isCheckConfig(); // F743-33178
  
          // We have to include the remove method of the EJBObject interface,
          // which is filtered out by the DeploymentUtil.getMethods() call.
          // This is not done for the non-EJBObject/EJBLocalObject interfaces
          boolean addRemove = false; // LI2281.07
          if (interfaceClass != null && // d366807
              (methodInterface == MethodInterface.REMOTE ||
               methodInterface == MethodInterface.LOCAL)) {
              addRemove = true;
              numMethods++;
          }
  
          String[] methodNames = new String[numMethods];
          Class<?>[][] methodParamTypes = new Class<?>[numMethods][];
          String[] methodSignatures = new String[numMethods];
          String[] jdiMethodSignatures = new String[numMethods];
          Method[] ejbMethods = new Method[numMethods]; // 366845.9
          boolean[] asynchMethodFlags = new boolean[numMethods];
          Method[] bridgeMethods = new Method[numMethods]; // d517824
          EJBMethodInfoImpl[] methodInfos = new EJBMethodInfoImpl[numMethods];
          EnterpriseBean wccmEnterpriseBean = bmd.wccm.enterpriseBean; // F743-1752.1
          LockType lockType[] = new LockType[numMethods]; // F743-1752.1
          long accessTimeout[] = new long[numMethods]; // F743-1752.1
  
          // NOTE: The method-level isolationAttrs and readOnlyAttrs are only applicable to CMP 1.1
          //       beans.  They are not used for CMP 2.0 beans.  (The application profile function
          //       is used instead for CMP 2.0.)
  
          int[] isolationAttrs = new int[numMethods];
          boolean[] readOnlyAttrs = new boolean[numMethods];
          TransactionAttribute[] transactionAttrs = new TransactionAttribute[numMethods];
  
          boolean[] denyAll = new boolean[numMethods]; //d366845.11.1
          boolean[] permitAll = new boolean[numMethods]; //d366845.11.1
  
          @SuppressWarnings("unchecked")
          ArrayList<String>[] roleArrays = new ArrayList[numMethods]; //d366845.11.1
  
          ActivitySessionAttribute[] activitySessionAttrs = new ActivitySessionAttribute[numMethods]; // LIDB441.5
  
          for (int i = 0; i < beanMethods.length; i++) {
              methodNames[i] = beanMethods[i].getName();
              methodParamTypes[i] = beanMethods[i].getParameterTypes();
              methodSignatures[i] = MethodAttribUtils.methodSignatureOnly(beanMethods[i]);
              jdiMethodSignatures[i] = MethodAttribUtils.jdiMethodSignature(beanMethods[i]);
  
              // For every method from the interface(s), find the corresponding
              // method on the EJB implementation class.  This will be needed
              // to obtain any method level annotations, as the interface
              // methods are NOT annotated.  Also, note that it would be an
              // invalid EJB if the bean does not implement all methods on
              // the configured interfaces.                                  366845.9
              // d571522 - For timed object methods, the interface method might be a
              // non-public method from the bean class.  In that case, we already
              // have the Method object.
              if (methodInterface == MethodInterface.TIMED_OBJECT && !Modifier.isPublic(beanMethods[i].getModifiers())) {
                  ejbMethods[i] = beanMethods[i];
              } else {
                  try {
                      ejbMethods[i] = bmd.enterpriseBeanClass.getMethod(methodNames[i], methodParamTypes[i]);
                  } catch (NoSuchMethodException nsmex) {
                      Tr.error(tc, "BEAN_DOES_NOT_IMPLEMENT_REQUIRED_METHOD_CNTR0157E",
                               new Object[] { bmd.enterpriseBeanName, bmd._moduleMetaData.ivName, beanMethods[i] });
                      throw new EJBConfigurationException("The bean: " + bmd.enterpriseBeanName + " in module: " + bmd._moduleMetaData.ivName +
                                                          " does not implement the required method: " + beanMethods[i]);
                  }
              }
  
              // d494984.1
              // If the ejbMethod is a bridge method, then replace with the target
              // of the bridge method.
              if (ejbMethods[i].isBridge()) {
                  bridgeMethods[i] = ejbMethods[i];
                  ejbMethods[i] = byteCodeMetaData.getBridgeMethodTarget(ejbMethods[i]); // F61004.1
  
                  if (ejbMethods[i] == null) {
                      //FFDCFilter.processException(e, CLASS_NAME + ".initializeBeanMethodMD", "2452", this);
  
                      // Note, when looking for target of a bridge method, using the toGenericString() method
                      // on the Method object from interface class returns a method signature that contains
                      // the generic types used as method parameters and return types.
                      String genericInterfaceMethod = beanMethods[i].toGenericString();
  
                      // CNTR8992E: This message is an English-only Error message: {0}.
                      String errorMessage = "Failure occured while attempting to find the target of a bridge method for the "
                                            + bmd.enterpriseBeanName + " enterprise bean in the " + bmd._moduleMetaData.ivName + " module."
                                            + " The java compiler generates a synthetic bridge method in the enterprise bean class for the generic "
                                            + genericInterfaceMethod + " method of inteface " + beanMethods[i].getDeclaringClass().getName();
                      Tr.error(tc, "ENGLISH_ONLY_ERROR_MESSAGE_CNTR8992E", errorMessage);
                      throw new EJBConfigurationException(errorMessage, byteCodeMetaData.getScanException());
                  }
              }
  
              // Initialize isolationAttrs to TX_NONE (unspecified) by default.  Portability layer
              // will do the correct thing to replace Tx_None with the proper value, depending on DB type.
              isolationAttrs[i] = java.sql.Connection.TRANSACTION_NONE;
  
          } // for all bean methods
  
          // Special case the remove method of the EJBObject interface
          if (addRemove) {
              int lastMethodIndex = numMethods - 1;
              methodNames[lastMethodIndex] = "remove";
              methodParamTypes[lastMethodIndex] = NO_PARAMS;
              methodSignatures[lastMethodIndex] = "";
              jdiMethodSignatures[lastMethodIndex] = "()V";
              ejbMethods[lastMethodIndex] = null; // internal method   366845.9
              readOnlyAttrs[lastMethodIndex] = false;
              isolationAttrs[lastMethodIndex] = java.sql.Connection.TRANSACTION_NONE;
  
              // remove is an 'internal' method, and the tx attribute cannot be set
              // via annotations, so set the default here; XML may still override.
              if (bmd.usesBeanManagedTx)
                  transactionAttrs[lastMethodIndex] = TransactionAttribute.TX_BEAN_MANAGED;
              else
                  transactionAttrs[lastMethodIndex] = (isEntity) ? TransactionAttribute.TX_REQUIRED : TransactionAttribute.TX_NOT_SUPPORTED;
  
              // LIDB441.5
              if (bmd.usesBeanManagedAS) // d127328 - do this independent of ActivityPolicyKind
                  activitySessionAttrs[lastMethodIndex] = ActivitySessionAttribute.AS_BEAN_MANAGED;
              else
                  activitySessionAttrs[lastMethodIndex] = ActivitySessionAttribute.AS_SUPPORTS;
          }
  
          //Process the Security MetaData       //366845.11
  
          // Process methods to exclude via security from WCCM. If there is no excludeList,
          // then any methods to exclude must have been specified via annotations.  //PK93643
          if (excludeList != null) {
              // Process all method-permission elements.   //d366845.11.1
              MethodAttribUtils.getXMLMethodsDenied(denyAll,
                                                    metaMethodElementKind,
                                                    methodNames,
                                                    methodParamTypes,
                                                    excludeList,
                                                    bmd); //PK93643
  
              if (isTraceOn && tc.isDebugEnabled()) {
                  Tr.debug(tc, "denyAll = " + Arrays.toString(denyAll));
              }
          }
  
          // Process all Security Attributes from WCCM. If there is no excludeList,
          // then any security attributes must have been specified via annotations.  //PK93643
          if (securityList != null) { //PK93643
              MethodAttribUtils.getXMLPermissions(roleArrays,
                                                  permitAll,
                                                  denyAll,
                                                  metaMethodElementKind,
                                                  methodNames,
                                                  methodParamTypes,
                                                  securityList,
                                                  bmd); //PK93643
          }
  
          // If not marked MetaDataComplete then look for
          // security annotation information.    //366845.11.2
          if (!bmd.metadataComplete) {
              MethodAttribUtils.getAnnotationsForSecurity(ejbMethods,
                                                          roleArrays,
                                                          denyAll,
                                                          permitAll);
          }
  
          // F743-1751 - Factored out transaction logic.
          initializeBeanMethodTransactionAttributes(isEntity,
                                                    addRemove,
                                                    methodInterface,
                                                    ejbMethods,
                                                    entityNoTxAttrMethods,
                                                    entityNoTxAttrMethodSignatures,
                                                    transactionList,
                                                    activitySessionList,
                                                    methodNames,
                                                    methodParamTypes,
                                                    methodSignatures,
                                                    transactionAttrs,
                                                    activitySessionAttrs,
                                                    bmd);
  
          if (bmd.ivModuleVersion <= BeanMetaData.J2EE_EJB_VERSION_1_1 ||
              bmd.cmpVersion == InternalConstants.CMP_VERSION_1_X) {
              //Need Isolation level for
              //1) All beans in Java EE 1.2 app
              //2) CMP11 beans ONLY in Java EE 1.3 app
              getIsolationLevels(isolationAttrs, // F743-18775
                                 metaMethodElementKind,
                                 methodNames,
                                 methodParamTypes,
                                 isoLevelList,
                                 wccmEnterpriseBean);
  
              if (bmd.cmpVersion == InternalConstants.CMP_VERSION_1_X) {
                  getReadOnlyAttributes(readOnlyAttrs, // F743-18775
                                        metaMethodElementKind,
                                        methodNames,
                                        methodParamTypes,
                                        accessIntentList,
                                        wccmEnterpriseBean);
  
                  readOnlyAttrs[numMethods - 1] = false; //EJBObject.remove() is never read-only, so force it to be read-write
                                                         //in case getReadOnlyAttributes set it to true (e.g., from a method wild-card).
              }
          }
  
          //F743-4582:
          // Process all Asynchronous methods configured via xml. If there is no EnterpriseBean,
          // assume this is an annotations only configuration scenario.
          if (wccmEnterpriseBean != null) {
  
              // 621123 - If any method of the bean is asychronous, set the flag in bmd.  Use bit-wise
              //          OR so that it is not unset by mistake because either XML or annotations happened
              //          to not define an async method for this bean.
              bmd.ivHasAsynchMethod |= MethodAttribUtils.getXMLAsynchronousMethods(asynchMethodFlags,
                                                                                   methodInterface,
                                                                                   methodNames,
                                                                                   methodParamTypes,
                                                                                   wccmEnterpriseBean);
          }
  
          // Next, process all @Asynchronous annotations unless the bean's configuration
          // was completely done via xml.
          if (!bmd.metadataComplete) {
  
              // 621123 - If any method of the bean is asychronous, set the flag in bmd.  Use bit-wise
              //          OR so that it is not unset by mistake because either XML or annotations happened
              //          to not define an async method for this bean.
              bmd.ivHasAsynchMethod |= MethodAttribUtils.getAsynchronousMethods(ejbMethods,
                                                                                asynchMethodFlags,
                                                                                methodInterface); //d599046
          }
  
          // F743-1752.1 start
          // Get Lock and AccessTimeout metadata if EJB is a Singleton session bean and
          // it uses container managed concurrency control.
          boolean singletonWithContainerManagedConcurrency = bmd.isSingletonSessionBean()
                                                             && (bmd.ivSingletonUsesBeanManagedConcurrency == false);
  
          if (singletonWithContainerManagedConcurrency) {
              // The default AccessTimeout for Singletons is to wait forever (-1),
              // unless overridden by a system property.                      d704504
              long defaultTimeout = DefaultSessionAccessTimeout;
  
              // Initialize the settings to an invalid value so annotation processing
              // can tell when the value has been set by XML processing. F743-21028.5
              Arrays.fill(accessTimeout, -2);
  
              // F743-7027 start
              // Process all @Lock/@AccessAsynchronous methods configured via xml. If there is no EnterpriseBean,
              // assume this is an annotations only configuration scenario.
              if (wccmEnterpriseBean != null) {
                  Session sessionBean = (Session) wccmEnterpriseBean;
                  MethodAttribUtils.getXMLCMCLockType(lockType, ejbMethods, sessionBean);
                  MethodAttribUtils.getXMLCMCLockAccessTimeout(accessTimeout, ejbMethods, sessionBean);
              } // F743-7027 end
  
              // Next, process all all @Lock/@AccessTimeout annotations. Note, we need to
              // call even if metadata complete is true since we want default values to be
              // set if nothing was in the ejb-jar.xml for lock and access timeout.
              MethodAttribUtils.getAnnotationCMCLockType(lockType, ejbMethods, bmd);
              MethodAttribUtils.getAnnotationCMCLockAccessTimeout(accessTimeout, ejbMethods,
                                                                  defaultTimeout, bmd.metadataComplete);
          } // F743-1752.1 end
  
          // Also get AccessTimeout metadata for Stateful session beans.  F743-22462
          else if (bmd.isStatefulSessionBean()) {
              // The default AccessTimeout starting in EE6 is to wait forever (-1),
              // though this may be overrident with a system property.
              // Previously, concurrent access of Stateful beans was not supported
              // and resulted in an exception. For compatibility, that would be the
              // same as an AccessTimeout of 0 (don't wait).
              long defaultTimeout = EE5Compatibility ? 0 : DefaultSessionAccessTimeout; // d704504
  
              // Initialize the settings to an invalid value so annotation processing
              // can tell when the value has been set by XML processing.
              Arrays.fill(accessTimeout, -2);
  
              // Process all methods configured via xml. If there is no EnterpriseBean,
              // assume this is an annotations only configuration scenario.
              if (wccmEnterpriseBean != null) {
                  MethodAttribUtils.getXMLCMCLockAccessTimeout(accessTimeout, ejbMethods,
                                                               (Session) wccmEnterpriseBean);
              }
  
              // Next, process all @AccessTimeout annotations. Note, we need to
              // call even if metadata complete is true since we want default values to be
              // set if nothing was in the ejb-jar.xml for lock and access timeout.
              MethodAttribUtils.getAnnotationCMCLockAccessTimeout(accessTimeout, ejbMethods,
                                                                  defaultTimeout, bmd.metadataComplete);
          }
  
          // interfaceClass is null when there is no home interface (business interface only)
          int minInterfaceIndex = interfaceClass == null ? 0 : -1;
          int numBusinessInterfaces = businessInterfaceClasses == null ? 0 : businessInterfaceClasses.length;
          int slotSize = bmd.container.getEJBRuntime().getMetaDataSlotSize(MethodMetaData.class);
  
          // Finally, build up method info objects containing all the configuratin attributes
          // for each ejb method.
  
          for (int i = 0; i < numMethods; i++) {
              String[] rolesAllowed = null;
              if (roleArrays[i] != null && !roleArrays[i].isEmpty()) {
                  rolesAllowed = new String[roleArrays[i].size()];
                  rolesAllowed = roleArrays[i].toArray(new String[0]); //d366845.11.2
              }
  
              if (isTraceOn && tc.isDebugEnabled()) {
                  String ms = (i < beanMethods.length) ? MethodAttribUtils.methodSignature(ejbMethods[i]) : methodNames[i] + MethodAttribUtils.METHOD_ARGLIST_SEP
                                                                                                            + methodSignatures[i]; //d494984.1
                  Tr.debug(tc, "Createing MethodInfo:  methodName = " +
                               methodNames[i] + " methodSignature = " +
                               ms + " PermitAll = " + //d494984.1
                               permitAll[i] + " DenyAll = " + denyAll[i]);
                  Tr.debug(tc, "RolesAllowed = " + Arrays.toString(rolesAllowed));
              }
  
              Class<?>[][] declaredExceptions = null;
              Class<?>[] declaredExceptionsComp = null; // d734957
  
              if (ejbMethods[i] != null) {
                  Class<?> classReturnType = ejbMethods[i].getReturnType();
  
                  if (asynchMethodFlags[i]) {
                      // If the current method is an asynchronous method, and the bean uses CMT transactions, but has an incorrect
                      // TX attribute configured, we can stop now and log an error.  Asynch methods can only have TX attributes of
                      // type TX_REQUIRED, TX_REQUIRES_NEW, or TX_NOT_SUPPORTED configured.
                      if (!bmd.usesBeanManagedTx &&
                          transactionAttrs[i] != TransactionAttribute.TX_REQUIRED &&
                          transactionAttrs[i] != TransactionAttribute.TX_REQUIRES_NEW &&
                          transactionAttrs[i] != TransactionAttribute.TX_NOT_SUPPORTED) {
                          Tr.error(tc, "INVALID_TX_ATTRIBUTE_FOR_ASYNCH_METHOD_CNTR0187E",
                                   new Object[] { methodNames[i], bmd.j2eeName.getComponent(), bmd.j2eeName.getModule(),
                                                  bmd.j2eeName.getApplication(), transactionAttrs[i] });
                          throw new EJBConfigurationException("The " + methodNames[i] +
                                                              " method on the " + bmd.j2eeName.getComponent() +
                                                              " bean in the " + bmd.j2eeName.getModule() +
                                                              " module of the " + bmd.j2eeName.getApplication() +
                                                              " application has a " + transactionAttrs[i] +
                                                              " transaction attribute configured.  Asynchronous methods" +
                                                              " only support transaction attributes of type" +
                                                              " TX_REQUIRED, TX_REQUIRES_NEW, or TX_NOT_SUPPORTED.");
                      }
  
                      // F743-4633
                      // Ensure for async methods the return type is void or Future<V> otherwise throw EJBConfigurationException.
                      if (classReturnType != Void.TYPE && classReturnType != Future.class) {
                          Tr.error(tc, "ASYNC_METHOD_MUST_RETURN_VOID_OR_FUTURE_CNTR0206E",
                                   new Object[] { methodNames[i], bmd.j2eeName.getComponent(), classReturnType.getName() });
                          throw new EJBConfigurationException("CNTR0206E: The " + methodNames[i]
                                                              + " asynchronous method on the " + bmd.j2eeName.getComponent()
                                                              + " bean has a return type of " + classReturnType.getName()
                                                              + ".  A return type of void or Future<V> is required for asynchronous methods.");
                      }
  
                      declaredExceptions = new Class<?>[numBusinessInterfaces][];
                  }
  
                  // Ensure that all the signatures of the business methods declared
                  // on each interface class match the corresponding signatures of
                  // the methods on the bean class.
                  // d668039 - Also check component interfaces by using a special
                  // index of -1.
                  for (int interfaceIndex = minInterfaceIndex; interfaceIndex < numBusinessInterfaces; interfaceIndex++) {
                      Class<?> klass = interfaceIndex >= 0 ? businessInterfaceClasses[interfaceIndex] : interfaceClass; // d668039
  
                      Method method;
                      try {
                          method = klass.getMethod(methodNames[i], methodParamTypes[i]);
                      } catch (NoSuchMethodException ex) {
                          if (isTraceOn && tc.isDebugEnabled())
                              Tr.debug(tc, "method " + beanMethods[i] + " not found on " + klass.getName());
                          continue;
                      }
  
                      // F743-16193 d644502
                      // Ensure the bean return type and the interface return type match
                      Class<?> interfaceReturnType = method.getReturnType();
                      if (!classReturnType.equals(interfaceReturnType)) {
                          // d645058
                          // For asynchronous methods this will be an error condition.
                          // To be compatible with previous versions when this return type checking was not done,
                          // only a warning will be issued when the customer has setup for validation logging.
                          if (asynchMethodFlags[i]) {
                              Tr.error(tc, "INCOMPATIBLE_RETURN_TYPES_CNTR0321E",
                                       new Object[] { classReturnType.getName(), methodNames[i], bmd.j2eeName.getComponent(),
                                                      interfaceReturnType.getName(), klass.getName() });
                              throw new EJBConfigurationException("CNTR0321E: The " + classReturnType.getName()
                                                                  + " return type for the " + methodNames[i]
                                                                  + " method of the " + bmd.j2eeName.getComponent()
                                                                  + " enterprise bean does not match the " + interfaceReturnType.getName()
                                                                  + " return type for the corresponding method on the " + klass.getName()
                                                                  + " interface.");
                          } else if (isValidationLoggable(checkAppConfigCustom)) {
                              Tr.warning(tc, "INCOMPATIBLE_RETURN_TYPES_CNTR0322W",
                                         new Object[] { classReturnType.getName(), methodNames[i], bmd.j2eeName.getComponent(),
                                                        interfaceReturnType.getName(), klass.getName() });
                              if (isValidationFailable(checkAppConfigCustom)) {
                                  throw new EJBConfigurationException("The " + classReturnType.getName() +
                                                                      " return type for the " + methodNames[i] +
                                                                      " method of the " + bmd.j2eeName.getComponent() +
                                                                      " enterprise bean is not compatible with the " + interfaceReturnType.getName() +
                                                                      " return type for the corresponding method on the " + klass.getName() +
                                                                      " interface.");
                              }
                          }
                      }
  
                      if (asynchMethodFlags[i]) {
                          Class<?>[] interfaceDeclaredExceptions = DeploymentUtil.getCheckedExceptions(
                                                                                                       method, Remote.class.isAssignableFrom(klass),
                                                                                                       DeploymentUtil.DeploymentTarget.WRAPPER); // d660332
                          if (interfaceIndex >= 0) {
                              declaredExceptions[interfaceIndex] = interfaceDeclaredExceptions;
                          } else {
                              declaredExceptionsComp = interfaceDeclaredExceptions;
                          }
                          if (classReturnType == Void.TYPE && interfaceDeclaredExceptions.length != 0) {
                              // Pass all the required params to the error message.  F743-4633
                              String exceptionList = "";
                              for (Class<?> exception : interfaceDeclaredExceptions) {
                                  exceptionList += exception.getName() + ", ";
                              }
  
                              Tr.error(tc, "INVALID_APPLICATION_EXCEPTION_FOR_VOID_ASYNCH_METHOD_CNTR0202E",
                                       new Object[] { methodNames[i], bmd.j2eeName.getComponent(), exceptionList });
                              throw new EJBConfigurationException("CNTR0202E: The " + methodNames[i]
                                                                  + " asynchronous method on the " + bmd.j2eeName.getComponent()
                                                                  + " bean has a return type of void and has the " + exceptionList
                                                                  + " application exception(s) on its throws clause.");
                          }
                      }
                  }
              }
  
              // build the method info object of this method
              EJBMethodInfoImpl methodInfoImpl = bmd.createEJBMethodInfoImpl(slotSize);
              String methodSig = i < beanMethods.length ? MethodAttribUtils.methodSignature(beanMethods[i]) : methodNames[i] + MethodAttribUtils.METHOD_ARGLIST_SEP
                                                                                                              + methodSignatures[i];
              methodInfoImpl.initializeInstanceData(methodSig,
                                                    methodNames[i],
                                                    bmd,
                                                    methodInterface,
                                                    transactionAttrs[i],
                                                    asynchMethodFlags[i]);
              methodInfoImpl.setMethodDescriptor(jdiMethodSignatures[i]);
              methodInfoImpl.setIsolationLevel(isolationAttrs[i]);
              methodInfoImpl.setActivitySessionAttribute(activitySessionAttrs[i]);
              methodInfoImpl.setReadOnly(readOnlyAttrs[i]);
              methodInfoImpl.setSecurityPolicy(denyAll[i], permitAll[i], rolesAllowed);
  
              methodInfoImpl.setMethod(ejbMethods[i]); // 366845.9 // F743-1752.1
              methodInfoImpl.setBridgeMethod(bridgeMethods[i]); // d517824 // F743-1752.1
  
              // If this is a singleton session bean that uses container managed concurrency
              // control, then set the LockType and AccessTimeout for this method.
              if (singletonWithContainerManagedConcurrency) {
                  methodInfoImpl.setCMLockType(lockType[i]); // F743-1752.1
                  methodInfoImpl.setCMLockAccessTimeout(accessTimeout[i]); // F743-1752.1
              } else if (bmd.isStatefulSessionBean()) {
                  methodInfoImpl.setCMLockAccessTimeout(accessTimeout[i]); // F743-22462
              }
  
              methodInfoImpl.setDeclaredExceptions(declaredExceptions); // F743-761
              methodInfoImpl.setDeclaredExceptionsComp(declaredExceptionsComp); // d734957
  
              methodInfos[i] = methodInfoImpl; // F743-1752.1
          }
  
          if (addRemove) {
              methodInfos[numMethods - 1].setComponentRemove(true);
  
              // EJB 2.1 Stateful remove methods (EJBObject/EJBLocalObject) must
              // throw a RemoveException if the bean is in use, so set concurrency
              // timout to 0 (no waiting).                                    d704504
              if (bmd.isStatefulSessionBean()) {
                  methodInfos[numMethods - 1].setCMLockAccessTimeout(0);
              }
          }
  
          if (isTraceOn && tc.isEntryEnabled())
              Tr.exit(tc, "initializeBeanMethodMetadata");
  
          return new MethodDataWrapper(methodNames, methodInfos, isolationAttrs, readOnlyAttrs);
  
      }