* Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).

* All rights reserved.

* This program and the accompanying materials are made available

* under the terms of the Common Public License v1.0

* which accompanies this distribution and is available at

* http://www.eclipse.org/legal/cpl-v10.html

* 

* Contributors:

*     PARC     initial implementation

* ******************************************************************/

   

    /**

     * This is called from {@link BcelWeaver} to perform the per-class weaving process.

     */

  public static boolean weave(

    BcelWorld world,

    LazyClassGen clazz,

    List shadowMungers,

    List typeMungers,

        List lateTypeMungers)

  {

    boolean b =  new BcelClassWeaver(world, clazz, shadowMungers, typeMungers, lateTypeMungers).weave();

    //System.out.println(clazz.getClassName() + ", " + clazz.getType().getWeaverState());

    //clazz.print();

    return b;

  }

 

  // --------------------------------------------

   

    private final LazyClassGen clazz;

    private final List         shadowMungers;

    private final List         typeMungers;

    private final List         lateTypeMungers;

    private final BcelObjectType  ty;    // alias of clazz.getType()

    private final BcelWorld       world; // alias of ty.getWorld()

    private final ConstantPoolGen cpg;   // alias of clazz.getConstantPoolGen()

    private final InstructionFactory fact; // alias of clazz.getFactory();

   

    private final List        addedLazyMethodGens           = new ArrayList();

    private final Set         addedDispatchTargets          = new HashSet();

   

  // Static setting across BcelClassWeavers

  private static boolean inReweavableMode = false;

   

   

    private        List addedSuperInitializersAsList = null; // List<IfaceInitList>

    private final Map  addedSuperInitializers = new HashMap(); // Interface -> IfaceInitList

    private        List addedThisInitializers  = new ArrayList(); // List<NewFieldMunger>

    private        List addedClassInitializers  = new ArrayList(); // List<NewFieldMunger>

 

  private Map mapToAnnotations = new HashMap();

   

    private BcelShadow clinitShadow = null;

   

    /**

     * This holds the initialization and pre-initialization shadows for this class

     * that were actually matched by mungers (if no match, then we don't even create the

     * shadows really).

     */

    private final List        initializationShadows         = new ArrayList(1);

   

  private BcelClassWeaver(

    BcelWorld world,

    LazyClassGen clazz,

    List shadowMungers,

    List typeMungers,

        List lateTypeMungers)

  {

    super();

    // assert world == clazz.getType().getWorld()

    this.world = world;

    this.clazz = clazz;

    this.shadowMungers = shadowMungers;

    this.typeMungers = typeMungers;

        this.lateTypeMungers = lateTypeMungers;

    this.ty = clazz.getBcelObjectType();

    this.cpg = clazz.getConstantPoolGen();

    this.fact = clazz.getFactory();

   

    fastMatchShadowMungers(shadowMungers);

   

    initializeSuperInitializerMap(ty.getResolvedTypeX());

  }

 

    private List[] perKindShadowMungers;

    private boolean canMatchBodyShadows = false;

    private boolean canMatchInitialization = false;

    private void fastMatchShadowMungers(List shadowMungers) {

      // beware the annoying property that SHADOW_KINDS[i].getKey == (i+1) !

     

      perKindShadowMungers = new List[Shadow.MAX_SHADOW_KIND + 1];

      for (int i = 0; i < perKindShadowMungers.length; i++) {

      perKindShadowMungers[i] = new ArrayList(0);

      }

      for (Iterator iter = shadowMungers.iterator(); iter.hasNext();) {

      ShadowMunger munger = (ShadowMunger) iter.next();

      Set couldMatchKinds = munger.getPointcut().couldMatchKinds();

      for (Iterator kindIterator = couldMatchKinds.iterator();

           kindIterator.hasNext();) {

        Shadow.Kind aKind = (Shadow.Kind) kindIterator.next();

        perKindShadowMungers[aKind.getKey()].add(munger);

      }

    }

     

      if (!perKindShadowMungers[Shadow.Initialization.getKey()].isEmpty())

        canMatchInitialization = true;

     

      for (int i = 0; i < Shadow.SHADOW_KINDS.length; i++) {

      Shadow.Kind kind = Shadow.SHADOW_KINDS[i];

      if (!kind.isEnclosingKind() && !perKindShadowMungers[i+1].isEmpty()) {

        canMatchBodyShadows = true;

      }

      if (perKindShadowMungers[i+1].isEmpty()) {

        perKindShadowMungers[i+1] = null;

      }

      }

    }

   

    private boolean canMatch(Shadow.Kind kind) {

      return perKindShadowMungers[kind.getKey()] != null;

    }

   

//    FastMatchInfo info = new FastMatchInfo(clazz.getType(), kind);

//    for (Iterator i = shadowMungers.iterator(); i.hasNext();) {

//      ShadowMunger munger = (ShadowMunger) i.next();

//      FuzzyBoolean fb = munger.getPointcut().fastMatch(info);

//      WeaverMetrics.recordFastMatchResult(fb);// Could pass: munger.getPointcut().toString()

//      if (fb.maybeTrue()) mungers.add(munger);

//    }

//  }

  private void initializeSuperInitializerMap(ResolvedType child) {

    ResolvedType[] superInterfaces = child.getDeclaredInterfaces();

    for (int i=0, len=superInterfaces.length; i < len; i++) {

      if (ty.getResolvedTypeX().isTopmostImplementor(superInterfaces[i])) {

        if (addSuperInitializer(superInterfaces[i])) {

          initializeSuperInitializerMap(superInterfaces[i]);

        }

      }

    }

  }

  private boolean addSuperInitializer(ResolvedType onType) {

    if (onType.isRawType() || onType.isParameterizedType()) onType = onType.getGenericType();

    IfaceInitList l = (IfaceInitList) addedSuperInitializers.get(onType);

    if (l != null) return false;

    l = new IfaceInitList(onType);

    addedSuperInitializers.put(onType, l);

    return true;

  }

  

  public void addInitializer(ConcreteTypeMunger cm) {

    NewFieldTypeMunger m = (NewFieldTypeMunger) cm.getMunger();

    ResolvedType onType = m.getSignature().getDeclaringType().resolve(world);

    if (onType.isRawType()) onType = onType.getGenericType();

    if (m.getSignature().isStatic()) {

      addedClassInitializers.add(cm);

    } else {

      if (onType == ty.getResolvedTypeX()) {

        addedThisInitializers.add(cm);

      } else {

        IfaceInitList l = (IfaceInitList) addedSuperInitializers.get(onType);

        l.list.add(cm);

      }

    }

  }

   

    private static class IfaceInitList implements PartialOrder.PartialComparable {

      final ResolvedType onType;

      List list = new ArrayList();

      IfaceInitList(ResolvedType onType) {

        this.onType = onType;

      }

     

    public int compareTo(Object other) {

      IfaceInitList o = (IfaceInitList)other;

      if (onType.isAssignableFrom(o.onType)) return +1;

      else if (o.onType.isAssignableFrom(onType)) return -1;

      else return 0;

    }

    public int fallbackCompareTo(Object other) {

      return 0;

    }

    }

   

    // XXX this is being called, but the result doesn't seem to be being used

    public boolean addDispatchTarget(ResolvedMember m) {

      return addedDispatchTargets.add(m);

    }

   

    public void addLazyMethodGen(LazyMethodGen gen) {

      addedLazyMethodGens.add(gen);

    }

     

  public void addOrReplaceLazyMethodGen(LazyMethodGen mg) {

    if (alreadyDefined(clazz, mg)) return;

   

    for (Iterator i = addedLazyMethodGens.iterator(); i.hasNext(); ) {

      LazyMethodGen existing = (LazyMethodGen)i.next();

      if (signaturesMatch(mg, existing)) {

        if (existing.definingType == null) {

          // this means existing was introduced on the class itself

          return;

        } else if (mg.definingType.isAssignableFrom(existing.definingType)) {

          // existing is mg's subtype and dominates mg

          return;

        } else if (existing.definingType.isAssignableFrom(mg.definingType)) {

          // mg is existing's subtype and dominates existing

          i.remove();

          addedLazyMethodGens.add(mg);

          return;

        } else {

          throw new BCException("conflict between: " + mg + " and " + existing);

        }

      }

    }

    addedLazyMethodGens.add(mg);

  }

  private boolean alreadyDefined(LazyClassGen clazz, LazyMethodGen mg) {

    for (Iterator i = clazz.getMethodGens().iterator(); i.hasNext(); ) {

      LazyMethodGen existing = (LazyMethodGen)i.next();

      if (signaturesMatch(mg, existing)) {

        if (!mg.isAbstract() && existing.isAbstract()) {

          i.remove();

          return false;

        }

        return true;

      }

    }

    return false;

  }

  private boolean signaturesMatch(LazyMethodGen mg, LazyMethodGen existing) {

    return mg.getName().equals(existing.getName()) &&

      mg.getSignature().equals(existing.getSignature());

  }     

   

 

  protected static LazyMethodGen makeBridgeMethod(LazyClassGen gen, ResolvedMember member) {

    // remove abstract modifier

    int mods = member.getModifiers();

    if (Modifier.isAbstract(mods)) mods = mods - Modifier.ABSTRACT;

   

    LazyMethodGen ret = new LazyMethodGen(

      mods,

      BcelWorld.makeBcelType(member.getReturnType()),

      member.getName(),

      BcelWorld.makeBcelTypes(member.getParameterTypes()),

      UnresolvedType.getNames(member.getExceptions()),

      gen);

       

        // 43972 : Static crosscutting makes interfaces unusable for javac

        // ret.makeSynthetic();   

    return ret;

  }

 

 

  /**

   * Create a single bridge method called 'theBridgeMethod' that bridges to 'whatToBridgeTo'

   */

  private static void createBridgeMethod(BcelWorld world, LazyMethodGen whatToBridgeToMethodGen, LazyClassGen clazz,ResolvedMember theBridgeMethod) {

    InstructionList body;

    InstructionFactory fact;

    int pos = 0;

    ResolvedMember whatToBridgeTo = whatToBridgeToMethodGen.getMemberView();

   

    if (whatToBridgeTo==null) {

      whatToBridgeTo =

        new ResolvedMemberImpl(Member.METHOD,

        whatToBridgeToMethodGen.getEnclosingClass().getType(),

        whatToBridgeToMethodGen.getAccessFlags(),

        whatToBridgeToMethodGen.getName(),

        whatToBridgeToMethodGen.getSignature());

    }

    LazyMethodGen bridgeMethod = makeBridgeMethod(clazz,theBridgeMethod); // The bridge method in this type will have the same signature as the one in the supertype

    bridgeMethod.setAccessFlags(bridgeMethod.getAccessFlags() | 0x00000040 /*BRIDGE    = 0x00000040*/ );

    Type returnType   = BcelWorld.makeBcelType(theBridgeMethod.getReturnType());

    Type[] paramTypes = BcelWorld.makeBcelTypes(theBridgeMethod.getParameterTypes());

    Type[] newParamTypes=whatToBridgeToMethodGen.getArgumentTypes();

    body = bridgeMethod.getBody();

    fact = clazz.getFactory();

    if (!whatToBridgeToMethodGen.isStatic()) {

       body.append(InstructionFactory.createThis());

       pos++;

    }

    for (int i = 0, len = paramTypes.length; i < len; i++) {

      Type paramType = paramTypes[i];

      body.append(InstructionFactory.createLoad(paramType, pos));

      if (!newParamTypes[i].equals(paramTypes[i])) {

        if (debug) System.err.println("Cast "+newParamTypes[i]+" from "+paramTypes[i]);

        body.append(fact.createCast(paramTypes[i],newParamTypes[i]));

      }

      pos+=paramType.getSize();

    }

    body.append(Utility.createInvoke(fact, world,whatToBridgeTo));

    body.append(InstructionFactory.createReturn(returnType));

    clazz.addMethodGen(bridgeMethod);

  }

 

    // ----

   

    public boolean weave() {

        if (clazz.isWoven() && !clazz.isReweavable()) {

          world.showMessage(IMessage.ERROR,

              WeaverMessages.format(WeaverMessages.ALREADY_WOVEN,clazz.getType().getName()),

        ty.getSourceLocation(), null);

          return false;

        }

      

        Set aspectsAffectingType = null;

        if (inReweavableMode || clazz.getType().isAspect()) aspectsAffectingType = new HashSet();

       

        boolean isChanged = false;

       

        // we want to "touch" all aspects

        if (clazz.getType().isAspect()) isChanged = true;

        // start by munging all typeMungers

        for (Iterator i = typeMungers.iterator(); i.hasNext(); ) {

          Object o = i.next();

          if ( !(o instanceof BcelTypeMunger) ) {

            //???System.err.println("surprising: " + o);

            continue;

          }

          BcelTypeMunger munger = (BcelTypeMunger)o;

          boolean typeMungerAffectedType = munger.munge(this);

          if (typeMungerAffectedType) {

            isChanged = true;

            if (inReweavableMode || clazz.getType().isAspect()) aspectsAffectingType.add(munger.getAspectType().getName());

          }

        }

        // Weave special half type/half shadow mungers...

        isChanged = weaveDeclareAtMethodCtor(clazz) || isChanged;

        isChanged = weaveDeclareAtField(clazz)      || isChanged;

       

        // XXX do major sort of stuff

        // sort according to:  Major:  type hierarchy

        //                     within each list:  dominates

        // don't forget to sort addedThisInitialiers according to dominates

        addedSuperInitializersAsList = new ArrayList(addedSuperInitializers.values());

        addedSuperInitializersAsList = PartialOrder.sort(addedSuperInitializersAsList);       

        if (addedSuperInitializersAsList == null) {

          throw new BCException("circularity in inter-types");

        }

     

        // this will create a static initializer if there isn't one

        // this is in just as bad taste as NOPs

        LazyMethodGen staticInit = clazz.getStaticInitializer();

        staticInit.getBody().insert(genInitInstructions(addedClassInitializers, true));

       

        // now go through each method, and match against each method.  This

        // sets up each method's {@link LazyMethodGen#matchedShadows} field,

        // and it also possibly adds to {@link #initializationShadows}.

        List methodGens = new ArrayList(clazz.getMethodGens());

        for (Iterator i = methodGens.iterator(); i.hasNext();) {

            LazyMethodGen mg = (LazyMethodGen)i.next();

      if (! mg.hasBody()) continue;

      boolean shadowMungerMatched = match(mg);

      if (shadowMungerMatched) {

        // For matching mungers, add their declaring aspects to the list that affected this type

        if (inReweavableMode || clazz.getType().isAspect()) aspectsAffectingType.addAll(findAspectsForMungers(mg));

              isChanged = true;

      }

        }

        // now we weave all but the initialization shadows

    for (Iterator i = methodGens.iterator(); i.hasNext();) {

      LazyMethodGen mg = (LazyMethodGen)i.next();

      if (! mg.hasBody()) continue;

      implement(mg);

    }

     

       

        // if we matched any initialization shadows, we inline and weave

    if (!initializationShadows.isEmpty()) {

      // Repeat next step until nothing left to inline...cant go on

      // infinetly as compiler will have detected and reported

      // "Recursive constructor invocation"

      while (inlineSelfConstructors(methodGens));

      positionAndImplement(initializationShadows);

    }

   

        // now proceed with late type mungers

        if (lateTypeMungers != null) {

            for (Iterator i = lateTypeMungers.iterator(); i.hasNext(); ) {

                BcelTypeMunger munger = (BcelTypeMunger)i.next();

                if (munger.matches(clazz.getType())) {

                    boolean typeMungerAffectedType = munger.munge(this);

                    if (typeMungerAffectedType) {

                        isChanged = true;

                        if (inReweavableMode || clazz.getType().isAspect()) aspectsAffectingType.add(munger.getAspectType().getName());

                    }

                }

            }

        }

        //FIXME AV - see #75442, for now this is not enough to fix the bug, comment that out until we really fix it

//        // flush to save some memory

//        PerObjectInterfaceTypeMunger.unregisterFromAsAdvisedBy(clazz.getType());

    // finally, if we changed, we add in the introduced methods.

        if (isChanged) {

          clazz.getOrCreateWeaverStateInfo(inReweavableMode);

      weaveInAddedMethods(); // FIXME asc are these potentially affected by declare annotation?

        }

       

        if (inReweavableMode) {

          WeaverStateInfo wsi = clazz.getOrCreateWeaverStateInfo(true);

          wsi.addAspectsAffectingType(aspectsAffectingType);

          wsi.setUnwovenClassFileData(ty.getJavaClass().getBytes());

          wsi.setReweavable(true);

        } else {

          clazz.getOrCreateWeaverStateInfo(false).setReweavable(false);

        }

       

        return isChanged;

    }

   

   

   

   

    // **************************** start of bridge method creation code *****************

   

    // debug flag for bridge method creation

  private static boolean debug=false;

   

 

  // FIXME asc tidy this lot up !!

 

    // FIXME asc refactor into ResolvedType or even ResolvedMember?

    /**

     * Check if a particular method is overriding another - refactored into this helper so it

     * can be used from multiple places.

     */

    private static ResolvedMember isOverriding(ResolvedType typeToCheck,ResolvedMember methodThatMightBeGettingOverridden,String mname,String mrettype,int mmods,boolean inSamePackage,UnresolvedType[] methodParamsArray) {

    // Check if we can be an override...

    if (methodThatMightBeGettingOverridden.isStatic()) return null; // we can't be overriding a static method

    if (methodThatMightBeGettingOverridden.isPrivate())  return null; // we can't be overriding a private method

    if (!methodThatMightBeGettingOverridden.getName().equals(mname))  return null; // names dont match (this will also skip <init> and <clinit> too)

    if (methodThatMightBeGettingOverridden.getParameterTypes().length!=methodParamsArray.length)  return null; // check same number of parameters

    if (!isVisibilityOverride(mmods,methodThatMightBeGettingOverridden,inSamePackage))  return null;

 

    if (debug) System.err.println("  Seriously considering this might be getting overridden "+methodThatMightBeGettingOverridden);

   

    // Look at erasures of parameters (List<String> erased is List)

    boolean sameParams = true;

    for (int p = 0;p<methodThatMightBeGettingOverridden.getParameterTypes().length;p++) {

      if (!methodThatMightBeGettingOverridden.getParameterTypes()[p].getErasureSignature().equals(methodParamsArray[p].getErasureSignature())) sameParams = false;

    }

   

    // If the 'typeToCheck' represents a parameterized type then the method will be the parameterized form of the

    // generic method in the generic type.  So if the method was 'void m(List<T> lt, T t)' and the parameterized type here

    // is I<String> then the method we are looking at will be 'void m(List<String> lt, String t)' which when erased

    // is 'void m(List lt,String t)' - so if the parameters *do* match then there is a generic method we are

    // overriding

   

      if (sameParams) {         

        // check for covariance

        if (typeToCheck.isParameterizedType()) {

        return methodThatMightBeGettingOverridden.getBackingGenericMember();

        } else if (!methodThatMightBeGettingOverridden.getReturnType().getErasureSignature().equals(mrettype)) {

          return methodThatMightBeGettingOverridden; // covariance

        }

      }

      return null;

    }

   

    /**

     * Looks at the visibility modifiers between two methods, and knows whether they are from classes in

     * the same package, and decides whether one overrides the other.

     * @return true if there is an overrides rather than a 'hides' relationship

     */

    static boolean isVisibilityOverride(int methodMods, ResolvedMember inheritedMethod,boolean inSamePackage) {

      if (inheritedMethod.isStatic()) return false;

      if (methodMods == inheritedMethod.getModifiers()) return true;

      if (inheritedMethod.isPrivate()) return false;

     

      boolean isPackageVisible = !inheritedMethod.isPrivate() && !inheritedMethod.isProtected()

                               && !inheritedMethod.isPublic();

      if (isPackageVisible && !inSamePackage) return false;

     

      return true;

    }

   

    /**

     * This method recurses up a specified type looking for a method that overrides the one passed in.

     *

     * @return the method being overridden or null if none is found

     */

    public static ResolvedMember checkForOverride(ResolvedType typeToCheck,String mname,String mparams,String mrettype,int mmods,String mpkg,UnresolvedType[] methodParamsArray) {

      if (typeToCheck==null) return null;

      if (typeToCheck instanceof MissingResolvedTypeWithKnownSignature) return null; // we just can't tell !

     

      if (debug) System.err.println("  Checking for override of "+mname+" in "+typeToCheck);

     

      String packageName = typeToCheck.getPackageName();

      if (packageName==null) packageName="";

      boolean inSamePackage = packageName.equals(mpkg); // used when looking at visibility rules

     

      ResolvedMember [] methods = typeToCheck.getDeclaredMethods();

      for (int ii=0;ii<methods.length;ii++) {

      ResolvedMember methodThatMightBeGettingOverridden = methods[ii]; // the method we are going to check     

      ResolvedMember isOverriding = isOverriding(typeToCheck,methodThatMightBeGettingOverridden,mname,mrettype,mmods,inSamePackage,methodParamsArray);

      if (isOverriding!=null) return isOverriding;

    }

    List l = typeToCheck.getInterTypeMungers();

    for (Iterator iterator = l.iterator(); iterator.hasNext();) {

      Object o = iterator.next();

      // FIXME asc if its not a BcelTypeMunger then its an EclipseTypeMunger ... do I need to worry about that?

      if (o instanceof BcelTypeMunger) {

        BcelTypeMunger element = (BcelTypeMunger)o;

        if (element.getMunger() instanceof NewMethodTypeMunger) {

          if (debug) System.err.println("Possible ITD candidate "+element);

          ResolvedMember aMethod = element.getSignature();

          ResolvedMember isOverriding = isOverriding(typeToCheck,aMethod,mname,mrettype,mmods,inSamePackage,methodParamsArray);

          if (isOverriding!=null) return isOverriding;

        }

      }

    }

   

   

    if (typeToCheck.equals(UnresolvedType.OBJECT)) return null;

   

      ResolvedType superclass = typeToCheck.getSuperclass();

    ResolvedMember overriddenMethod = checkForOverride(superclass,mname,mparams,mrettype,mmods,mpkg,methodParamsArray);

    if (overriddenMethod!=null) return overriddenMethod;

     

    ResolvedType[] interfaces = typeToCheck.getDeclaredInterfaces();

    for (int i = 0; i < interfaces.length; i++) {

      ResolvedType anInterface = interfaces[i];

      overriddenMethod = checkForOverride(anInterface,mname,mparams,mrettype,mmods,mpkg,methodParamsArray);

      if (overriddenMethod!=null) return overriddenMethod;

    }

    return null;

    }

    /**

     * We need to determine if any methods in this type require bridge methods - this method should only

     * be called if necessary to do this calculation, i.e. we are on a 1.5 VM (where covariance/generics exist) and

     * the type hierarchy for the specified class has changed (via decp/itd).

     *

     * See pr108101

     */

  public static boolean calculateAnyRequiredBridgeMethods(BcelWorld world,LazyClassGen clazz) {

    if (!world.isInJava5Mode()) return false; // just double check... the caller should have already verified this

    if (clazz.isInterface()) return false; // dont bother if we're an interface

    boolean didSomething=false; // set if we build any bridge methods

   

    // So what methods do we have right now in this class?

    List /*LazyMethodGen*/ methods = clazz.getMethodGens();

    // Keep a set of all methods from this type - it'll help us to check if bridge methods

    // have already been created, we don't want to do it twice!

    Set methodsSet = new HashSet();

    for (int i = 0; i < methods.size(); i++) {

      LazyMethodGen aMethod = (LazyMethodGen)methods.get(i);

      methodsSet.add(aMethod.getName()+aMethod.getSignature()); // e.g. "foo(Ljava/lang/String;)V"

    }

   

    // Now go through all the methods in this type

    for (int i = 0; i < methods.size(); i++) {

     

      // This is the local method that we *might* have to bridge to

      LazyMethodGen bridgeToCandidate  = (LazyMethodGen)methods.get(i);

      if (bridgeToCandidate.isBridgeMethod()) continue; // Doh!

      String name  = bridgeToCandidate.getName();

      String psig  = bridgeToCandidate.getParameterSignature();

      String rsig  = bridgeToCandidate.getReturnType().getSignature();

     

      //if (bridgeToCandidate.isAbstract()) continue;

      if (bridgeToCandidate.isStatic())      continue; // ignore static methods

      if (name.endsWith("init>")) continue; // Skip constructors and static initializers

      if (debug) System.err.println("Determining if we have to bridge to "+clazz.getName()+"."+name+""+bridgeToCandidate.getSignature());

     

      // Let's take a look at the superclass

      ResolvedType theSuperclass= clazz.getSuperClass();

      if (debug) System.err.println("Checking supertype "+theSuperclass);

      String pkgName = clazz.getPackageName();

      UnresolvedType[] bm = BcelWorld.fromBcel(bridgeToCandidate.getArgumentTypes());

      ResolvedMember overriddenMethod = checkForOverride(theSuperclass,name,psig,rsig,bridgeToCandidate.getAccessFlags(),pkgName,bm);

      if (overriddenMethod!=null) {

        boolean alreadyHaveABridgeMethod = methodsSet.contains(overriddenMethod.getName()+overriddenMethod.getSignature());

        if (!alreadyHaveABridgeMethod) {

          if (debug) System.err.println("Bridging to "+overriddenMethod);

          createBridgeMethod(world, bridgeToCandidate, clazz, overriddenMethod);

          didSomething = true;

          continue; // look at the next method

        }

      }

      // Check superinterfaces

      String[] interfaces = clazz.getInterfaceNames();

      for (int j = 0; j < interfaces.length; j++) {

        if (debug) System.err.println("Checking superinterface "+interfaces[j]);

        ResolvedType interfaceType = world.resolve(interfaces[j]);

        overriddenMethod = checkForOverride(interfaceType,name,psig,rsig,bridgeToCandidate.getAccessFlags(),clazz.getPackageName(),bm);

        if (overriddenMethod!=null) {

          boolean alreadyHaveABridgeMethod = methodsSet.contains(overriddenMethod.getName()+overriddenMethod.getSignature());

          if (!alreadyHaveABridgeMethod) {

            createBridgeMethod(world, bridgeToCandidate, clazz, overriddenMethod);

            didSomething=true;

            if (debug) System.err.println("Bridging to "+overriddenMethod);

            continue; // look at the next method

          } 

        }

      }

    }

    return didSomething;

  }

 

    // **************************** end of bridge method creation code *****************

    /**

     * Weave any declare @method/@ctor statements into the members of the supplied class

     */

    private boolean weaveDeclareAtMethodCtor(LazyClassGen clazz) {

    List reportedProblems = new ArrayList();

   

    List allDecams = world.getDeclareAnnotationOnMethods();

    if (allDecams.isEmpty()) return false; // nothing to do

   

    boolean isChanged = false;

    // deal with ITDs

    List itdMethodsCtors = getITDSubset(clazz,ResolvedTypeMunger.Method);

    itdMethodsCtors.addAll(getITDSubset(clazz,ResolvedTypeMunger.Constructor));   

    if (!itdMethodsCtors.isEmpty()) {

      // Can't use the subset called 'decaMs' as it won't be right for ITDs...

           isChanged = weaveAtMethodOnITDSRepeatedly(allDecams,itdMethodsCtors,reportedProblems);

    }

   

    // deal with all the other methods...

        List members = clazz.getMethodGens();

    List decaMs = getMatchingSubset(allDecams,clazz.getType());   

    if (decaMs.isEmpty()) return false; // nothing to do

    if (!members.isEmpty()) {

      Set unusedDecams = new HashSet();

      unusedDecams.addAll(decaMs);

          for (int memberCounter = 0;memberCounter<members.size();memberCounter++) {

            LazyMethodGen mg = (LazyMethodGen)members.get(memberCounter);

            if (!mg.getName().startsWith(NameMangler.PREFIX)) {

             

              // Single first pass

              List worthRetrying = new ArrayList();

              boolean modificationOccured = false;

             

              for (Iterator iter = decaMs.iterator(); iter.hasNext();) {

                DeclareAnnotation decaM = (DeclareAnnotation) iter.next();

               

                if (decaM.matches(mg.getMemberView(),world)) {

                  if (doesAlreadyHaveAnnotation(mg.getMemberView(),decaM,reportedProblems)) {

                    // remove the declare @method since don't want an error when

                    // the annotation is already there

                    unusedDecams.remove(decaM);

                    continue; // skip this one...

                  }

                 

                  Annotation a = decaM.getAnnotationX().getBcelAnnotation();

                  AnnotationGen ag = new AnnotationGen(a,clazz.getConstantPoolGen(),true);

                  Method oldMethod = mg.getMethod();

                  MethodGen myGen = new MethodGen(oldMethod,clazz.getClassName(),clazz.getConstantPoolGen());

                  myGen.addAnnotation(ag);

                  Method newMethod = myGen.getMethod();

                  mg.addAnnotation(decaM.getAnnotationX());

                  members.set(memberCounter,new LazyMethodGen(newMethod,clazz));

                 

                  AsmRelationshipProvider.getDefault().addDeclareAnnotationRelationship(decaM.getSourceLocation(),clazz.getName(),mg.getMethod());

                  reportMethodCtorWeavingMessage(clazz, mg.getMemberView(), decaM,mg.getDeclarationLineNumber());

                  isChanged = true;

                  modificationOccured = true;

            // remove the declare @method since have matched against it

                  unusedDecams.remove(decaM);                

                } else {

                  if (!decaM.isStarredAnnotationPattern())

                    worthRetrying.add(decaM); // an annotation is specified that might be put on by a subsequent decaf

                }

              }

             

              // Multiple secondary passes

              while (!worthRetrying.isEmpty() && modificationOccured) {

                modificationOccured = false;

                // lets have another go

                List forRemoval = new ArrayList();

                for (Iterator iter = worthRetrying.iterator(); iter.hasNext();) {

                  DeclareAnnotation decaM = (DeclareAnnotation) iter.next();

                  if (decaM.matches(mg.getMemberView(),world)) {

                    if (doesAlreadyHaveAnnotation(mg.getMemberView(),decaM,reportedProblems)) {

                      // remove the declare @method since don't want an error when

                        // the annotation is already there

                        unusedDecams.remove(decaM);

                      continue; // skip this one...

                    }

                    mg.addAnnotation(decaM.getAnnotationX());

                    AsmRelationshipProvider.getDefault().addDeclareAnnotationRelationship(decaM.getSourceLocation(),clazz.getName(),mg.getMethod());

                    isChanged = true;

                    modificationOccured = true;

                    forRemoval.add(decaM);

                // remove the declare @method since have matched against it

                    unusedDecams.remove(decaM);

                  }

                }

                worthRetrying.removeAll(forRemoval);

              }

            }

          }

        checkUnusedDeclareAtTypes(unusedDecams, false);

        }

    return isChanged;

    }

 

    // TAG: WeavingMessage

  private void reportMethodCtorWeavingMessage(LazyClassGen clazz, ResolvedMember member, DeclareAnnotation decaM,int memberLineNumber) {

    if (!getWorld().getMessageHandler().isIgnoring(IMessage.WEAVEINFO)){

      StringBuffer parmString = new StringBuffer("(");

      UnresolvedType[] paramTypes = member.getParameterTypes();

      for (int i = 0; i < paramTypes.length; i++) {

        UnresolvedType type = paramTypes[i];

        String s = org.aspectj.apache.bcel.classfile.Utility.signatureToString(type.getSignature());

        if (s.lastIndexOf(".")!=-1) s =s.substring(s.lastIndexOf(".")+1);

        parmString.append(s);

        if ((i+1)<paramTypes.length) parmString.append(",");

      }

      parmString.append(")");

      String methodName = member.getName();

      StringBuffer sig = new StringBuffer();

      sig.append(org.aspectj.apache.bcel.classfile.Utility.accessToString(member.getModifiers()));

      sig.append(" ");

      sig.append(member.getReturnType().toString());

      sig.append(" ");

      sig.append(member.getDeclaringType().toString());

      sig.append(".");

      sig.append(methodName.equals("<init>")?"new":methodName);

      sig.append(parmString);

     

      StringBuffer loc = new StringBuffer();

      if (clazz.getFileName()==null) {

        loc.append("no debug info available");

      } else {

        loc.append(clazz.getFileName());

        if (memberLineNumber!=-1) {

          loc.append(":"+memberLineNumber);

        }

      }

      getWorld().getMessageHandler().handleMessage(

          WeaveMessage.constructWeavingMessage(WeaveMessage.WEAVEMESSAGE_ANNOTATES,

              new String[]{

              sig.toString(),

              loc.toString(),

              decaM.getAnnotationString(),

              methodName.startsWith("<init>")?"constructor":"method",

              decaM.getAspect().toString(),

              Utility.beautifyLocation(decaM.getSourceLocation())

              })); 

    }

  }

   

  /**

   * Looks through a list of declare annotation statements and only returns

   * those that could possibly match on a field/method/ctor in type.

   */

  private List getMatchingSubset(List declareAnnotations, ResolvedType type) {

      List subset = new ArrayList();

      for (Iterator iter = declareAnnotations.iterator(); iter.hasNext();) {

      DeclareAnnotation da = (DeclareAnnotation) iter.next();

      if (da.couldEverMatch(type)) {

        subset.add(da);

      }

    }

    return subset;

  }

 

    /**

     * Get a subset of all the type mungers defined on this aspect

     */

  private List getITDSubset(LazyClassGen clazz,ResolvedTypeMunger.Kind wantedKind) {

    List subset = new ArrayList();

    Collection c = clazz.getBcelObjectType().getTypeMungers();

    for (Iterator iter = c.iterator();iter.hasNext();) {