Package org.aspectj.weaver

Source Code of org.aspectj.weaver.World$TimeCollector

/* *******************************************************************
* Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
*               2005 Contributors
* All rights reserved.
* This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v1.0
* which accompanies this distribution and is available at
* http://www.eclipse.org/legal/epl-v10.html
* Contributors:
*     PARC     initial implementation
*     Adrian Colyer, Andy Clement, overhaul for generics, Abraham Nevado
* ******************************************************************/

package org.aspectj.weaver;

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.WeakHashMap;

import org.aspectj.bridge.IMessage;
import org.aspectj.bridge.IMessage.Kind;
import org.aspectj.bridge.IMessageHandler;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.bridge.Message;
import org.aspectj.bridge.MessageUtil;
import org.aspectj.bridge.context.PinpointingMessageHandler;
import org.aspectj.util.IStructureModel;
import org.aspectj.weaver.UnresolvedType.TypeKind;
import org.aspectj.weaver.patterns.Declare;
import org.aspectj.weaver.patterns.DeclareAnnotation;
import org.aspectj.weaver.patterns.DeclareParents;
import org.aspectj.weaver.patterns.DeclarePrecedence;
import org.aspectj.weaver.patterns.DeclareSoft;
import org.aspectj.weaver.patterns.DeclareTypeErrorOrWarning;
import org.aspectj.weaver.patterns.Pointcut;
import org.aspectj.weaver.patterns.TypePattern;
import org.aspectj.weaver.tools.PointcutDesignatorHandler;
import org.aspectj.weaver.tools.Trace;
import org.aspectj.weaver.tools.TraceFactory;

/**
* A World is a collection of known types and crosscutting members.
*/
public abstract class World implements Dump.INode {
  /** handler for any messages produced during resolution etc. */
  private IMessageHandler messageHandler = IMessageHandler.SYSTEM_ERR;

  /**
   * handler for cross-reference information produced during the weaving process
   */
  private ICrossReferenceHandler xrefHandler = null;

  /**
   * Currently 'active' scope in which to lookup (resolve) typevariable references
   */
  private TypeVariableDeclaringElement typeVariableLookupScope;

  /** The heart of the world, a map from type signatures to resolved types */
  protected TypeMap typeMap = new TypeMap(this); // Signature to ResolvedType

  /** New pointcut designators this world supports */
  private Set<PointcutDesignatorHandler> pointcutDesignators;

  // see pr145963
  /** Should we create the hierarchy for binary classes and aspects */
  public static boolean createInjarHierarchy = true;

  /** Calculator for working out aspect precedence */
  private final AspectPrecedenceCalculator precedenceCalculator;

  /** All of the type and shadow mungers known to us */
  private final CrosscuttingMembersSet crosscuttingMembersSet = new CrosscuttingMembersSet(this);

  /** The structure model for the compilation */
  private IStructureModel model = null;

  /** for processing Xlint messages */
  private Lint lint = new Lint(this);

  /** XnoInline option setting passed down to weaver */
  private boolean XnoInline;

  /** XlazyTjp option setting passed down to weaver */
  private boolean XlazyTjp;

  /** XhasMember option setting passed down to weaver */
  private boolean XhasMember = false;

  /**
   * Xpinpoint controls whether we put out developer info showing the source of messages
   */
  private boolean Xpinpoint = false;

  /** When behaving in a Java 5 way autoboxing is considered */
  private boolean behaveInJava5Way = false;

  /** Should timing information be reported (as info messages)? */
  private boolean timing = false;
  private boolean timingPeriodically = true;

  /** Determines if this world could be used for multiple compiles */
  private boolean incrementalCompileCouldFollow = false;

  /** The level of the aspectjrt.jar the code we generate needs to run on */
  private String targetAspectjRuntimeLevel = Constants.RUNTIME_LEVEL_DEFAULT;

  /** Flags for the new joinpoints that are 'optional' */
  private boolean optionalJoinpoint_ArrayConstruction = false; // Command line
  // flag:
  // "-Xjoinpoints:arrayconstruction"
  private boolean optionalJoinpoint_Synchronization = false; // Command line
  // flag:
  // "-Xjoinpoints:synchronization"

  private boolean addSerialVerUID = false;

  private Properties extraConfiguration = null;
  private boolean checkedAdvancedConfiguration = false;
  private boolean synchronizationPointcutsInUse = false;
  // Xset'table options
  private boolean runMinimalMemory = false;
  private boolean runMinimalMemorySet = false;
  private boolean shouldPipelineCompilation = true;
  private boolean shouldGenerateStackMaps = false;
  protected boolean bcelRepositoryCaching = xsetBCEL_REPOSITORY_CACHING_DEFAULT.equalsIgnoreCase("true");
  private boolean fastMethodPacking = false;
  private int itdVersion = 2; // defaults to 2nd generation itds

  // Minimal Model controls whether model entities that are not involved in relationships are deleted post-build
  private boolean minimalModel = false;
  private boolean targettingRuntime1_6_10 = false;

  private boolean completeBinaryTypes = false;
  private boolean overWeaving = false;
  public boolean forDEBUG_structuralChangesCode = false;
  public boolean forDEBUG_bridgingCode = false;
  public boolean optimizedMatching = true;
  protected long timersPerJoinpoint = 25000;
  protected long timersPerType = 250;

  public int infoMessagesEnabled = 0; // 0=uninitialized, 1=no, 2=yes

  private static Trace trace = TraceFactory.getTraceFactory().getTrace(World.class);

  private long errorThreshold;
  private long warningThreshold;

  /**
   * A list of RuntimeExceptions containing full stack information for every type we couldn't find.
   */
  private List<RuntimeException> dumpState_cantFindTypeExceptions = null;

  /**
   * Play God. On the first day, God created the primitive types and put them in the type map.
   */
  protected World() {
    super();
    if (trace.isTraceEnabled()) {
      trace.enter("<init>", this);
    }
    // Dump.registerNode(this.getClass(), this);
    typeMap.put("B", ResolvedType.BYTE);
    typeMap.put("S", ResolvedType.SHORT);
    typeMap.put("I", ResolvedType.INT);
    typeMap.put("J", ResolvedType.LONG);
    typeMap.put("F", ResolvedType.FLOAT);
    typeMap.put("D", ResolvedType.DOUBLE);
    typeMap.put("C", ResolvedType.CHAR);
    typeMap.put("Z", ResolvedType.BOOLEAN);
    typeMap.put("V", ResolvedType.VOID);
    precedenceCalculator = new AspectPrecedenceCalculator(this);
    if (trace.isTraceEnabled()) {
      trace.exit("<init>");
    }
  }

  /**
   * Dump processing when a fatal error occurs
   */
  public void accept(Dump.IVisitor visitor) {
    // visitor.visitObject("Extra configuration:");
    // visitor.visitList(extraConfiguration.);
    visitor.visitObject("Shadow mungers:");
    visitor.visitList(crosscuttingMembersSet.getShadowMungers());
    visitor.visitObject("Type mungers:");
    visitor.visitList(crosscuttingMembersSet.getTypeMungers());
    visitor.visitObject("Late Type mungers:");
    visitor.visitList(crosscuttingMembersSet.getLateTypeMungers());
    if (dumpState_cantFindTypeExceptions != null) {
      visitor.visitObject("Cant find type problems:");
      visitor.visitList(dumpState_cantFindTypeExceptions);
      dumpState_cantFindTypeExceptions = null;
    }
  }

  // ==========================================================================
  // ===
  // T Y P E R E S O L U T I O N
  // ==========================================================================
  // ===

  /**
   * Resolve a type that we require to be present in the world
   */
  public ResolvedType resolve(UnresolvedType ty) {
    return resolve(ty, false);
  }

  /**
   * Attempt to resolve a type - the source location gives you some context in which resolution is taking place. In the case of an
   * error where we can't find the type - we can then at least report why (source location) we were trying to resolve it.
   */
  public ResolvedType resolve(UnresolvedType ty, ISourceLocation isl) {
    ResolvedType ret = resolve(ty, true);
    if (ResolvedType.isMissing(ty)) {
      // IMessage msg = null;
      getLint().cantFindType.signal(WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE, ty.getName()), isl);
      // if (isl!=null) {
      // msg = MessageUtil.error(WeaverMessages.format(WeaverMessages.
      // CANT_FIND_TYPE,ty.getName()),isl);
      // } else {
      // msg = MessageUtil.error(WeaverMessages.format(WeaverMessages.
      // CANT_FIND_TYPE,ty.getName()));
      // }
      // messageHandler.handleMessage(msg);
    }
    return ret;
  }

  /**
   * Convenience method for resolving an array of unresolved types in one hit. Useful for e.g. resolving type parameters in
   * signatures.
   */
  public ResolvedType[] resolve(UnresolvedType[] types) {
    if (types == null) {
      return ResolvedType.NONE;
    }

    ResolvedType[] ret = new ResolvedType[types.length];
    for (int i = 0; i < types.length; i++) {
      ret[i] = resolve(types[i]);
    }
    return ret;
  }

  /**
   * Resolve a type. This the hub of type resolution. The resolved type is added to the type map by signature.
   */
  public ResolvedType resolve(UnresolvedType ty, boolean allowMissing) {

    // special resolution processing for already resolved types.
    if (ty instanceof ResolvedType) {
      ResolvedType rty = (ResolvedType) ty;
      rty = resolve(rty);
      // A TypeVariableReferenceType may look like it is resolved (it extends ResolvedType) but the internal
      // type variable may not yet have been resolved
      if (!rty.isTypeVariableReference() || ((TypeVariableReferenceType) rty).isTypeVariableResolved()) {
        return rty;
      }
    }

    // dispatch back to the type variable reference to resolve its
    // constituent parts don't do this for other unresolved types otherwise
    // you'll end up in a
    // loop
    if (ty.isTypeVariableReference()) {
      return ty.resolve(this);
    }

    // if we've already got a resolved type for the signature, just return
    // it
    // after updating the world
    String signature = ty.getSignature();
    ResolvedType ret = typeMap.get(signature);
    if (ret != null) {
      ret.world = this; // Set the world for the RTX
      return ret;
    } else if (signature.equals("?") || signature.equals("*")) {
      // might be a problem here, not sure '?' should make it to here as a
      // signature, the
      // proper signature for wildcard '?' is '*'
      // fault in generic wildcard, can't be done earlier because of init
      // issues
      // TODO ought to be shared single instance representing this
      ResolvedType something = getWildcard();
      typeMap.put("?", something);
      return something;
    }

    // no existing resolved type, create one
    synchronized (buildingTypeLock) {
      if (ty.isArray()) {
        ResolvedType componentType = resolve(ty.getComponentType(), allowMissing);
        ret = new ArrayReferenceType(signature, "[" + componentType.getErasureSignature(), this, componentType);
      } else {
        ret = resolveToReferenceType(ty, allowMissing);
        if (!allowMissing && ret.isMissing()) {
          ret = handleRequiredMissingTypeDuringResolution(ty);
        }
        if (completeBinaryTypes) {
          completeBinaryType(ret);
        }
      }
    }

    // Pulling in the type may have already put the right entry in the map
    ResolvedType result = typeMap.get(signature);
    if (result == null && !ret.isMissing()) {
      ret = ensureRawTypeIfNecessary(ret);
      typeMap.put(signature, ret);
      return ret;
    }
    if (result == null) {
      return ret;
    } else {
      return result;
    }
  }

  private Object buildingTypeLock = new Object();

  // Only need one representation of '?' in a world - can be shared
  private BoundedReferenceType wildcard;

  private BoundedReferenceType getWildcard() {
    if (wildcard == null) {
      wildcard = new BoundedReferenceType(this);
    }
    return wildcard;
  }

  /**
   * Called when a type is resolved - enables its type hierarchy to be finished off before we proceed
   */
  protected void completeBinaryType(ResolvedType ret) {
  }

  /**
   * Return true if the classloader relating to this world is definetly the one that will define the specified class. Return false
   * otherwise or we don't know for certain.
   */
  public boolean isLocallyDefined(String classname) {
    return false;
  }

  /**
   * We tried to resolve a type and couldn't find it...
   */
  private ResolvedType handleRequiredMissingTypeDuringResolution(UnresolvedType ty) {
    // defer the message until someone asks a question of the type that we
    // can't answer
    // just from the signature.
    // MessageUtil.error(messageHandler,
    // WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE,ty.getName()));
    if (dumpState_cantFindTypeExceptions == null) {
      dumpState_cantFindTypeExceptions = new ArrayList<RuntimeException>();
    }
    if (dumpState_cantFindTypeExceptions.size() < 100) { // limit growth
      dumpState_cantFindTypeExceptions.add(new RuntimeException("Can't find type " + ty.getName()));
    }
    return new MissingResolvedTypeWithKnownSignature(ty.getSignature(), this);
  }

  /**
   * Some TypeFactory operations create resolved types directly, but these won't be in the typeMap - this resolution process puts
   * them there. Resolved types are also told their world which is needed for the special autoboxing resolved types.
   */
  public ResolvedType resolve(ResolvedType ty) {
    if (ty.isTypeVariableReference()) {
      return ty; // until type variables have proper sigs...
    }
    ResolvedType resolved = typeMap.get(ty.getSignature());
    if (resolved == null) {
      resolved = ensureRawTypeIfNecessary(ty);
      typeMap.put(ty.getSignature(), resolved);
      resolved = ty;
    }
    resolved.world = this;
    return resolved;
  }

  /**
   * When the world is operating in 1.5 mode, the TypeMap should only contain RAW types and never directly generic types. The RAW
   * type will contain a reference to the generic type.
   *
   * @param type a possibly generic type for which the raw needs creating as it is not currently in the world
   * @return a type suitable for putting into the world
   */
  private ResolvedType ensureRawTypeIfNecessary(ResolvedType type) {
    if (!isInJava5Mode() || type.isRawType()) {
      return type;
    }
    // Key requirement here is if it is generic, create a RAW entry to be put in the map that points to it
    if (type instanceof ReferenceType && ((ReferenceType) type).getDelegate() != null && type.isGenericType()) {
      ReferenceType rawType = new ReferenceType(type.getSignature(), this);
      rawType.typeKind = UnresolvedType.TypeKind.RAW;
      ReferenceTypeDelegate delegate = ((ReferenceType) type).getDelegate();
      rawType.setDelegate(delegate);
      rawType.setGenericType((ReferenceType) type);
      return rawType;
    }
    // probably parameterized...
    return type;
  }

  /**
   * Convenience method for finding a type by name and resolving it in one step.
   */
  public ResolvedType resolve(String name) {
    // trace.enter("resolve", this, new Object[] {name});
    ResolvedType ret = resolve(UnresolvedType.forName(name));
    // trace.exit("resolve", ret);
    return ret;
  }

  public ReferenceType resolveToReferenceType(String name) {
    return (ReferenceType) resolve(name);
  }

  public ResolvedType resolve(String name, boolean allowMissing) {
    return resolve(UnresolvedType.forName(name), allowMissing);
  }

  /**
   * Resolve to a ReferenceType - simple, raw, parameterized, or generic. Raw, parameterized, and generic versions of a type share
   * a delegate.
   */
  private final ResolvedType resolveToReferenceType(UnresolvedType ty, boolean allowMissing) {
    if (ty.isParameterizedType()) {
      // ======= parameterized types ================
      ResolvedType rt = resolveGenericTypeFor(ty, allowMissing);
      if (rt.isMissing()) {
        return rt;
      }
      ReferenceType genericType = (ReferenceType) rt;
      ReferenceType parameterizedType = TypeFactory.createParameterizedType(genericType, ty.typeParameters, this);
      return parameterizedType;

    } else if (ty.isGenericType()) {
      // ======= generic types ======================
      ResolvedType rt = resolveGenericTypeFor(ty, false);
      ReferenceType genericType = (ReferenceType) rt;
      return genericType;

    } else if (ty.isGenericWildcard()) {
      // ======= generic wildcard types =============
      return resolveGenericWildcardFor((WildcardedUnresolvedType) ty);
    } else {
      // ======= simple and raw types ===============
      String erasedSignature = ty.getErasureSignature();
      ReferenceType simpleOrRawType = new ReferenceType(erasedSignature, this);
      if (ty.needsModifiableDelegate()) {
        simpleOrRawType.setNeedsModifiableDelegate(true);
      }
      ReferenceTypeDelegate delegate = resolveDelegate(simpleOrRawType);
      // 117854
      // if (delegate == null) return ResolvedType.MISSING;
      if (delegate == null) {
        return new MissingResolvedTypeWithKnownSignature(ty.getSignature(), erasedSignature, this);// ResolvedType
        // .
        // MISSING
        // ;
      }

      if (delegate.isGeneric() && behaveInJava5Way) {
        // ======== raw type ===========
        simpleOrRawType.typeKind = TypeKind.RAW;
        ReferenceType genericType = makeGenericTypeFrom(delegate, simpleOrRawType);
        // name =
        // ReferenceType.fromTypeX(UnresolvedType.forRawTypeNames(
        // ty.getName()),this);
        simpleOrRawType.setDelegate(delegate);
        genericType.setDelegate(delegate);
        simpleOrRawType.setGenericType(genericType);
        return simpleOrRawType;

      } else {
        // ======== simple type =========
        simpleOrRawType.setDelegate(delegate);
        return simpleOrRawType;
      }
    }
  }

  /**
   * Attempt to resolve a type that should be a generic type.
   */
  public ResolvedType resolveGenericTypeFor(UnresolvedType anUnresolvedType, boolean allowMissing) {
    // Look up the raw type by signature
    String rawSignature = anUnresolvedType.getRawType().getSignature();
    ResolvedType rawType = typeMap.get(rawSignature);
    if (rawType == null) {
      rawType = resolve(UnresolvedType.forSignature(rawSignature), allowMissing);
      typeMap.put(rawSignature, rawType);
    }
    if (rawType.isMissing()) {
      return rawType;
    }

    // Does the raw type know its generic form? (It will if we created the
    // raw type from a source type, it won't if its been created just
    // through
    // being referenced, e.g. java.util.List
    ResolvedType genericType = rawType.getGenericType();

    // There is a special case to consider here (testGenericsBang_pr95993
    // highlights it)
    // You may have an unresolvedType for a parameterized type but it
    // is backed by a simple type rather than a generic type. This occurs
    // for
    // inner types of generic types that inherit their enclosing types
    // type variables.
    if (rawType.isSimpleType() && (anUnresolvedType.typeParameters == null || anUnresolvedType.typeParameters.length == 0)) {
      rawType.world = this;
      return rawType;
    }

    if (genericType != null) {
      genericType.world = this;
      return genericType;
    } else {
      // Fault in the generic that underpins the raw type ;)
      ReferenceTypeDelegate delegate = resolveDelegate((ReferenceType) rawType);
      ReferenceType genericRefType = makeGenericTypeFrom(delegate, ((ReferenceType) rawType));
      ((ReferenceType) rawType).setGenericType(genericRefType);
      genericRefType.setDelegate(delegate);
      ((ReferenceType) rawType).setDelegate(delegate);
      return genericRefType;
    }
  }

  private ReferenceType makeGenericTypeFrom(ReferenceTypeDelegate delegate, ReferenceType rawType) {
    String genericSig = delegate.getDeclaredGenericSignature();
    if (genericSig != null) {
      return new ReferenceType(UnresolvedType.forGenericTypeSignature(rawType.getSignature(),
          delegate.getDeclaredGenericSignature()), this);
    } else {
      return new ReferenceType(UnresolvedType.forGenericTypeVariables(rawType.getSignature(), delegate.getTypeVariables()),
          this);
    }
  }

  /**
   * Go from an unresolved generic wildcard (represented by UnresolvedType) to a resolved version (BoundedReferenceType).
   */
  private ReferenceType resolveGenericWildcardFor(WildcardedUnresolvedType aType) {
    BoundedReferenceType ret = null;
    // FIXME asc doesnt take account of additional interface bounds (e.g. ?
    // super R & Serializable - can you do that?)
    if (aType.isExtends()) {
      ReferenceType upperBound = (ReferenceType) resolve(aType.getUpperBound());
      ret = new BoundedReferenceType(upperBound, true, this);
    } else if (aType.isSuper()) {
      ReferenceType lowerBound = (ReferenceType) resolve(aType.getLowerBound());
      ret = new BoundedReferenceType(lowerBound, false, this);
    } else {
      // must be ? on its own!
      ret = getWildcard();
    }
    return ret;
  }

  /**
   * Find the ReferenceTypeDelegate behind this reference type so that it can fulfill its contract.
   */
  protected abstract ReferenceTypeDelegate resolveDelegate(ReferenceType ty);

  /**
   * Special resolution for "core" types like OBJECT. These are resolved just like any other type, but if they are not found it is
   * more serious and we issue an error message immediately.
   */
  // OPTIMIZE streamline path for core types? They are just simple types,
  // could look straight in the typemap?
  public ResolvedType getCoreType(UnresolvedType tx) {
    ResolvedType coreTy = resolve(tx, true);
    if (coreTy.isMissing()) {
      MessageUtil.error(messageHandler, WeaverMessages.format(WeaverMessages.CANT_FIND_CORE_TYPE, tx.getName()));
    }
    return coreTy;
  }

  /**
   * Lookup a type by signature, if not found then build one and put it in the map.
   */
  public ReferenceType lookupOrCreateName(UnresolvedType ty) {
    String signature = ty.getSignature();
    ReferenceType ret = lookupBySignature(signature);
    if (ret == null) {
      ret = ReferenceType.fromTypeX(ty, this);
      typeMap.put(signature, ret);
    }
    return ret;
  }

  /**
   * Lookup a reference type in the world by its signature. Returns null if not found.
   */
  public ReferenceType lookupBySignature(String signature) {
    return (ReferenceType) typeMap.get(signature);
  }

  // ==========================================================================
  // ===
  // T Y P E R E S O L U T I O N -- E N D
  // ==========================================================================
  // ===

  /**
   * Member resolution is achieved by resolving the declaring type and then looking up the member in the resolved declaring type.
   */
  public ResolvedMember resolve(Member member) {
    ResolvedType declaring = member.getDeclaringType().resolve(this);
    if (declaring.isRawType()) {
      declaring = declaring.getGenericType();
    }
    ResolvedMember ret;
    if (member.getKind() == Member.FIELD) {
      ret = declaring.lookupField(member);
    } else {
      ret = declaring.lookupMethod(member);
    }

    if (ret != null) {
      return ret;
    }

    return declaring.lookupSyntheticMember(member);
  }

  private boolean allLintIgnored = false;

  public void setAllLintIgnored() {
    allLintIgnored = true;
  }

  public boolean areAllLintIgnored() {
    return allLintIgnored;
  }

  public abstract IWeavingSupport getWeavingSupport();

  /**
   * Create an advice shadow munger from the given advice attribute
   */
  // public abstract Advice createAdviceMunger(AjAttribute.AdviceAttribute
  // attribute, Pointcut pointcut, Member signature);
  /**
   * Create an advice shadow munger for the given advice kind
   */
  public final Advice createAdviceMunger(AdviceKind kind, Pointcut p, Member signature, int extraParameterFlags,
      IHasSourceLocation loc, ResolvedType declaringAspect) {
    AjAttribute.AdviceAttribute attribute = new AjAttribute.AdviceAttribute(kind, p, extraParameterFlags, loc.getStart(),
        loc.getEnd(), loc.getSourceContext());
    return getWeavingSupport().createAdviceMunger(attribute, p, signature, declaringAspect);
  }

  /**
   * Same signature as org.aspectj.util.PartialOrder.PartialComparable.compareTo
   */
  public int compareByPrecedence(ResolvedType aspect1, ResolvedType aspect2) {
    return precedenceCalculator.compareByPrecedence(aspect1, aspect2);
  }

  public Integer getPrecedenceIfAny(ResolvedType aspect1, ResolvedType aspect2) {
    return precedenceCalculator.getPrecedenceIfAny(aspect1, aspect2);
  }

  /**
   * compares by precedence with the additional rule that a super-aspect is sorted before its sub-aspects
   */
  public int compareByPrecedenceAndHierarchy(ResolvedType aspect1, ResolvedType aspect2) {
    return precedenceCalculator.compareByPrecedenceAndHierarchy(aspect1, aspect2);
  }

  // simple property getter and setters
  // ===========================================================

  /**
   * Nobody should hold onto a copy of this message handler, or setMessageHandler won't work right.
   */
  public IMessageHandler getMessageHandler() {
    return messageHandler;
  }

  public void setMessageHandler(IMessageHandler messageHandler) {
    if (this.isInPinpointMode()) {
      this.messageHandler = new PinpointingMessageHandler(messageHandler);
    } else {
      this.messageHandler = messageHandler;
    }
  }

  /**
   * convenenience method for creating and issuing messages via the message handler - if you supply two locations you will get two
   * messages.
   */
  public void showMessage(Kind kind, String message, ISourceLocation loc1, ISourceLocation loc2) {
    if (loc1 != null) {
      messageHandler.handleMessage(new Message(message, kind, null, loc1));
      if (loc2 != null) {
        messageHandler.handleMessage(new Message(message, kind, null, loc2));
      }
    } else {
      messageHandler.handleMessage(new Message(message, kind, null, loc2));
    }
  }

  public void setCrossReferenceHandler(ICrossReferenceHandler xrefHandler) {
    this.xrefHandler = xrefHandler;
  }

  /**
   * Get the cross-reference handler for the world, may be null.
   */
  public ICrossReferenceHandler getCrossReferenceHandler() {
    return xrefHandler;
  }

  public void setTypeVariableLookupScope(TypeVariableDeclaringElement scope) {
    typeVariableLookupScope = scope;
  }

  public TypeVariableDeclaringElement getTypeVariableLookupScope() {
    return typeVariableLookupScope;
  }

  public List<DeclareParents> getDeclareParents() {
    return crosscuttingMembersSet.getDeclareParents();
  }

  public List<DeclareAnnotation> getDeclareAnnotationOnTypes() {
    return crosscuttingMembersSet.getDeclareAnnotationOnTypes();
  }

  public List<DeclareAnnotation> getDeclareAnnotationOnFields() {
    return crosscuttingMembersSet.getDeclareAnnotationOnFields();
  }

  public List<DeclareAnnotation> getDeclareAnnotationOnMethods() {
    return crosscuttingMembersSet.getDeclareAnnotationOnMethods();
  }

  public List<DeclareTypeErrorOrWarning> getDeclareTypeEows() {
    return crosscuttingMembersSet.getDeclareTypeEows();
  }

  public List<DeclareSoft> getDeclareSoft() {
    return crosscuttingMembersSet.getDeclareSofts();
  }

  public CrosscuttingMembersSet getCrosscuttingMembersSet() {
    return crosscuttingMembersSet;
  }

  public IStructureModel getModel() {
    return model;
  }

  public void setModel(IStructureModel model) {
    this.model = model;
  }

  public Lint getLint() {
    return lint;
  }

  public void setLint(Lint lint) {
    this.lint = lint;
  }

  public boolean isXnoInline() {
    return XnoInline;
  }

  public void setXnoInline(boolean xnoInline) {
    XnoInline = xnoInline;
  }

  public boolean isXlazyTjp() {
    return XlazyTjp;
  }

  public void setXlazyTjp(boolean b) {
    XlazyTjp = b;
  }

  public boolean isHasMemberSupportEnabled() {
    return XhasMember;
  }

  public void setXHasMemberSupportEnabled(boolean b) {
    XhasMember = b;
  }

  public boolean isInPinpointMode() {
    return Xpinpoint;
  }

  public void setPinpointMode(boolean b) {
    Xpinpoint = b;
  }

  public boolean isMinimalModel() {
    ensureAdvancedConfigurationProcessed();
    return minimalModel;
  }

  public boolean isTargettingRuntime1_6_10() {
    ensureAdvancedConfigurationProcessed();
    return targettingRuntime1_6_10;
  }

  public void setBehaveInJava5Way(boolean b) {
    behaveInJava5Way = b;
  }

  /**
   * Set the timing option (whether to collect timing info), this will also need INFO messages turned on for the message handler
   * being used. The reportPeriodically flag should be set to false under AJDT so numbers just come out at the end.
   */
  public void setTiming(boolean timersOn, boolean reportPeriodically) {
    timing = timersOn;
    timingPeriodically = reportPeriodically;
  }

  /**
   * Set the error and warning threashold which can be taken from CompilerOptions (see bug 129282)
   *
   * @param errorThreshold
   * @param warningThreshold
   */
  public void setErrorAndWarningThreshold(long errorThreshold, long warningThreshold) {
    this.errorThreshold = errorThreshold;
    this.warningThreshold = warningThreshold;
  }

  /**
   * @return true if ignoring the UnusedDeclaredThrownException and false if this compiler option is set to error or warning
   */
  public boolean isIgnoringUnusedDeclaredThrownException() {
    // the 0x800000 is CompilerOptions.UnusedDeclaredThrownException
    // which is ASTNode.bit24
    if ((errorThreshold & 0x800000) != 0 || (warningThreshold & 0x800000) != 0) {
      return false;
    }
    return true;
  }

  public void performExtraConfiguration(String config) {
    if (config == null) {
      return;
    }
    // Bunch of name value pairs to split
    extraConfiguration = new Properties();
    int pos = -1;
    while ((pos = config.indexOf(",")) != -1) {
      String nvpair = config.substring(0, pos);
      int pos2 = nvpair.indexOf("=");
      if (pos2 != -1) {
        String n = nvpair.substring(0, pos2);
        String v = nvpair.substring(pos2 + 1);
        extraConfiguration.setProperty(n, v);
      }
      config = config.substring(pos + 1);
    }
    if (config.length() > 0) {
      int pos2 = config.indexOf("=");
      if (pos2 != -1) {
        String n = config.substring(0, pos2);
        String v = config.substring(pos2 + 1);
        extraConfiguration.setProperty(n, v);
      }
    }
    ensureAdvancedConfigurationProcessed();
  }

  public boolean areInfoMessagesEnabled() {
    if (infoMessagesEnabled == 0) {
      infoMessagesEnabled = (messageHandler.isIgnoring(IMessage.INFO) ? 1 : 2);
    }
    return infoMessagesEnabled == 2;
  }

  /**
   * may return null
   */
  public Properties getExtraConfiguration() {
    return extraConfiguration;
  }

  public final static String xsetWEAVE_JAVA_PACKAGES = "weaveJavaPackages"; // default
  // false
  // -
  // controls
  // LTW
  public final static String xsetWEAVE_JAVAX_PACKAGES = "weaveJavaxPackages"; // default
  // false
  // -
  // controls
  // LTW
  public final static String xsetCAPTURE_ALL_CONTEXT = "captureAllContext"; // default
  // false
  public final static String xsetRUN_MINIMAL_MEMORY = "runMinimalMemory"; // default
  // true
  public final static String xsetDEBUG_STRUCTURAL_CHANGES_CODE = "debugStructuralChangesCode"; // default
  // false
  public final static String xsetDEBUG_BRIDGING = "debugBridging"; // default
  // false
  public final static String xsetBCEL_REPOSITORY_CACHING = "bcelRepositoryCaching";
  public final static String xsetPIPELINE_COMPILATION = "pipelineCompilation";
  public final static String xsetGENERATE_STACKMAPS = "generateStackMaps";
  public final static String xsetPIPELINE_COMPILATION_DEFAULT = "true";
  public final static String xsetCOMPLETE_BINARY_TYPES = "completeBinaryTypes";
  public final static String xsetCOMPLETE_BINARY_TYPES_DEFAULT = "false";
  public final static String xsetTYPE_DEMOTION = "typeDemotion";
  public final static String xsetTYPE_DEMOTION_DEBUG = "typeDemotionDebug";
  public final static String xsetTYPE_REFS = "useWeakTypeRefs";
  public final static String xsetBCEL_REPOSITORY_CACHING_DEFAULT = "true";
  public final static String xsetFAST_PACK_METHODS = "fastPackMethods"; // default true
  public final static String xsetOVERWEAVING = "overWeaving";
  public final static String xsetOPTIMIZED_MATCHING = "optimizedMatching";
  public final static String xsetTIMERS_PER_JOINPOINT = "timersPerJoinpoint";
  public final static String xsetTIMERS_PER_FASTMATCH_CALL = "timersPerFastMatchCall";
  public final static String xsetITD_VERSION = "itdVersion";
  public final static String xsetITD_VERSION_ORIGINAL = "1";
  public final static String xsetITD_VERSION_2NDGEN = "2";
  public final static String xsetITD_VERSION_DEFAULT = xsetITD_VERSION_2NDGEN;
  public final static String xsetMINIMAL_MODEL = "minimalModel";
  public final static String xsetTARGETING_RUNTIME_1610 = "targetRuntime1_6_10";

  public boolean isInJava5Mode() {
    return behaveInJava5Way;
  }

  public boolean isTimingEnabled() {
    return timing;
  }

  public void setTargetAspectjRuntimeLevel(String s) {
    targetAspectjRuntimeLevel = s;
  }

  public void setOptionalJoinpoints(String jps) {
    if (jps == null) {
      return;
    }
    if (jps.indexOf("arrayconstruction") != -1) {
      optionalJoinpoint_ArrayConstruction = true;
    }
    if (jps.indexOf("synchronization") != -1) {
      optionalJoinpoint_Synchronization = true;
    }
  }

  public boolean isJoinpointArrayConstructionEnabled() {
    return optionalJoinpoint_ArrayConstruction;
  }

  public boolean isJoinpointSynchronizationEnabled() {
    return optionalJoinpoint_Synchronization;
  }

  public String getTargetAspectjRuntimeLevel() {
    return targetAspectjRuntimeLevel;
  }

  // OPTIMIZE are users falling foul of not supplying -1.5 and so targetting
  // the old runtime?
  public boolean isTargettingAspectJRuntime12() {
    boolean b = false; // pr116679
    if (!isInJava5Mode()) {
      b = true;
    } else {
      b = getTargetAspectjRuntimeLevel().equals(org.aspectj.weaver.Constants.RUNTIME_LEVEL_12);
    }
    // System.err.println("Asked if targetting runtime 1.2 , returning: "+b);
    return b;
  }

  /*
   * Map of types in the world, can have 'references' to expendable ones which can be garbage collected to recover memory. An
   * expendable type is a reference type that is not exposed to the weaver (ie just pulled in for type resolution purposes).
   */
  public static class TypeMap {

    // Strategy for entries in the expendable map
    public final static int DONT_USE_REFS = 0; // Hang around forever
    public final static int USE_WEAK_REFS = 1; // Collected asap
    public final static int USE_SOFT_REFS = 2; // Collected when short on memory

    public List<String> addedSinceLastDemote;
    public List<String> writtenClasses;

    private static boolean debug = false;
    public static boolean useExpendableMap = true; // configurable for reliable testing
    private boolean demotionSystemActive;
    private boolean debugDemotion = false;

    public int policy = USE_WEAK_REFS;

    // Map of types that never get thrown away
    final Map<String, ResolvedType> tMap = new HashMap<String, ResolvedType>();

    // Map of types that may be ejected from the cache if we need space
    final Map<String, Reference<ResolvedType>> expendableMap = Collections
        .synchronizedMap(new WeakHashMap<String, Reference<ResolvedType>>());

    private final World w;

    // profiling tools...
    private boolean memoryProfiling = false;
    private int maxExpendableMapSize = -1;
    private int collectedTypes = 0;
    private final ReferenceQueue<ResolvedType> rq = new ReferenceQueue<ResolvedType>();

    // private static Trace trace = TraceFactory.getTraceFactory().getTrace(World.TypeMap.class);

    TypeMap(World w) {
      // Demotion activated when switched on and loadtime weaving or in AJDT
      demotionSystemActive = w.isDemotionActive() && (w.isLoadtimeWeaving() || w.couldIncrementalCompileFollow());
      addedSinceLastDemote = new ArrayList<String>();
      writtenClasses = new ArrayList<String>();
      this.w = w;
      memoryProfiling = false;// !w.getMessageHandler().isIgnoring(Message.
      // INFO);
    }

    // For testing
    public Map<String, Reference<ResolvedType>> getExpendableMap() {
      return expendableMap;
    }

    // For testing
    public Map<String, ResolvedType> getMainMap() {
      return tMap;
    }

    public int demote() {
      return demote(false);
    }

    /**
     * Go through any types added during the previous file weave. If any are suitable for demotion, then put them in the
     * expendable map where GC can claim them at some point later. Demotion means: the type is not an aspect, the type is not
     * java.lang.Object, the type is not primitive and the type is not affected by type mungers in any way. Further refinements
     * of these conditions may allow for more demotions.
     *
     * @return number of types demoted
     */
    public int demote(boolean atEndOfCompile) {
      if (!demotionSystemActive) {
        return 0;
      }
      if (debugDemotion) {
        System.out.println("Demotion running " + addedSinceLastDemote);
      }
      boolean isLtw = w.isLoadtimeWeaving();
      int demotionCounter = 0;
      if (isLtw) {
        // Loadtime weaving demotion strategy
        for (String key : addedSinceLastDemote) {
          ResolvedType type = tMap.get(key);
          if (type != null && !type.isAspect() && !type.equals(UnresolvedType.OBJECT) && !type.isPrimitiveType()) {
            List<ConcreteTypeMunger> typeMungers = type.getInterTypeMungers();
            if (typeMungers == null || typeMungers.size() == 0) {
              tMap.remove(key);
              insertInExpendableMap(key, type);
              demotionCounter++;
            }
          }
        }
        addedSinceLastDemote.clear();
      } else {
        // Compile time demotion strategy
        List<String> forRemoval = new ArrayList<String>();
        for (String key : addedSinceLastDemote) {
          ResolvedType type = tMap.get(key);
          if (type == null) {
            // TODO not 100% sure why it is not there, where did it go?
            forRemoval.add(key);
            continue;
          }
          if (!writtenClasses.contains(type.getName())) { // COSTLY
            continue;
          }
          if (type != null && !type.isAspect() && !type.equals(UnresolvedType.OBJECT) && !type.isPrimitiveType()) {
            List<ConcreteTypeMunger> typeMungers = type.getInterTypeMungers();
            if (typeMungers == null || typeMungers.size() == 0) {
              /*
               * if (type.isNested()) { try { ReferenceType rt = (ReferenceType) w.resolve(type.getOutermostType());
               * if (!rt.isMissing()) { ReferenceTypeDelegate delegate = ((ReferenceType) type).getDelegate(); boolean
               * isWeavable = delegate == null ? false : delegate.isExposedToWeaver(); boolean hasBeenWoven = delegate
               * == null ? false : delegate.hasBeenWoven(); if (isWeavable && !hasBeenWoven) { // skip demotion of
               * this inner type for now continue; } } } catch (ClassCastException cce) { cce.printStackTrace();
               * System.out.println("outer of " + key + " is not a reftype? " + type.getOutermostType()); // throw new
               * IllegalStateException(cce); } }
               */
              ReferenceTypeDelegate delegate = ((ReferenceType) type).getDelegate();
              boolean isWeavable = delegate == null ? false : delegate.isExposedToWeaver();
              boolean hasBeenWoven = delegate == null ? false : delegate.hasBeenWoven();
              if (!isWeavable || hasBeenWoven) {
                if (debugDemotion) {
                  System.out.println("Demoting " + key);
                }
                forRemoval.add(key);
                tMap.remove(key);
                insertInExpendableMap(key, type);
                demotionCounter++;
              }
            } else {
              // no need to try this again, it will never be demoted
              writtenClasses.remove(type.getName());
              forRemoval.add(key);
            }
          } else {
            writtenClasses.remove(type.getName());
            // no need to try this again, it will never be demoted
            forRemoval.add(key);
          }
        }
        addedSinceLastDemote.removeAll(forRemoval);
      }
      if (debugDemotion) {
        System.out.println("Demoted " + demotionCounter + " types.  Types remaining in fixed set #" + tMap.keySet().size()
            + ".  addedSinceLastDemote size is " + addedSinceLastDemote.size());
        System.out.println("writtenClasses.size() = " + writtenClasses.size() + ": " + writtenClasses);
      }
      if (atEndOfCompile) {
        if (debugDemotion) {
          System.out.println("Clearing writtenClasses");
        }
        writtenClasses.clear();
      }
      return demotionCounter;
    }

    private void insertInExpendableMap(String key, ResolvedType type) {
      if (useExpendableMap) {
        if (!expendableMap.containsKey(key)) {
          if (policy == USE_SOFT_REFS) {
            expendableMap.put(key, new SoftReference<ResolvedType>(type));
          } else {
            expendableMap.put(key, new WeakReference<ResolvedType>(type));
          }
        }
      }
    }

    /**
     * Add a new type into the map, the key is the type signature. Some types do *not* go in the map, these are ones involving
     * *member* type variables. The reason is that when all you have is the signature which gives you a type variable name, you
     * cannot guarantee you are using the type variable in the same way as someone previously working with a similarly named
     * type variable. So, these do not go into the map: - TypeVariableReferenceType. - ParameterizedType where a member type
     * variable is involved. - BoundedReferenceType when one of the bounds is a type variable.
     *
     * definition: "member type variables" - a tvar declared on a generic method/ctor as opposed to those you see declared on a
     * generic type.
     */
    public ResolvedType put(String key, ResolvedType type) {
      if (!type.isCacheable()) {
        return type;
      }
      if (type.isParameterizedType() && type.isParameterizedWithTypeVariable()) {
        if (debug) {
          System.err
              .println("Not putting a parameterized type that utilises member declared type variables into the typemap: key="
                  + key + " type=" + type);
        }
        return type;
      }
      if (type.isTypeVariableReference()) {
        if (debug) {
          System.err.println("Not putting a type variable reference type into the typemap: key=" + key + " type=" + type);
        }
        return type;
      }
      // this test should be improved - only avoid putting them in if one
      // of the
      // bounds is a member type variable
      if (type instanceof BoundedReferenceType) {
        if (debug) {
          System.err.println("Not putting a bounded reference type into the typemap: key=" + key + " type=" + type);
        }
        return type;
      }
      if (type instanceof MissingResolvedTypeWithKnownSignature) {
        if (debug) {
          System.err.println("Not putting a missing type into the typemap: key=" + key + " type=" + type);
        }
        return type;
      }

      if ((type instanceof ReferenceType) && (((ReferenceType) type).getDelegate() == null) && w.isExpendable(type)) {
        if (debug) {
          System.err.println("Not putting expendable ref type with null delegate into typemap: key=" + key + " type="
              + type);
        }
        return type;
      }

      // TODO should this be in as a permanent assertion?
      /*
       * if ((type instanceof ReferenceType) && type.getWorld().isInJava5Mode() && (((ReferenceType) type).getDelegate() !=
       * null) && type.isGenericType()) { throw new BCException("Attempt to add generic type to typemap " + type.toString() +
       * " (should be raw)"); }
       */

      if (w.isExpendable(type)) {
        if (useExpendableMap) {
          // Dont use reference queue for tracking if not profiling...
          if (policy == USE_WEAK_REFS) {
            if (memoryProfiling) {
              expendableMap.put(key, new WeakReference<ResolvedType>(type, rq));
            } else {
              expendableMap.put(key, new WeakReference<ResolvedType>(type));
            }
          } else if (policy == USE_SOFT_REFS) {
            if (memoryProfiling) {
              expendableMap.put(key, new SoftReference<ResolvedType>(type, rq));
            } else {
              expendableMap.put(key, new SoftReference<ResolvedType>(type));
            }
            // } else {
            // expendableMap.put(key, type);
          }
        }
        if (memoryProfiling && expendableMap.size() > maxExpendableMapSize) {
          maxExpendableMapSize = expendableMap.size();
        }
        return type;
      } else {

        if (demotionSystemActive) {
          // System.out.println("Added since last demote " + key);
          addedSinceLastDemote.add(key);
        }

        return tMap.put(key, type);
      }
    }

    public void report() {
      if (!memoryProfiling) {
        return;
      }
      checkq();
      w.getMessageHandler().handleMessage(
          MessageUtil.info("MEMORY: world expendable type map reached maximum size of #" + maxExpendableMapSize
              + " entries"));
      w.getMessageHandler().handleMessage(
          MessageUtil.info("MEMORY: types collected through garbage collection #" + collectedTypes + " entries"));
    }

    public void checkq() {
      if (!memoryProfiling) {
        return;
      }
      while (rq.poll() != null) {
        collectedTypes++;
      }
    }

    /**
     * Lookup a type by its signature, always look in the real map before the expendable map
     */
    public ResolvedType get(String key) {
      checkq();
      ResolvedType ret = tMap.get(key);
      if (ret == null) {
        if (policy == USE_WEAK_REFS) {
          WeakReference<ResolvedType> ref = (WeakReference<ResolvedType>) expendableMap.get(key);
          if (ref != null) {
            ret = ref.get();
          }
        } else if (policy == USE_SOFT_REFS) {
          SoftReference<ResolvedType> ref = (SoftReference<ResolvedType>) expendableMap.get(key);
          if (ref != null) {
            ret = ref.get();
          }
          // } else {
          // return (ResolvedType) expendableMap.get(key);
        }
      }
      return ret;
    }

    /** Remove a type from the map */
    public ResolvedType remove(String key) {
      ResolvedType ret = tMap.remove(key);
      if (ret == null) {
        if (policy == USE_WEAK_REFS) {
          WeakReference<ResolvedType> wref = (WeakReference<ResolvedType>) expendableMap.remove(key);
          if (wref != null) {
            ret = wref.get();
          }
        } else if (policy == USE_SOFT_REFS) {
          SoftReference<ResolvedType> wref = (SoftReference<ResolvedType>) expendableMap.remove(key);
          if (wref != null) {
            ret = wref.get();
          }
          // } else {
          // ret = (ResolvedType) expendableMap.remove(key);
        }
      }
      return ret;
    }

    public void classWriteEvent(String classname) {
      // that is a name com.Foo and not a signature Lcom/Foo; boooooooooo!
      if (demotionSystemActive) {
        writtenClasses.add(classname);
      }
      if (debugDemotion) {
        System.out.println("Class write event for " + classname);
      }
    }

    // public ResolvedType[] getAllTypes() {
    // List/* ResolvedType */results = new ArrayList();
    //
    // collectTypes(expendableMap, results);
    // collectTypes(tMap, results);
    // return (ResolvedType[]) results.toArray(new
    // ResolvedType[results.size()]);
    // }
    //
    // private void collectTypes(Map map, List/* ResolvedType */results) {
    // for (Iterator iterator = map.keySet().iterator();
    // iterator.hasNext();) {
    // String key = (String) iterator.next();
    // ResolvedType type = get(key);
    // if (type != null)
    // results.add(type);
    // else
    // System.err.println("null!:" + key);
    // }
    // }

  }

  /**
   * This class is used to compute and store precedence relationships between aspects.
   */
  private static class AspectPrecedenceCalculator {

    private final World world;
    private final Map<PrecedenceCacheKey, Integer> cachedResults;

    public AspectPrecedenceCalculator(World forSomeWorld) {
      world = forSomeWorld;
      cachedResults = new HashMap<PrecedenceCacheKey, Integer>();
    }

    /**
     * Ask every declare precedence in the world to order the two aspects. If more than one declare precedence gives an
     * ordering, and the orderings conflict, then that's an error.
     */
    public int compareByPrecedence(ResolvedType firstAspect, ResolvedType secondAspect) {
      PrecedenceCacheKey key = new PrecedenceCacheKey(firstAspect, secondAspect);
      if (cachedResults.containsKey(key)) {
        return (cachedResults.get(key)).intValue();
      } else {
        int order = 0;
        DeclarePrecedence orderer = null; // Records the declare
        // precedence statement that
        // gives the first ordering
        for (Iterator<Declare> i = world.getCrosscuttingMembersSet().getDeclareDominates().iterator(); i.hasNext();) {
          DeclarePrecedence d = (DeclarePrecedence) i.next();
          int thisOrder = d.compare(firstAspect, secondAspect);
          if (thisOrder != 0) {
            if (orderer == null) {
              orderer = d;
            }
            if (order != 0 && order != thisOrder) {
              ISourceLocation[] isls = new ISourceLocation[2];
              isls[0] = orderer.getSourceLocation();
              isls[1] = d.getSourceLocation();
              Message m = new Message("conflicting declare precedence orderings for aspects: "
                  + firstAspect.getName() + " and " + secondAspect.getName(), null, true, isls);
              world.getMessageHandler().handleMessage(m);
            } else {
              order = thisOrder;
            }
          }
        }
        cachedResults.put(key, new Integer(order));
        return order;
      }
    }

    public Integer getPrecedenceIfAny(ResolvedType aspect1, ResolvedType aspect2) {
      return cachedResults.get(new PrecedenceCacheKey(aspect1, aspect2));
    }

    public int compareByPrecedenceAndHierarchy(ResolvedType firstAspect, ResolvedType secondAspect) {
      if (firstAspect.equals(secondAspect)) {
        return 0;
      }

      int ret = compareByPrecedence(firstAspect, secondAspect);
      if (ret != 0) {
        return ret;
      }

      if (firstAspect.isAssignableFrom(secondAspect)) {
        return -1;
      } else if (secondAspect.isAssignableFrom(firstAspect)) {
        return +1;
      }

      return 0;
    }

    private static class PrecedenceCacheKey {
      public ResolvedType aspect1;
      public ResolvedType aspect2;

      public PrecedenceCacheKey(ResolvedType a1, ResolvedType a2) {
        aspect1 = a1;
        aspect2 = a2;
      }

      @Override
      public boolean equals(Object obj) {
        if (!(obj instanceof PrecedenceCacheKey)) {
          return false;
        }
        PrecedenceCacheKey other = (PrecedenceCacheKey) obj;
        return (aspect1 == other.aspect1 && aspect2 == other.aspect2);
      }

      @Override
      public int hashCode() {
        return aspect1.hashCode() + aspect2.hashCode();
      }
    }
  }

  public void validateType(UnresolvedType type) {
  }

  // --- with java5 we can get into a recursive mess if we aren't careful when
  // resolving types (*cough* java.lang.Enum) ---

  public boolean isDemotionActive() {
    return false;
  }

  // --- this first map is for java15 delegates which may try and recursively
  // access the same type variables.
  // --- I would rather stash this against a reference type - but we don't
  // guarantee referencetypes are unique for
  // so we can't :(
  private final Map<Class<?>, TypeVariable[]> workInProgress1 = new HashMap<Class<?>, TypeVariable[]>();

  public TypeVariable[] getTypeVariablesCurrentlyBeingProcessed(Class<?> baseClass) {
    return workInProgress1.get(baseClass);
  }

  public void recordTypeVariablesCurrentlyBeingProcessed(Class<?> baseClass, TypeVariable[] typeVariables) {
    workInProgress1.put(baseClass, typeVariables);
  }

  public void forgetTypeVariablesCurrentlyBeingProcessed(Class<?> baseClass) {
    workInProgress1.remove(baseClass);
  }

  public void setAddSerialVerUID(boolean b) {
    addSerialVerUID = b;
  }

  public boolean isAddSerialVerUID() {
    return addSerialVerUID;
  }

  /** be careful calling this - pr152257 */
  public void flush() {
    typeMap.expendableMap.clear();
  }

  public void ensureAdvancedConfigurationProcessed() {

    // Check *once* whether the user has switched asm support off
    if (!checkedAdvancedConfiguration) {
      Properties p = getExtraConfiguration();
      if (p != null) {

        String s = p.getProperty(xsetBCEL_REPOSITORY_CACHING, xsetBCEL_REPOSITORY_CACHING_DEFAULT);
        bcelRepositoryCaching = s.equalsIgnoreCase("true");
        if (!bcelRepositoryCaching) {
          getMessageHandler().handleMessage(
              MessageUtil
                  .info("[bcelRepositoryCaching=false] AspectJ will not use a bcel cache for class information"));
        }

        // ITD Versions
        // 1 is the first version in use up to AspectJ 1.6.8
        // 2 is from 1.6.9 onwards
        s = p.getProperty(xsetITD_VERSION, xsetITD_VERSION_DEFAULT);
        if (s.equals(xsetITD_VERSION_ORIGINAL)) {
          itdVersion = 1;
        }

        s = p.getProperty(xsetMINIMAL_MODEL, "false");
        if (s.equalsIgnoreCase("true")) {
          minimalModel = true;
        }

        s = p.getProperty(xsetTARGETING_RUNTIME_1610, "false");
        if (s.equalsIgnoreCase("true")) {
          targettingRuntime1_6_10 = true;
        }

        s = p.getProperty(xsetFAST_PACK_METHODS, "true");
        fastMethodPacking = s.equalsIgnoreCase("true");

        s = p.getProperty(xsetPIPELINE_COMPILATION, xsetPIPELINE_COMPILATION_DEFAULT);
        shouldPipelineCompilation = s.equalsIgnoreCase("true");

        s = p.getProperty(xsetGENERATE_STACKMAPS, "false");
        shouldGenerateStackMaps = s.equalsIgnoreCase("true");

        s = p.getProperty(xsetCOMPLETE_BINARY_TYPES, xsetCOMPLETE_BINARY_TYPES_DEFAULT);
        completeBinaryTypes = s.equalsIgnoreCase("true");
        if (completeBinaryTypes) {
          getMessageHandler().handleMessage(
              MessageUtil.info("[completeBinaryTypes=true] Completion of binary types activated"));
        }

        s = p.getProperty(xsetTYPE_DEMOTION); // default is: ON (for ltw) OFF (for ctw)
        if (s != null) {
          boolean b = typeMap.demotionSystemActive;
          if (b && s.equalsIgnoreCase("false")) {
            System.out.println("typeDemotion=false: type demotion switched OFF");
            typeMap.demotionSystemActive = false;
          } else if (!b && s.equalsIgnoreCase("true")) {
            System.out.println("typeDemotion=true: type demotion switched ON");
            typeMap.demotionSystemActive = true;
          }
        }

        s = p.getProperty(xsetOVERWEAVING, "false");
        if (s.equalsIgnoreCase("true")) {
          overWeaving = true;
        }

        s = p.getProperty(xsetTYPE_DEMOTION_DEBUG, "false");
        if (s.equalsIgnoreCase("true")) {
          typeMap.debugDemotion = true;
        }
        s = p.getProperty(xsetTYPE_REFS, "true");
        if (s.equalsIgnoreCase("false")) {
          typeMap.policy = TypeMap.USE_SOFT_REFS;
        }

        runMinimalMemorySet = p.getProperty(xsetRUN_MINIMAL_MEMORY) != null;
        s = p.getProperty(xsetRUN_MINIMAL_MEMORY, "false");
        runMinimalMemory = s.equalsIgnoreCase("true");
        // if (runMinimalMemory)
        // getMessageHandler().handleMessage(MessageUtil.info(
        // "[runMinimalMemory=true] Optimizing bcel processing (and cost of performance) to use less memory"
        // ));

        s = p.getProperty(xsetDEBUG_STRUCTURAL_CHANGES_CODE, "false");
        forDEBUG_structuralChangesCode = s.equalsIgnoreCase("true");

        s = p.getProperty(xsetDEBUG_BRIDGING, "false");
        forDEBUG_bridgingCode = s.equalsIgnoreCase("true");

        s = p.getProperty(xsetOPTIMIZED_MATCHING, "true");
        optimizedMatching = s.equalsIgnoreCase("true");
        if (!optimizedMatching) {
          getMessageHandler().handleMessage(MessageUtil.info("[optimizedMatching=false] optimized matching turned off"));
        }

        s = p.getProperty(xsetTIMERS_PER_JOINPOINT, "25000");
        try {
          timersPerJoinpoint = Integer.parseInt(s);
        } catch (Exception e) {
          getMessageHandler().handleMessage(MessageUtil.error("unable to process timersPerJoinpoint value of " + s));
          timersPerJoinpoint = 25000;
        }

        s = p.getProperty(xsetTIMERS_PER_FASTMATCH_CALL, "250");
        try {
          timersPerType = Integer.parseInt(s);
        } catch (Exception e) {
          getMessageHandler().handleMessage(MessageUtil.error("unable to process timersPerType value of " + s));
          timersPerType = 250;
        }

      }
      try {
        String value = System.getProperty("aspectj.overweaving", "false");
        if (value.equalsIgnoreCase("true")) {
          System.out.println("ASPECTJ: aspectj.overweaving=true: overweaving switched ON");
          overWeaving = true;
        }
        value = System.getProperty("aspectj.typeDemotion", "false");
        if (value.equalsIgnoreCase("true")) {
          System.out.println("ASPECTJ: aspectj.typeDemotion=true: type demotion switched ON");
          typeMap.demotionSystemActive = true;
        }
        value = System.getProperty("aspectj.minimalModel", "false");
        if (value.equalsIgnoreCase("true")) {
          System.out.println("ASPECTJ: aspectj.minimalModel=true: minimal model switched ON");
          minimalModel = true;
        }
      } catch (Throwable t) {
        System.err.println("ASPECTJ: Unable to read system properties");
        t.printStackTrace();
      }
      checkedAdvancedConfiguration = true;
    }
  }

  public boolean isRunMinimalMemory() {
    ensureAdvancedConfigurationProcessed();
    return runMinimalMemory;
  }

  public boolean isRunMinimalMemorySet() {
    ensureAdvancedConfigurationProcessed();
    return runMinimalMemorySet;
  }

  public boolean shouldFastPackMethods() {
    ensureAdvancedConfigurationProcessed();
    return fastMethodPacking;
  }

  public boolean shouldPipelineCompilation() {
    ensureAdvancedConfigurationProcessed();
    return shouldPipelineCompilation;
  }

  public boolean shouldGenerateStackMaps() {
    ensureAdvancedConfigurationProcessed();
    return shouldGenerateStackMaps;
  }

  public void setIncrementalCompileCouldFollow(boolean b) {
    incrementalCompileCouldFollow = b;
  }

  public boolean couldIncrementalCompileFollow() {
    return incrementalCompileCouldFollow;
  }

  public void setSynchronizationPointcutsInUse() {
    if (trace.isTraceEnabled()) {
      trace.enter("setSynchronizationPointcutsInUse", this);
    }
    synchronizationPointcutsInUse = true;
    if (trace.isTraceEnabled()) {
      trace.exit("setSynchronizationPointcutsInUse");
    }
  }

  public boolean areSynchronizationPointcutsInUse() {
    return synchronizationPointcutsInUse;
  }

  /**
   * Register a new pointcut designator handler with the world - this can be used by any pointcut parsers attached to the world.
   *
   * @param designatorHandler handler for the new pointcut
   */
  public void registerPointcutHandler(PointcutDesignatorHandler designatorHandler) {
    if (pointcutDesignators == null) {
      pointcutDesignators = new HashSet<PointcutDesignatorHandler>();
    }
    pointcutDesignators.add(designatorHandler);
  }

  public Set<PointcutDesignatorHandler> getRegisteredPointcutHandlers() {
    if (pointcutDesignators == null) {
      return Collections.emptySet();
    }
    return pointcutDesignators;
  }

  public void reportMatch(ShadowMunger munger, Shadow shadow) {

  }

  public boolean isOverWeaving() {
    return overWeaving;
  }

  public void reportCheckerMatch(Checker checker, Shadow shadow) {
  }

  /**
   * @return true if this world has the activation and scope of application of the aspects controlled via aop.xml files
   */
  public boolean isXmlConfigured() {
    return false;
  }

  public boolean isAspectIncluded(ResolvedType aspectType) {
    return true;
  }

  /**
   * Determine if the named aspect requires a particular type around in order to be useful. The type is named in the aop.xml file
   * against the aspect.
   *
   * @return true if there is a type missing that this aspect really needed around
   */
  public boolean hasUnsatisfiedDependency(ResolvedType aspectType) {
    return false;
  }

  public TypePattern getAspectScope(ResolvedType declaringType) {
    return null;
  }

  public Map<String, ResolvedType> getFixed() {
    return typeMap.tMap;
  }

  public Map<String, Reference<ResolvedType>> getExpendable() {
    return typeMap.expendableMap;
  }

  /**
   * Ask the type map to demote any types it can - we don't want them anchored forever.
   */
  public void demote() {
    typeMap.demote();
  }

  // protected boolean isExpendable(ResolvedType type) {
  // if (type.equals(UnresolvedType.OBJECT))
  // return false;
  // if (type == null)
  // return false;
  // boolean isExposed = type.isExposedToWeaver();
  // boolean nullDele = (type instanceof ReferenceType) ? ((ReferenceType) type).getDelegate() != null : true;
  // if (isExposed || !isExposed && nullDele)
  // return false;
  // return !type.isPrimitiveType();
  // }

  /**
   * Reference types we don't intend to weave may be ejected from the cache if we need the space.
   */
  protected boolean isExpendable(ResolvedType type) {
    return (!type.equals(UnresolvedType.OBJECT) && (!type.isExposedToWeaver()) && (!type.isPrimitiveType()));
  }

  // map from aspect > excluded types
  // memory issue here?
  private Map<ResolvedType, Set<ResolvedType>> exclusionMap = new HashMap<ResolvedType, Set<ResolvedType>>();

  public Map<ResolvedType, Set<ResolvedType>> getExclusionMap() {
    return exclusionMap;
  }

  private TimeCollector timeCollector = null;

  /**
   * Record the time spent matching a pointcut - this will accumulate over the lifetime of this world/weaver and be reported every
   * 25000 join points.
   */
  public void record(Pointcut pointcut, long timetaken) {
    if (timeCollector == null) {
      ensureAdvancedConfigurationProcessed();
      timeCollector = new TimeCollector(this);
    }
    timeCollector.record(pointcut, timetaken);
  }

  /**
   * Record the time spent fastmatching a pointcut - this will accumulate over the lifetime of this world/weaver and be reported
   * every 250 types.
   */
  public void recordFastMatch(Pointcut pointcut, long timetaken) {
    if (timeCollector == null) {
      ensureAdvancedConfigurationProcessed();
      timeCollector = new TimeCollector(this);
    }
    timeCollector.recordFastMatch(pointcut, timetaken);
  }

  public void reportTimers() {
    if (timeCollector != null && !timingPeriodically) {
      timeCollector.report();
      timeCollector = new TimeCollector(this);
    }
  }

  private static class TimeCollector {
    private World world;
    long joinpointCount;
    long typeCount;
    long perJoinpointCount;
    long perTypes;
    Map<String, Long> joinpointsPerPointcut = new HashMap<String, Long>();
    Map<String, Long> timePerPointcut = new HashMap<String, Long>();
    Map<String, Long> fastMatchTimesPerPointcut = new HashMap<String, Long>();
    Map<String, Long> fastMatchTypesPerPointcut = new HashMap<String, Long>();

    TimeCollector(World world) {
      this.perJoinpointCount = world.timersPerJoinpoint;
      this.perTypes = world.timersPerType;
      this.world = world;
      this.joinpointCount = 0;
      this.typeCount = 0;
      this.joinpointsPerPointcut = new HashMap<String, Long>();
      this.timePerPointcut = new HashMap<String, Long>();
    }

    public void report() {
      long totalTime = 0L;
      for (String p : joinpointsPerPointcut.keySet()) {
        totalTime += timePerPointcut.get(p);
      }
      world.getMessageHandler().handleMessage(
          MessageUtil.info("Pointcut matching cost (total=" + (totalTime / 1000000) + "ms for " + joinpointCount
              + " joinpoint match calls):"));
      for (String p : joinpointsPerPointcut.keySet()) {
        StringBuffer sb = new StringBuffer();
        sb.append("Time:" + (timePerPointcut.get(p) / 1000000) + "ms (jps:#" + joinpointsPerPointcut.get(p)
            + ") matching against " + p);
        world.getMessageHandler().handleMessage(MessageUtil.info(sb.toString()));
      }
      world.getMessageHandler().handleMessage(MessageUtil.info("---"));

      totalTime = 0L;
      for (String p : fastMatchTimesPerPointcut.keySet()) {
        totalTime += fastMatchTimesPerPointcut.get(p);
      }
      world.getMessageHandler().handleMessage(
          MessageUtil.info("Pointcut fast matching cost (total=" + (totalTime / 1000000) + "ms for " + typeCount
              + " fast match calls):"));
      for (String p : fastMatchTimesPerPointcut.keySet()) {
        StringBuffer sb = new StringBuffer();
        sb.append("Time:" + (fastMatchTimesPerPointcut.get(p) / 1000000) + "ms (types:#" + fastMatchTypesPerPointcut.get(p)
            + ") fast matching against " + p);
        world.getMessageHandler().handleMessage(MessageUtil.info(sb.toString()));
      }
      world.getMessageHandler().handleMessage(MessageUtil.info("---"));

    }

    void record(Pointcut pointcut, long timetakenInNs) {
      joinpointCount++;
      String pointcutText = pointcut.toString();
      Long jpcounter = joinpointsPerPointcut.get(pointcutText);
      if (jpcounter == null) {
        jpcounter = 1L;
      } else {
        jpcounter++;
      }
      joinpointsPerPointcut.put(pointcutText, jpcounter);

      Long time = timePerPointcut.get(pointcutText);
      if (time == null) {
        time = timetakenInNs;
      } else {
        time += timetakenInNs;
      }
      timePerPointcut.put(pointcutText, time);
      if (world.timingPeriodically) {
        if ((joinpointCount % perJoinpointCount) == 0) {
          long totalTime = 0L;
          for (String p : joinpointsPerPointcut.keySet()) {
            totalTime += timePerPointcut.get(p);
          }
          world.getMessageHandler().handleMessage(
              MessageUtil.info("Pointcut matching cost (total=" + (totalTime / 1000000) + "ms for " + joinpointCount
                  + " joinpoint match calls):"));
          for (String p : joinpointsPerPointcut.keySet()) {
            StringBuffer sb = new StringBuffer();
            sb.append("Time:" + (timePerPointcut.get(p) / 1000000) + "ms (jps:#" + joinpointsPerPointcut.get(p)
                + ") matching against " + p);
            world.getMessageHandler().handleMessage(MessageUtil.info(sb.toString()));
          }
          world.getMessageHandler().handleMessage(MessageUtil.info("---"));
        }
      }
    }

    void recordFastMatch(Pointcut pointcut, long timetakenInNs) {
      typeCount++;
      String pointcutText = pointcut.toString();
      Long typecounter = fastMatchTypesPerPointcut.get(pointcutText);
      if (typecounter == null) {
        typecounter = 1L;
      } else {
        typecounter++;
      }
      fastMatchTypesPerPointcut.put(pointcutText, typecounter);

      Long time = fastMatchTimesPerPointcut.get(pointcutText);
      if (time == null) {
        time = timetakenInNs;
      } else {
        time += timetakenInNs;
      }
      fastMatchTimesPerPointcut.put(pointcutText, time);
      if (world.timingPeriodically) {
        if ((typeCount % perTypes) == 0) {
          long totalTime = 0L;
          for (String p : fastMatchTimesPerPointcut.keySet()) {
            totalTime += fastMatchTimesPerPointcut.get(p);
          }
          world.getMessageHandler().handleMessage(
              MessageUtil.info("Pointcut fast matching cost (total=" + (totalTime / 1000000) + "ms for " + typeCount
                  + " fast match calls):"));
          for (String p : fastMatchTimesPerPointcut.keySet()) {
            StringBuffer sb = new StringBuffer();
            sb.append("Time:" + (fastMatchTimesPerPointcut.get(p) / 1000000) + "ms (types:#"
                + fastMatchTypesPerPointcut.get(p) + ") fast matching against " + p);
            world.getMessageHandler().handleMessage(MessageUtil.info(sb.toString()));
          }
          world.getMessageHandler().handleMessage(MessageUtil.info("---"));
        }
      }
    }
  }

  public TypeMap getTypeMap() {
    return typeMap;
  }

  public static void reset() {
    ResolvedType.resetPrimitives();
  }

  /**
   * Returns the version of ITD that this world wants to create. The default is the new style (2) but in some cases where there
   * might be a clash, the old style can be used. It is set through the option -Xset:itdVersion=1
   *
   * @return the ITD version this world wants to create - 1=oldstyle 2=new, transparent style
   */
  public int getItdVersion() {
    return itdVersion;
  }

  // if not loadtime weaving then we are compile time weaving or post-compile time weaving
  public abstract boolean isLoadtimeWeaving();

  public void classWriteEvent(char[][] compoundName) {
    // override if interested in write events
  }

}
TOP

Related Classes of org.aspectj.weaver.World$TimeCollector

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.