/* *******************************************************************
 * 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.ResolvedType.Primitive;
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.
/**
 * 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. /** handler for any messages produced during resolution etc. */
	private IMessageHandler messageHandler = IMessageHandler.SYSTEM_ERR;

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

	
Currently 'active' scope in which to lookup (resolve) typevariable references /** 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 /** The heart of the world, a map from type signatures to resolved types */
	protected TypeMap typeMap = new TypeMap(this);

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

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

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

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

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

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

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

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

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

	
Xpinpoint controls whether we put out developer info showing the source of messages /** 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 /** When behaving in a Java 5 way autoboxing is considered */
	private boolean behaveInJava5Way = false;

	
Should timing information be reported (as info messages)? /** 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 /** 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 /** The level of the aspectjrt.jar the code we generate needs to run on */
	public static final RuntimeVersion RUNTIME_LEVEL_DEFAULT = RuntimeVersion.V1_5;
	private RuntimeVersion targetAspectjRuntimeLevel = RUNTIME_LEVEL_DEFAULT;

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

	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 transientTjpFields = 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 = true;
	private boolean useFinal = true;
	private boolean targettingRuntime1_6_10 = false;

	private boolean completeBinaryTypes = false;
	private boolean overWeaving = false;
	private static boolean systemPropertyOverWeaving = false;
	public boolean forDEBUG_structuralChangesCode = false;
	public boolean forDEBUG_bridgingCode = false;
	public boolean optimizedMatching = true;
	public boolean generateNewLvts = 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 boolean errorThreshold;
	private boolean warningThreshold;

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

	static {
		try {
			String value = System.getProperty("aspectj.overweaving", "false");
			if (value.equalsIgnoreCase("true")) {
				System.out.println("ASPECTJ: aspectj.overweaving=true: overweaving switched ON");
				systemPropertyOverWeaving = true;
			}
		} catch (Throwable t) {
			System.err.println("ASPECTJ: Unable to read system properties");
			t.printStackTrace();
		}
	}

	public final Primitive BYTE = new Primitive("B", 1, 0);
	public final Primitive CHAR = new Primitive("C", 1, 1);
	public final Primitive DOUBLE = new Primitive("D", 2, 2);
	public final Primitive FLOAT = new Primitive("F", 1, 3);
	public final Primitive INT = new Primitive("I", 1, 4);
	public final Primitive LONG = new Primitive("J", 2, 5);
	public final Primitive SHORT = new Primitive("S", 1, 6);
	public final Primitive BOOLEAN = new Primitive("Z", 1, 7);
	public final Primitive VOID = new Primitive("V", 0, 8);

	
Insert the primitives
/**
	 * Insert the primitives
	 */
	protected World() {
		super();
		// Dump.registerNode(this.getClass(), this);
		typeMap.put("B", BYTE);
		typeMap.put("S", SHORT);
		typeMap.put("I", INT);
		typeMap.put("J", LONG);
		typeMap.put("F", FLOAT);
		typeMap.put("D", DOUBLE);
		typeMap.put("C", CHAR);
		typeMap.put("Z", BOOLEAN);
		typeMap.put("V", VOID);
		precedenceCalculator = new AspectPrecedenceCalculator(this);
	}

	
Dump processing when a fatal error occurs
/**
	 * Dump processing when a fatal error occurs
	 */
	@Override
	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
/**
	 * 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.
/**
	 * 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.
/**
	 * 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.
/**
	 * 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
/**
	 * 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.
/**
	 * 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...
/**
	 * 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.
/**
	 * 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.
Params:
type – a possibly generic type for which the raw needs creating as it is not currently in the world
Returns:
a type suitable for putting into the world/**
	 * 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.
/**
	 * 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.
/**
	 * 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);
			if (rt.isMissing()) {
				return rt;
			}
			ReferenceType genericType = (ReferenceType) rt;
			if (rt.isMissing()) {
				return 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);

			if (delegate == null) {
				return new MissingResolvedTypeWithKnownSignature(ty.getSignature(), erasedSignature, this);
			}

			if (delegate.isGeneric() && behaveInJava5Way) {
				// ======== raw type ===========
				simpleOrRawType.typeKind = TypeKind.RAW;
				if (simpleOrRawType.hasNewInterfaces()) { // debug 375777
					throw new IllegalStateException(
							"Simple type promoted forced to raw, but it had new interfaces/superclass.  Type is "
									+ simpleOrRawType.getName());
				}
				ReferenceType genericType = makeGenericTypeFrom(delegate, simpleOrRawType);
				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.
/**
	 * 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).
/**
	 * 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()) {
			ResolvedType resolvedUpperBound = resolve(aType.getUpperBound());
			if (resolvedUpperBound.isMissing()) {
				return getWildcard();
			}
			ret = new BoundedReferenceType((ReferenceType)resolvedUpperBound, true, this);
		} else if (aType.isSuper()) {
			ResolvedType resolvedLowerBound = resolve(aType.getLowerBound());
			if (resolvedLowerBound.isMissing()) {
				return getWildcard();
			}
			ret = new BoundedReferenceType((ReferenceType)resolvedLowerBound, 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.
/**
	 * 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.
/**
	 * 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.
/**
	 * 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.
/**
	 * 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.
/**
	 * 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
/**
	 * 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
/**
	 * 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
/**
	 * 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.
/**
	 * 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.
/**
	 * 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.
/**
	 * 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 useFinal() {
		return useFinal;
	}

	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.
/**
	 * 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)
Params:
errorThreshold – 
warningThreshold – /**
	 * Set the error and warning threashold which can be taken from CompilerOptions (see bug 129282)
	 *
	 * @param errorThreshold
	 * @param warningThreshold
	 */
	public void setErrorAndWarningThreshold(boolean errorThreshold, boolean warningThreshold) {
		this.errorThreshold = errorThreshold;
		this.warningThreshold = warningThreshold;
	}

	
Returns:
true if ignoring the UnusedDeclaredThrownException and false if this compiler option is set to error or warning/**
	 * @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
		return errorThreshold||warningThreshold;
//		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
/**
	 * may return null
	 */
	public Properties getExtraConfiguration() {
		return extraConfiguration;
	}

	public final static String xsetAVOID_FINAL = "avoidFinal"; // default true

	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 xsetTRANSIENT_TJP_FIELDS = "makeTjpFieldsTransient"; // 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";

	// This option allows you to prevent AspectJ adding local variable tables - some tools (e.g. dex) may
	// not like what gets created because even though it is valid, the bytecode they are processing has
	// unexpected quirks that mean the table entries are violated in the code. See issue:
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=470658
	public final static String xsetGENERATE_NEW_LVTS="generateNewLocalVariableTables";

	public boolean isInJava5Mode() {
		return behaveInJava5Way;
	}

	public boolean isTimingEnabled() {
		return timing;
	}

	public void setTargetAspectjRuntimeLevel(String s) {
		targetAspectjRuntimeLevel = RuntimeVersion.getVersionFor(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 RuntimeVersion 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() == RuntimeVersion.V1_2);
		}
		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).
	 * Generic types have their raw form added to the map, which has a pointer to the underlying generic.
	 */
	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>();

		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.
Returns:
number of types demoted/**
		 * 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.
/**
		 * 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;
			}
			Reference<? extends ResolvedType> r = null;
			while ((r=rq.poll()) != null) {
				collectedTypes++;
			}
		}

		
Lookup a type by its signature, always look in the real map before the expendable map
/**
		 * 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();
//						if (ret==null) {
//							expendableMap.remove(key);
//						}
					}
				} else if (policy == USE_SOFT_REFS) {
					SoftReference<ResolvedType> ref = (SoftReference<ResolvedType>) expendableMap.get(key);
					if (ref != null) {
						ret = ref.get();
//						if (ret==null) {
//							expendableMap.remove(key);
//						}
					}
					// } else {
					// return (ResolvedType) expendableMap.get(key);
				}
			}
			return ret;
		}

		
Remove a type from the map /** 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 void demote(ResolvedType type) {
			String key = type.getSignature();
			if (debugDemotion) {
				addedSinceLastDemote.remove(key);
			}
			tMap.remove(key);
			insertInExpendableMap(key, type);
		}

		// 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.
/**
	 * 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.
/**
		 * 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 true;
	}

	// --- 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 /** 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(xsetAVOID_FINAL, "false");
				if (s.equalsIgnoreCase("true")) {
					useFinal = false; // if avoidFinal=true, then set useFinal to false
				}

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

				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
				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(xsetTRANSIENT_TJP_FIELDS,"false");
				transientTjpFields = s.equalsIgnoreCase("true");

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

				s = p.getProperty(xsetGENERATE_NEW_LVTS,"true");
				generateNewLvts = s.equalsIgnoreCase("true");
				if (!generateNewLvts) {
					getMessageHandler().handleMessage(MessageUtil.info("[generateNewLvts=false] for methods without an incoming local variable table, do not generate one"));
				}

				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 {
				if (systemPropertyOverWeaving) {
					overWeaving = true;
				}
				String value = null;
				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 isTransientTjpFields() {
		ensureAdvancedConfigurationProcessed();
		return transientTjpFields;
	}

	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.
Params:
designatorHandler – handler for the new pointcut/**
	 * 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) {
	}

	
Returns:
true if this world has the activation and scope of application of the aspects controlled via aop.xml files/**
	 * @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.
Returns:
true if there is a type missing that this aspect really needed around/**
	 * 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.
/**
	 * 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.
/**
	 * 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()
				&& !type.isPrimitiveArray();
	}

	// 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.
/**
	 * 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.
/**
	 * 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
Returns:
the ITD version this world wants to create - 1=oldstyle 2=new, transparent style/**
	 * 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
	}

}