docs: public void addInjectionTarget(Member member)
                      throws InjectionException
      {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && tc.isEntryEnabled())
              Tr.entry(tc, "addInjectionTarget: " + member);
  
          // -----------------------------------------------------------------------
          // First, determine if the target being added is already in the list.
          // This may occur if the target is specified in both XML and annotations
          // (an override) or if multiple interceptors inherit from a base class
          // where the base class contains an injection annotation.          d457733
          //
          // Next, determine if the customer has incorrectly attempted to inject
          // into both the field and corresponding java beans property method.
          // This is not allowed per the JavaEE, EJB 3.0 Specifications.   d447011.2
          //
          // Finally, note that if the XML target resulted in the method, but the
          // annotation is on the field, then the XML should really be considered
          // to be overriding the field injection, so don't throw an exception
          // and instead just remove the previous target from XML.           d510950
          // -----------------------------------------------------------------------
  
          boolean containsTarget = false;
          String existingMemberName = null;
          String toAddMemberName = null;
          InjectionTarget injectionTarget = null;
  
          if (ivInjectionTargets != null)
          {
              for (InjectionTarget target : ivInjectionTargets)
              {
                  Member targetMember = target.getMember();
  
                  if (targetMember.equals(member))
                  {
                      // Reset 'fromXML' since it also matches an annotation. Reseting
                      // this allows us to detect when they have annotations on both
                      // the field and set method.                                 PK92087
                      target.ivFromXML = false;
  
                      // Already in list, break out and check for error below, or ignore
                      if (isTraceOn && tc.isDebugEnabled())
                          Tr.debug(tc, "found: " + target);
                      injectionTarget = target; // save for trace    d643444
                      containsTarget = true;
                      break;
                  }
  
                  // If both are from the same class, then check for 'double' injection
                  // into both the field and method for a 'property.              d510950
                  if (targetMember.getDeclaringClass() == member.getDeclaringClass())
                  {
                      // Obtain the 'property' method name from the existing target
                      if (targetMember instanceof Method) {
                          existingMemberName = targetMember.getName();
                      } else {
                          existingMemberName = getMethodFromProperty(targetMember.getName());
                      }
  
                      // Obtain the 'property' method name from the target being added
                      if (member instanceof Method) {
                          toAddMemberName = member.getName();
                      } else {
                          toAddMemberName = getMethodFromProperty(member.getName());
                      }
  
                      // When equal, injection has been specified for both field an method.
                      if (existingMemberName.equals(toAddMemberName))
                      {
                          if (target.ivFromXML)
                          {
                              // If the existing one came from XML, then it must be the
                              // method, but is really intended to be an override of the
                              // field annotation... so just remove the method target
                              // and let the field target be added below.            d510950
                              if (isTraceOn && tc.isDebugEnabled())
                                  Tr.debug(tc, "removing: " + targetMember.getName());
                              ivInjectionTargets.remove(target);
                              break;
                          }
  
                          // Annotation present on both the field and method... error.
                          Tr.error(tc, "INJECTION_DECLARED_IN_BOTH_THE_FIELD_AND_METHOD_OF_A_BEAN_CWNEN0056E",
                                   ivJndiName,
                                   member.getDeclaringClass().getName(),
                                   ivNameSpaceConfig.getModuleName(),
                                   ivNameSpaceConfig.getApplicationName());
                          throw new InjectionConfigurationException("Injection of the " + ivJndiName +
                                                                    " resource was specified for both a property instance" +
                                                                    " variable and its corresponding set method on the " +
                                                                    member.getDeclaringClass().getName() + " class in the " +
                                                                    ivNameSpaceConfig.getModuleName() + " module of the " +
                                                                    ivNameSpaceConfig.getApplicationName() + " application.");
                      }
                  }
              }
          }
  
          // -----------------------------------------------------------------------
          // The following is stated in the EJB Specification overriding rules:
          //
          //    The injection target, if specified, must name exactly the annotated
          //    field or property method.
          //
          // Previously (EJB 3.0 Feature Pack and WAS 7.0) this was interpreted to
          // mean that if any targets were specified in XML, then the XML must
          // contain targets for every annotation.  So, if the target being added
          // due to an annotation is NOT present in the list, then it was not
          // specified in XML, which would have been an error.  WAS did support
          // adding additional targets from XML, but there had to also be a target
          // for every annotation.
          //
          // Since that time, it has been realized that this can be quite annoying
          // to customers, as they must duplicate annotation information just to
          // specify an extra injection target.  Also, this could be quite difficult
          // to enforce for EJBs in WAR modules, where targets and EJB references
          // can now be defined in many different locations.
          //
          // Beginning in WAS 8.0, the above rule is now being interpreted to mean
          // only that if a target in XML matches an annotation, then that target
          // is considered an override of that annotation and has really very
          // little effect.  Additional targets in XML are not considered overrides
          // of any annotations, and are just additional targets.  Thus, targets
          // from XML do not globally replace all targets from annotations, but
          // just add to them.                                               d643444
          //
          // Also note that the rule indicates it is an override when they are an
          // exact match, so if the target was in XML, but was for a set method,
          // and the annotation was for the field... then it is assumed the XML
          // target was really the field (there is no way to indicate field in XML),
          // so the above code would have removed the method target, and will
          // expect the code below to add the field target; this is not an error.
          // To not assume these are an exact match would otherwise always result
          // in an error, since injection may not occur into both the field and
          // corresponding set method.
          //
          // Otherwise, if the XML specified no targets, then this is just an add
          // due to an annotation.  As long as the target is not already in the
          // list, then just add it (i.e. no duplicates).
          //
          // In this scenario, the target may already be in the list if multiple
          // classes being injected both inherit from the same base class. The
          // target will only be added once, and later will be 'collected' into
          // the InjectionTarget arrays for both subclasses.                 d457733
          // -----------------------------------------------------------------------
          if (!containsTarget)
          {
              if (member instanceof Field)
              {
                  injectionTarget = new InjectionTargetField((Field) member, this);
              }
              else
              {
                  injectionTarget = createInjectionTarget((Method) member, this);
              }
  
              injectionTarget.setInjectionBinding(this);
              addInjectionTarget(injectionTarget);
          }
  
          if (isTraceOn && tc.isEntryEnabled())
              Tr.exit(tc, "addInjectionTarget : " +
                          ((containsTarget) ? "(duplicate) " : "") + injectionTarget);
      }