issue_id
int64 2.04k
425k
| title
stringlengths 9
251
| body
stringlengths 4
32.8k
⌀ | status
stringclasses 6
values | after_fix_sha
stringlengths 7
7
| project_name
stringclasses 6
values | repo_url
stringclasses 6
values | repo_name
stringclasses 6
values | language
stringclasses 1
value | issue_url
null | before_fix_sha
null | pull_url
null | commit_datetime
timestamp[us, tz=UTC] | report_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 23
187
| chunk_content
stringlengths 1
22k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
349,636 |
Bug 349636 AspectJ reports "abort trouble" while instrumenting a class on startup
|
Build Identifier: 20110218-0911 java.lang.NullPointerException at org.aspectj.weaver.bcel.Utility.appendConversion(Utility.java:272) at org.aspectj.weaver.bcel.BcelVar.appendConvertableArrayLoad(BcelVar.java:81) at org.aspectj.weaver.bcel.BcelVar.createConvertableArrayLoad(BcelVar.java:101) at org.aspectj.weaver.bcel.BcelShadow.makeClosureClassAndReturnConstructor(BcelShadow.java:3066) at org.aspectj.weaver.bcel.BcelShadow.weaveAroundClosure(BcelShadow.java:2830) at org.aspectj.weaver.bcel.BcelAdvice.implementOn(BcelAdvice.java:342) at org.aspectj.weaver.Shadow.implementMungers(Shadow.java:630) at org.aspectj.weaver.Shadow.implement(Shadow.java:544) at org.aspectj.weaver.bcel.BcelClassWeaver.implement(BcelClassWeaver.java:3147) at org.aspectj.weaver.bcel.BcelClassWeaver.weave(BcelClassWeaver.java:490) at org.aspectj.weaver.bcel.BcelClassWeaver.weave(BcelClassWeaver.java:100) at org.aspectj.weaver.bcel.BcelWeaver.weave(BcelWeaver.java:1687) at org.aspectj.weaver.bcel.BcelWeaver.weaveWithoutDump(BcelWeaver.java:1631) at org.aspectj.weaver.bcel.BcelWeaver.weaveAndNotify(BcelWeaver.java:1394) at org.aspectj.weaver.bcel.BcelWeaver.weave(BcelWeaver.java:1180) at org.aspectj.weaver.tools.WeavingAdaptor.getWovenBytes(WeavingAdaptor.java:467) at org.aspectj.weaver.tools.WeavingAdaptor.weaveClass(WeavingAdaptor.java:318) at org.eclipse.equinox.weaving.aspectj.loadtime.OSGiWeavingAdaptor.weaveClass(Unknown Source) at org.eclipse.equinox.weaving.aspectj.AspectJWeavingService.preProcess(Unknown Source) at org.eclipse.equinox.weaving.adaptors.WeavingAdaptor.weaveClass(Unknown Source) at org.eclipse.equinox.weaving.hooks.WeavingHook.processClass(Unknown Source) at org.eclipse.osgi.baseadaptor.loader.ClasspathManager.defineClass(ClasspathManager.java:575) at org.eclipse.osgi.baseadaptor.loader.ClasspathManager.findClassImpl(ClasspathManager.java:550) at org.eclipse.osgi.baseadaptor.loader.ClasspathManager.findLocalClassImpl(ClasspathManager.java:481) at org.eclipse.osgi.baseadaptor.loader.ClasspathManager.findLocalClass_LockClassLoader(ClasspathManager.java:469) at org.eclipse.osgi.baseadaptor.loader.ClasspathManager.findLocalClass(ClasspathManager.java:449) at org.eclipse.osgi.internal.baseadaptor.DefaultClassLoader.findLocalClass(DefaultClassLoader.java:216) at org.eclipse.osgi.internal.loader.BundleLoader.findLocalClass(BundleLoader.java:393) at org.eclipse.osgi.internal.loader.BundleLoader.findClassInternal(BundleLoader.java:469) at org.eclipse.osgi.internal.loader.BundleLoader.findClass(BundleLoader.java:422) at org.eclipse.osgi.internal.loader.BundleLoader.findClass(BundleLoader.java:410) at org.eclipse.osgi.internal.baseadaptor.DefaultClassLoader.loadClass(DefaultClassLoader.java:107) at java.lang.ClassLoader.loadClass(ClassLoader.java:247) at org.eclipse.osgi.internal.loader.BundleLoader.loadClass(BundleLoader.java:338) at org.eclipse.osgi.framework.internal.core.BundleHost.loadClass(BundleHost.java:232) at org.eclipse.osgi.framework.internal.core.AbstractBundle.loadClass(AbstractBundle.java:1197) at org.springframework.osgi.util.BundleDelegatingClassLoader.findClass(BundleDelegatingClassLoader.java:99) at org.springframework.osgi.util.BundleDelegatingClassLoader.loadClass(BundleDelegatingClassLoader.java:157) at java.lang.ClassLoader.loadClass(ClassLoader.java:247) at org.springframework.util.ClassUtils.forName(ClassUtils.java:257) at org.springframework.beans.factory.support.AbstractBeanDefinition.resolveBeanClass(AbstractBeanDefinition.java:408) at org.springframework.beans.factory.support.AbstractBeanFactory.doResolveBeanClass(AbstractBeanFactory.java:1271) at org.springframework.beans.factory.support.AbstractBeanFactory.resolveBeanClass(AbstractBeanFactory.java:1242) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.predictBeanType(AbstractAutowireCapableBeanFactory.java:576) at org.springframework.beans.factory.support.AbstractBeanFactory.isFactoryBean(AbstractBeanFactory.java:1319) at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBeanNamesForType(DefaultListableBeanFactory.java:315) at org.springframework.osgi.context.support.AbstractDelegatedExecutionApplicationContext.invokeBeanFactoryPostProcessors(AbstractDelegatedExecutionApplicationContext.java:391) at org.springframework.osgi.context.support.AbstractDelegatedExecutionApplicationContext.invokeBeanFactoryPostProcessors(AbstractDelegatedExecutionApplicationContext.java:364) at org.springframework.osgi.context.support.AbstractDelegatedExecutionApplicationContext$3.run(AbstractDelegatedExecutionApplicationContext.java:256) at org.springframework.osgi.util.internal.PrivilegedUtils.executeWithCustomTCCL(PrivilegedUtils.java:87) at org.springframework.osgi.context.support.AbstractDelegatedExecutionApplicationContext.startRefresh(AbstractDelegatedExecutionApplicationContext.java:222) at org.springframework.osgi.extender.internal.dependencies.startup.DependencyWaiterApplicationContextExecutor.stageOne(DependencyWaiterApplicationContextExecutor.java:225) at org.springframework.osgi.extender.internal.dependencies.startup.DependencyWaiterApplicationContextExecutor.refresh(DependencyWaiterApplicationContextExecutor.java:178) at org.springframework.osgi.context.support.AbstractDelegatedExecutionApplicationContext.refresh(AbstractDelegatedExecutionApplicationContext.java:159) at org.springframework.osgi.extender.internal.activator.LifecycleManager$1.run(LifecycleManager.java:223) at java.lang.Thread.run(Thread.java:662) Reproducible: Sometimes
|
resolved fixed
|
f7b1193
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-17T22:39:42Z | 2011-06-17T00:20:00Z |
weaver/src/org/aspectj/weaver/bcel/Utility.java
|
public static Attribute bcelAttribute(AjAttribute a, ConstantPool pool) {
int nameIndex = pool.addUtf8(a.getNameString());
byte[] bytes = a.getBytes(new BcelConstantPoolWriter(pool));
int length = bytes.length;
return new Unknown(nameIndex, length, bytes, pool);
}
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
/* *******************************************************************
* 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;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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 {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
protected TypeMap typeMap = new TypeMap(this);
private Set<PointcutDesignatorHandler> pointcutDesignators;
public static boolean createInjarHierarchy = true;
private final AspectPrecedenceCalculator precedenceCalculator;
private final CrosscuttingMembersSet crosscuttingMembersSet = new CrosscuttingMembersSet(this);
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
private IStructureModel model = null;
private Lint lint = new Lint(this);
private boolean XnoInline;
private boolean XlazyTjp;
private boolean XhasMember = false;
/**
* Xpinpoint controls whether we put out developer info showing the source of messages
*/
private boolean Xpinpoint = false;
private boolean behaveInJava5Way = false;
private boolean timing = false;
private boolean timingPeriodically = true;
private boolean incrementalCompileCouldFollow = false;
private String targetAspectjRuntimeLevel = Constants.RUNTIME_LEVEL_DEFAULT;
private boolean optionalJoinpoint_ArrayConstruction = false;
private boolean optionalJoinpoint_Synchronization = false;
private boolean addSerialVerUID = false;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
private Properties extraConfiguration = null;
private boolean checkedAdvancedConfiguration = false;
private boolean synchronizationPointcutsInUse = false;
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;
private boolean minimalModel = false;
private boolean useFinal = true;
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;
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;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
/**
* 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);
}
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("Shadow mungers:");
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
}
}
/**
* 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)) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
getLint().cantFindType.signal(WeaverMessages.format(WeaverMessages.CANT_FIND_TYPE, ty.getName()), isl);
}
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) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
if (ty instanceof ResolvedType) {
ResolvedType rty = (ResolvedType) ty;
rty = resolve(rty);
if (!rty.isTypeVariableReference() || ((TypeVariableReferenceType) rty).isTypeVariableResolved()) {
return rty;
}
}
if (ty.isTypeVariableReference()) {
return ty.resolve(this);
}
String signature = ty.getSignature();
ResolvedType ret = typeMap.get(signature);
if (ret != null) {
ret.world = this;
return ret;
} else if (signature.equals("?") || signature.equals("*")) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
ResolvedType something = getWildcard();
typeMap.put("?", something);
return something;
}
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);
}
}
}
ResolvedType result = typeMap.get(signature);
if (result == null && !ret.isMissing()) {
ret = ensureRawTypeIfNecessary(ret);
typeMap.put(signature, ret);
return ret;
}
if (result == null) {
return ret;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
} else {
return result;
}
}
private Object buildingTypeLock = new Object();
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) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
if (dumpState_cantFindTypeExceptions == null) {
dumpState_cantFindTypeExceptions = new ArrayList<RuntimeException>();
}
if (dumpState_cantFindTypeExceptions.size() < 100) {
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;
}
ResolvedType resolved = typeMap.get(ty.getSignature());
if (resolved == null) {
resolved = ensureRawTypeIfNecessary(ty);
typeMap.put(ty.getSignature(), resolved);
resolved = ty;
}
resolved.world = this;
return resolved;
}
/**
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
* 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;
}
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;
}
return type;
}
/**
* Convenience method for finding a type by name and resolving it in one step.
*/
public ResolvedType resolve(String name) {
ResolvedType ret = resolve(UnresolvedType.forName(name));
return ret;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
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()) {
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()) {
ResolvedType rt = resolveGenericTypeFor(ty, false);
ReferenceType genericType = (ReferenceType) rt;
return genericType;
} else if (ty.isGenericWildcard()) {
return resolveGenericWildcardFor((WildcardedUnresolvedType) ty);
} else {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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) {
simpleOrRawType.typeKind = TypeKind.RAW;
ReferenceType genericType = makeGenericTypeFrom(delegate, simpleOrRawType);
simpleOrRawType.setDelegate(delegate);
genericType.setDelegate(delegate);
simpleOrRawType.setGenericType(genericType);
return simpleOrRawType;
} else {
simpleOrRawType.setDelegate(delegate);
return simpleOrRawType;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
}
}
/**
* Attempt to resolve a type that should be a generic type.
*/
public ResolvedType resolveGenericTypeFor(UnresolvedType anUnresolvedType, boolean allowMissing) {
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;
}
ResolvedType genericType = rawType.getGenericType();
if (rawType.isSimpleType() && (anUnresolvedType.typeParameters == null || anUnresolvedType.typeParameters.length == 0)) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
rawType.world = this;
return rawType;
}
if (genericType != null) {
genericType.world = this;
((ReferenceType) genericType).addDependentType((ReferenceType) rawType);
return genericType;
} else {
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).
*/
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
private ReferenceType resolveGenericWildcardFor(WildcardedUnresolvedType aType) {
BoundedReferenceType ret = null;
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 {
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.
*/
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()));
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
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);
}
/**
* 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) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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
*/
/**
* Create an advice shadow munger for the given advice kind
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
*/
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);
}
/**
* Nobody should hold onto a copy of this message handler, or setMessageHandler won't work right.
*/
public IMessageHandler getMessageHandler() {
return messageHandler;
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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.
*/
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
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
*/
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() {
if ((errorThreshold & 0x800000) != 0 || (warningThreshold & 0x800000) != 0) {
return false;
}
return true;
}
public void performExtraConfiguration(String config) {
if (config == null) {
return;
}
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);
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
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 xsetAVOID_FINAL = "avoidFinal";
public final static String xsetWEAVE_JAVA_PACKAGES = "weaveJavaPackages";
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
public final static String xsetWEAVE_JAVAX_PACKAGES = "weaveJavaxPackages";
public final static String xsetCAPTURE_ALL_CONTEXT = "captureAllContext";
public final static String xsetRUN_MINIMAL_MEMORY = "runMinimalMemory";
public final static String xsetDEBUG_STRUCTURAL_CHANGES_CODE = "debugStructuralChangesCode";
public final static String xsetDEBUG_BRIDGING = "debugBridging";
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";
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";
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
public String getTargetAspectjRuntimeLevel() {
return targetAspectjRuntimeLevel;
}
public boolean isTargettingAspectJRuntime12() {
boolean b = false;
if (!isInJava5Mode()) {
b = true;
} else {
b = getTargetAspectjRuntimeLevel().equals(org.aspectj.weaver.Constants.RUNTIME_LEVEL_12);
}
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 {
public final static int DONT_USE_REFS = 0;
public final static int USE_WEAK_REFS = 1;
public final static int USE_SOFT_REFS = 2;
public List<String> addedSinceLastDemote;
public List<String> writtenClasses;
private static boolean debug = false;
public static boolean useExpendableMap = true;
private boolean demotionSystemActive;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
private boolean debugDemotion = false;
public int policy = USE_WEAK_REFS;
final Map<String, ResolvedType> tMap = new HashMap<String, ResolvedType>();
final Map<String, Reference<ResolvedType>> expendableMap = Collections
.synchronizedMap(new WeakHashMap<String, Reference<ResolvedType>>());
private final World w;
private boolean memoryProfiling = false;
private int maxExpendableMapSize = -1;
private int collectedTypes = 0;
private final ReferenceQueue<ResolvedType> rq = new ReferenceQueue<ResolvedType>();
TypeMap(World w) {
demotionSystemActive = w.isDemotionActive() && (w.isLoadtimeWeaving() || w.couldIncrementalCompileFollow());
addedSinceLastDemote = new ArrayList<String>();
writtenClasses = new ArrayList<String>();
this.w = w;
memoryProfiling = false;
}
public Map<String, Reference<ResolvedType>> getExpendableMap() {
return expendableMap;
}
public Map<String, ResolvedType> getMainMap() {
return tMap;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
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) {
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);
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
demotionCounter++;
}
}
}
addedSinceLastDemote.clear();
} else {
List<String> forRemoval = new ArrayList<String>();
for (String key : addedSinceLastDemote) {
ResolvedType type = tMap.get(key);
if (type == null) {
forRemoval.add(key);
continue;
}
if (!writtenClasses.contains(type.getName())) {
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); } }
*/
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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 {
writtenClasses.remove(type.getName());
forRemoval.add(key);
}
} else {
writtenClasses.remove(type.getName());
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);
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
}
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);
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
}
/*
* 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) {
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));
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
}
if (memoryProfiling && expendableMap.size() > maxExpendableMapSize) {
maxExpendableMapSize = expendableMap.size();
}
return type;
} else {
if (demotionSystemActive) {
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;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
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();
}
}
}
return ret;
}
public ResolvedType remove(String key) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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();
}
}
}
return ret;
}
public void classWriteEvent(String classname) {
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) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
addedSinceLastDemote.remove(key);
}
tMap.remove(key);
insertInExpendableMap(key, type);
}
}
/**
* This class is used to compute and store precedence relationships between aspects.
*/
private static class AspectPrecedenceCalculator {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
for (Iterator<Declare> i = world.getCrosscuttingMembersSet().getDeclareDominates().iterator(); i.hasNext();) {
DeclarePrecedence d = (DeclarePrecedence) i.next();
int thisOrder = d.compare(firstAspect, secondAspect);
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
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) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
public boolean isDemotionActive() {
return false;
}
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;
}
public void flush() {
typeMap.expendableMap.clear();
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
public void ensureAdvancedConfigurationProcessed() {
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"));
}
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;
}
s = p.getProperty(xsetMINIMAL_MODEL, "false");
if (s.equalsIgnoreCase("true")) {
minimalModel = true;
}
s = p.getProperty(xsetTARGETING_RUNTIME_1610, "false");
if (s.equalsIgnoreCase("true")) {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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);
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");
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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");
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;
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
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);
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
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;
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
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;
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
/**
* Ask the type map to demote any types it can - we don't want them anchored forever.
*/
public void demote() {
typeMap.demote();
}
/**
* 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();
}
private Map<ResolvedType, Set<ResolvedType>> exclusionMap = new HashMap<ResolvedType, Set<ResolvedType>>();
public Map<ResolvedType, Set<ResolvedType>> getExclusionMap() {
return exclusionMap;
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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 {
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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);
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
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);
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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("---"));
}
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
}
}
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();
|
349,764 |
Bug 349764 Repeated output of ASPECTJ: aspectj.overweaving=true: overweaving switched ON
|
Build Identifier: 1.6.11 The message is repeated every time a new class loader is being use to load weaving configuration (using -Dorg.aspectj.tracing.factory=default). Since this value is a system (!) property there is no need to display its value more than once (or even check it more than once - it could be lazily initialized and cached...) Reproducible: Always Steps to Reproduce: 1. use -Dorg.aspectj.tracing.factory=default -Daspectj.overweaving=true properties 2. place some JAR that contains aop.xml with some aspects and weaving options where it can be loaded/visible from several class loaders 3. runt the application and check the STDOUT output
|
resolved fixed
|
bb2aea4
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-20T17:10:01Z | 2011-06-19T10:40:00Z |
org.aspectj.matcher/src/org/aspectj/weaver/World.java
|
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;
}
public abstract boolean isLoadtimeWeaving();
public void classWriteEvent(char[][] compoundName) {
}
}
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
/* *******************************************************************
* Copyright (c) 2002-2010 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
* ******************************************************************/
package org.aspectj.weaver.bcel;
import java.io.ByteArrayInputStream;
import java.io.File;
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.Attributes;
import java.util.jar.Attributes.Name;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import org.aspectj.apache.bcel.classfile.ClassParser;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.asm.AsmManager;
import org.aspectj.asm.IProgramElement;
import org.aspectj.asm.internal.AspectJElementHierarchy;
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
import org.aspectj.bridge.IMessage;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.bridge.Message;
import org.aspectj.bridge.MessageUtil;
import org.aspectj.bridge.SourceLocation;
import org.aspectj.bridge.WeaveMessage;
import org.aspectj.bridge.context.CompilationAndWeavingContext;
import org.aspectj.bridge.context.ContextToken;
import org.aspectj.util.FileUtil;
import org.aspectj.util.FuzzyBoolean;
import org.aspectj.weaver.Advice;
import org.aspectj.weaver.AdviceKind;
import org.aspectj.weaver.AjAttribute.WeaverVersionInfo;
import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.AnnotationOnTypeMunger;
import org.aspectj.weaver.BCException;
import org.aspectj.weaver.CompressingDataOutputStream;
import org.aspectj.weaver.ConcreteTypeMunger;
import org.aspectj.weaver.CrosscuttingMembersSet;
import org.aspectj.weaver.CustomMungerFactory;
import org.aspectj.weaver.IClassFileProvider;
import org.aspectj.weaver.IUnwovenClassFile;
import org.aspectj.weaver.IWeaveRequestor;
import org.aspectj.weaver.NewParentTypeMunger;
import org.aspectj.weaver.ReferenceType;
import org.aspectj.weaver.ReferenceTypeDelegate;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.ResolvedTypeMunger;
import org.aspectj.weaver.Shadow;
import org.aspectj.weaver.ShadowMunger;
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.WeaverMessages;
import org.aspectj.weaver.WeaverStateInfo;
import org.aspectj.weaver.World;
import org.aspectj.weaver.model.AsmRelationshipProvider;
import org.aspectj.weaver.patterns.AndPointcut;
import org.aspectj.weaver.patterns.BindingPattern;
import org.aspectj.weaver.patterns.BindingTypePattern;
import org.aspectj.weaver.patterns.ConcreteCflowPointcut;
import org.aspectj.weaver.patterns.DeclareAnnotation;
import org.aspectj.weaver.patterns.DeclareParents;
import org.aspectj.weaver.patterns.DeclareTypeErrorOrWarning;
import org.aspectj.weaver.patterns.FastMatchInfo;
import org.aspectj.weaver.patterns.IfPointcut;
import org.aspectj.weaver.patterns.KindedPointcut;
import org.aspectj.weaver.patterns.NameBindingPointcut;
import org.aspectj.weaver.patterns.NotPointcut;
import org.aspectj.weaver.patterns.OrPointcut;
import org.aspectj.weaver.patterns.Pointcut;
import org.aspectj.weaver.patterns.PointcutRewriter;
import org.aspectj.weaver.patterns.WithinPointcut;
import org.aspectj.weaver.tools.Trace;
import org.aspectj.weaver.tools.TraceFactory;
/**
*
* @author PARC
* @author Andy Clement
* @author Alexandre Vasseur
*/
public class BcelWeaver {
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
public static final String CLOSURE_CLASS_PREFIX = "$Ajc";
public static final String SYNTHETIC_CLASS_POSTFIX = "$ajc";
private static Trace trace = TraceFactory.getTraceFactory().getTrace(BcelWeaver.class);
private transient final BcelWorld world;
private final CrosscuttingMembersSet xcutSet;
private boolean inReweavableMode = false;
private transient List<UnwovenClassFile> addedClasses = new ArrayList<UnwovenClassFile>();
private transient List<String> deletedTypenames = new ArrayList<String>();
private transient List<ShadowMunger> shadowMungerList = null;
private transient List<ConcreteTypeMunger> typeMungerList = null;
private transient List<ConcreteTypeMunger> lateTypeMungerList = null;
private transient List<DeclareParents> declareParentsList = null;
private Manifest manifest = null;
private boolean needToReweaveWorld = false;
private boolean isBatchWeave = true;
private ZipOutputStream zipOutputStream;
private CustomMungerFactory customMungerFactory;
public BcelWeaver(BcelWorld world) {
super();
if (trace.isTraceEnabled()) {
trace.enter("<init>", this, world);
}
this.world = world;
this.xcutSet = world.getCrosscuttingMembersSet();
if (trace.isTraceEnabled()) {
trace.exit("<init>");
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
}
}
/**
* Add the given aspect to the weaver. The type is resolved to support DOT for static inner classes as well as DOLLAR
*
* @param aspectName
* @return aspect
*/
public ResolvedType addLibraryAspect(String aspectName) {
if (trace.isTraceEnabled()) {
trace.enter("addLibraryAspect", this, aspectName);
}
UnresolvedType unresolvedT = UnresolvedType.forName(aspectName);
unresolvedT.setNeedsModifiableDelegate(true);
ResolvedType type = world.resolve(unresolvedT, true);
if (type.isMissing()) {
String fixedName = aspectName;
int hasDot = fixedName.lastIndexOf('.');
while (hasDot > 0) {
char[] fixedNameChars = fixedName.toCharArray();
fixedNameChars[hasDot] = '$';
fixedName = new String(fixedNameChars);
hasDot = fixedName.lastIndexOf('.');
UnresolvedType ut = UnresolvedType.forName(fixedName);
ut.setNeedsModifiableDelegate(true);
type = world.resolve(ut, true);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
if (!type.isMissing()) {
break;
}
}
}
if (type.isAspect()) {
WeaverStateInfo wsi = type.getWeaverState();
if (wsi != null && wsi.isReweavable()) {
BcelObjectType classType = getClassType(type.getName());
JavaClass wovenJavaClass = classType.getJavaClass();
byte[] bytes = wsi.getUnwovenClassFileData(wovenJavaClass.getBytes());
JavaClass unwovenJavaClass = Utility.makeJavaClass(wovenJavaClass.getFileName(), bytes);
world.storeClass(unwovenJavaClass);
classType.setJavaClass(unwovenJavaClass, true);
}
xcutSet.addOrReplaceAspect(type);
if (trace.isTraceEnabled()) {
trace.exit("addLibraryAspect", type);
}
if (type.getSuperclass().isAspect()) {
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
addLibraryAspect(type.getSuperclass().getName());
}
return type;
} else {
RuntimeException ex = new RuntimeException("Cannot register non aspect: " + type.getName() + " , " + aspectName);
if (trace.isTraceEnabled()) {
trace.exit("addLibraryAspect", ex);
}
throw ex;
}
}
/**
*
* @param inFile directory containing classes or zip/jar class archive
*/
public void addLibraryJarFile(File inFile) throws IOException {
List<ResolvedType> addedAspects = null;
if (inFile.isDirectory()) {
addedAspects = addAspectsFromDirectory(inFile);
} else {
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
addedAspects = addAspectsFromJarFile(inFile);
}
if (world.isOverWeaving()) {
return;
}
for (ResolvedType addedAspect : addedAspects) {
xcutSet.addOrReplaceAspect(addedAspect);
}
}
private List<ResolvedType> addAspectsFromJarFile(File inFile) throws FileNotFoundException, IOException {
ZipInputStream inStream = new ZipInputStream(new FileInputStream(inFile));
List<ResolvedType> addedAspects = new ArrayList<ResolvedType>();
try {
while (true) {
ZipEntry entry = inStream.getNextEntry();
if (entry == null) {
break;
}
if (entry.isDirectory() || !entry.getName().endsWith(".class")) {
continue;
}
int size = (int) entry.getSize();
ClassParser parser = new ClassParser(new ByteArrayInputStream(FileUtil.readAsByteArray(inStream)), entry.getName());
JavaClass jc = parser.parse();
inStream.closeEntry();
ResolvedType type = world.addSourceObjectType(jc, false).getResolvedTypeX();
type.setBinaryPath(inFile.getAbsolutePath());
if (type.isAspect()) {
addedAspects.add(type);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
} else {
world.demote(type);
}
}
} finally {
inStream.close();
}
return addedAspects;
}
/**
* Look for .class files that represent aspects in the supplied directory - return the list of accumulated aspects.
*
* @param directory the directory in which to look for Aspect .class files
* @return the list of discovered aspects
* @throws FileNotFoundException
* @throws IOException
*/
private List<ResolvedType> addAspectsFromDirectory(File directory) throws FileNotFoundException, IOException {
List<ResolvedType> addedAspects = new ArrayList<ResolvedType>();
File[] classFiles = FileUtil.listFiles(directory, new FileFilter() {
public boolean accept(File pathname) {
return pathname.getName().endsWith(".class");
}
});
for (File classFile : classFiles) {
FileInputStream fis = new FileInputStream(classFile);
byte[] classBytes = FileUtil.readAsByteArray(fis);
ResolvedType aspectType = isAspect(classBytes, classFile.getAbsolutePath(), directory);
if (aspectType != null) {
addedAspects.add(aspectType);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
}
fis.close();
}
return addedAspects;
}
/**
* Determine if the supplied bytes represent an aspect, if they do then create a ResolvedType instance for the aspect and return
* it, otherwise return null
*
* @param classbytes the classbytes that might represent an aspect
* @param name the name of the class
* @param directory directory which contained the class file
* @return a ResolvedType if the classbytes represent an aspect, otherwise null
*/
private ResolvedType isAspect(byte[] classbytes, String name, File dir) throws IOException {
ClassParser parser = new ClassParser(new ByteArrayInputStream(classbytes), name);
JavaClass jc = parser.parse();
ResolvedType type = world.addSourceObjectType(jc, false).getResolvedTypeX();
String typeName = type.getName().replace('.', File.separatorChar);
int end = name.lastIndexOf(typeName + ".class");
String binaryPath = null;
if (end == -1) {
binaryPath = dir.getAbsolutePath();
} else {
binaryPath = name.substring(0, end - 1);
}
type.setBinaryPath(binaryPath);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
if (type.isAspect()) {
return type;
} else {
world.demote(type);
return null;
}
}
/**
* Add any .class files in the directory to the outdir. Anything other than .class files in the directory (or its
* subdirectories) are considered resources and are also copied.
*
*/
public List<UnwovenClassFile> addDirectoryContents(File inFile, File outDir) throws IOException {
List<UnwovenClassFile> addedClassFiles = new ArrayList<UnwovenClassFile>();
File[] files = FileUtil.listFiles(inFile, new FileFilter() {
public boolean accept(File f) {
boolean accept = !f.isDirectory();
return accept;
}
});
for (int i = 0; i < files.length; i++) {
addedClassFiles.add(addClassFile(files[i], inFile, outDir));
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
}
return addedClassFiles;
}
/**
* Adds all class files in the jar
*/
public List<UnwovenClassFile> addJarFile(File inFile, File outDir, boolean canBeDirectory) {
List<UnwovenClassFile> addedClassFiles = new ArrayList<UnwovenClassFile>();
needToReweaveWorld = true;
JarFile inJar = null;
try {
if (inFile.isDirectory() && canBeDirectory) {
addedClassFiles.addAll(addDirectoryContents(inFile, outDir));
} else {
inJar = new JarFile(inFile);
try {
addManifest(inJar.getManifest());
Enumeration entries = inJar.entries();
while (entries.hasMoreElements()) {
JarEntry entry = (JarEntry) entries.nextElement();
InputStream inStream = inJar.getInputStream(entry);
byte[] bytes = FileUtil.readAsByteArray(inStream);
String filename = entry.getName();
UnwovenClassFile classFile = new UnwovenClassFile(new File(outDir, filename).getAbsolutePath(), bytes);
if (filename.endsWith(".class")) {
ReferenceType type = this.addClassFile(classFile, false);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
StringBuffer sb = new StringBuffer();
sb.append(inFile.getAbsolutePath());
sb.append("!");
sb.append(entry.getName());
type.setBinaryPath(sb.toString());
addedClassFiles.add(classFile);
}
inStream.close();
}
} finally {
inJar.close();
}
inJar.close();
}
} catch (FileNotFoundException ex) {
IMessage message = new Message("Could not find input jar file " + inFile.getPath() + ", ignoring", new SourceLocation(
inFile, 0), false);
world.getMessageHandler().handleMessage(message);
} catch (IOException ex) {
IMessage message = new Message("Could not read input jar file " + inFile.getPath() + "(" + ex.getMessage() + ")",
new SourceLocation(inFile, 0), true);
world.getMessageHandler().handleMessage(message);
} finally {
if (inJar != null) {
try {
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
inJar.close();
} catch (IOException ex) {
IMessage message = new Message("Could not close input jar file " + inFile.getPath() + "(" + ex.getMessage()
+ ")", new SourceLocation(inFile, 0), true);
world.getMessageHandler().handleMessage(message);
}
}
}
return addedClassFiles;
}
public boolean needToReweaveWorld() {
return needToReweaveWorld;
}
/**
* Should be addOrReplace
*/
public ReferenceType addClassFile(UnwovenClassFile classFile, boolean fromInpath) {
addedClasses.add(classFile);
ReferenceType type = world.addSourceObjectType(classFile.getJavaClass(), false).getResolvedTypeX();
if (fromInpath) {
type.setBinaryPath(classFile.getFilename());
}
return type;
}
public UnwovenClassFile addClassFile(File classFile, File inPathDir, File outDir) throws IOException {
FileInputStream fis = new FileInputStream(classFile);
byte[] bytes = FileUtil.readAsByteArray(fis);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
String filename = classFile.getAbsolutePath().substring(inPathDir.getAbsolutePath().length() + 1);
UnwovenClassFile ucf = new UnwovenClassFile(new File(outDir, filename).getAbsolutePath(), bytes);
if (filename.endsWith(".class")) {
StringBuffer sb = new StringBuffer();
sb.append(inPathDir.getAbsolutePath());
sb.append("!");
sb.append(filename);
ReferenceType type = this.addClassFile(ucf, false);
type.setBinaryPath(sb.toString());
}
fis.close();
return ucf;
}
public void deleteClassFile(String typename) {
deletedTypenames.add(typename);
world.deleteSourceObjectType(UnresolvedType.forName(typename));
}
public void setIsBatchWeave(boolean b) {
isBatchWeave = b;
}
public void prepareForWeave() {
if (trace.isTraceEnabled()) {
trace.enter("prepareForWeave", this);
}
needToReweaveWorld = xcutSet.hasChangedSinceLastReset();
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
for (Iterator<UnwovenClassFile> i = addedClasses.iterator(); i.hasNext();) {
UnwovenClassFile jc = i.next();
String name = jc.getClassName();
ResolvedType type = world.resolve(name);
if (type.isAspect() && !world.isOverWeaving()) {
needToReweaveWorld |= xcutSet.addOrReplaceAspect(type);
}
}
for (Iterator<String> i = deletedTypenames.iterator(); i.hasNext();) {
String name = i.next();
if (xcutSet.deleteAspect(UnresolvedType.forName(name))) {
needToReweaveWorld = true;
}
}
shadowMungerList = xcutSet.getShadowMungers();
rewritePointcuts(shadowMungerList);
typeMungerList = xcutSet.getTypeMungers();
lateTypeMungerList = xcutSet.getLateTypeMungers();
declareParentsList = xcutSet.getDeclareParents();
addCustomMungers();
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
Collections.sort(shadowMungerList, new Comparator<ShadowMunger>() {
public int compare(ShadowMunger sm1, ShadowMunger sm2) {
if (sm1.getSourceLocation() == null) {
return (sm2.getSourceLocation() == null ? 0 : 1);
}
if (sm2.getSourceLocation() == null) {
return -1;
}
return (sm2.getSourceLocation().getOffset() - sm1.getSourceLocation().getOffset());
}
});
if (inReweavableMode) {
world.showMessage(IMessage.INFO, WeaverMessages.format(WeaverMessages.REWEAVABLE_MODE), null, null);
}
if (trace.isTraceEnabled()) {
trace.exit("prepareForWeave");
}
}
private void addCustomMungers() {
if (customMungerFactory != null) {
for (Iterator<UnwovenClassFile> i = addedClasses.iterator(); i.hasNext();) {
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
UnwovenClassFile jc = i.next();
String name = jc.getClassName();
ResolvedType type = world.resolve(name);
if (type.isAspect()) {
Collection<ShadowMunger> shadowMungers = customMungerFactory.createCustomShadowMungers(type);
if (shadowMungers != null) {
shadowMungerList.addAll(shadowMungers);
}
Collection<ConcreteTypeMunger> typeMungers = customMungerFactory.createCustomTypeMungers(type);
if (typeMungers != null) {
typeMungerList.addAll(typeMungers);
}
}
}
}
}
public void setCustomMungerFactory(CustomMungerFactory factory) {
customMungerFactory = factory;
}
/*
* Rewrite all of the pointcuts in the world into their most efficient form for subsequent matching. Also ensure that if
* pc1.equals(pc2) then pc1 == pc2 (for non-binding pcds) by making references all point to the same instance. Since pointcuts
* remember their match decision on the last shadow, this makes matching faster when many pointcuts share common elements, or
* even when one single pointcut has one common element (which can be a side-effect of DNF rewriting).
*/
private void rewritePointcuts(List<ShadowMunger> shadowMungers) {
PointcutRewriter rewriter = new PointcutRewriter();
for (ShadowMunger munger : shadowMungers) {
Pointcut p = munger.getPointcut();
Pointcut newP = rewriter.rewrite(p);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
if (munger instanceof Advice) {
Advice advice = (Advice) munger;
if (advice.getSignature() != null) {
final int numFormals;
final String names[];
if ((advice.getConcreteAspect().isAnnotationStyleAspect() && advice.getDeclaringAspect() != null && advice
.getDeclaringAspect().resolve(world).isAnnotationStyleAspect())
|| advice.isAnnotationStyle()) {
numFormals = advice.getBaseParameterCount();
int numArgs = advice.getSignature().getParameterTypes().length;
if (numFormals > 0) {
names = advice.getSignature().getParameterNames(world);
validateBindings(newP, p, numArgs, names);
}
} else {
numFormals = advice.getBaseParameterCount();
if (numFormals > 0) {
names = advice.getBaseParameterNames(world);
validateBindings(newP, p, numFormals, names);
}
}
}
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
}
newP.m_ignoreUnboundBindingForNames = p.m_ignoreUnboundBindingForNames;
munger.setPointcut(newP);
}
Map<Pointcut, Pointcut> pcMap = new HashMap<Pointcut, Pointcut>();
for (Iterator iter = shadowMungers.iterator(); iter.hasNext();) {
ShadowMunger munger = (ShadowMunger) iter.next();
Pointcut p = munger.getPointcut();
Pointcut newP = shareEntriesFromMap(p, pcMap);
newP.m_ignoreUnboundBindingForNames = p.m_ignoreUnboundBindingForNames;
munger.setPointcut(newP);
}
}
private Pointcut shareEntriesFromMap(Pointcut p, Map<Pointcut, Pointcut> pcMap) {
if (p instanceof NameBindingPointcut) {
return p;
}
if (p instanceof IfPointcut) {
return p;
}
if (p instanceof ConcreteCflowPointcut) {
return p;
}
if (p instanceof AndPointcut) {
AndPointcut apc = (AndPointcut) p;
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
Pointcut left = shareEntriesFromMap(apc.getLeft(), pcMap);
Pointcut right = shareEntriesFromMap(apc.getRight(), pcMap);
return new AndPointcut(left, right);
} else if (p instanceof OrPointcut) {
OrPointcut opc = (OrPointcut) p;
Pointcut left = shareEntriesFromMap(opc.getLeft(), pcMap);
Pointcut right = shareEntriesFromMap(opc.getRight(), pcMap);
return new OrPointcut(left, right);
} else if (p instanceof NotPointcut) {
NotPointcut npc = (NotPointcut) p;
Pointcut not = shareEntriesFromMap(npc.getNegatedPointcut(), pcMap);
return new NotPointcut(not);
} else {
if (pcMap.containsKey(p)) {
return pcMap.get(p);
} else {
pcMap.put(p, p);
return p;
}
}
}
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
private void validateBindings(Pointcut dnfPointcut, Pointcut userPointcut, int numFormals, String[] names) {
if (numFormals == 0) {
return;
}
if (dnfPointcut.couldMatchKinds() == Shadow.NO_SHADOW_KINDS_BITS) {
return;
}
if (dnfPointcut instanceof OrPointcut) {
OrPointcut orBasedDNFPointcut = (OrPointcut) dnfPointcut;
Pointcut[] leftBindings = new Pointcut[numFormals];
Pointcut[] rightBindings = new Pointcut[numFormals];
validateOrBranch(orBasedDNFPointcut, userPointcut, numFormals, names, leftBindings, rightBindings);
} else {
Pointcut[] bindings = new Pointcut[numFormals];
validateSingleBranch(dnfPointcut, userPointcut, numFormals, names, bindings);
}
}
private void validateOrBranch(OrPointcut pc, Pointcut userPointcut, int numFormals, String[] names, Pointcut[] leftBindings,
Pointcut[] rightBindings) {
Pointcut left = pc.getLeft();
Pointcut right = pc.getRight();
if (left instanceof OrPointcut) {
Pointcut[] newRightBindings = new Pointcut[numFormals];
validateOrBranch((OrPointcut) left, userPointcut, numFormals, names, leftBindings, newRightBindings);
} else {
if (left.couldMatchKinds() != Shadow.NO_SHADOW_KINDS_BITS) {
validateSingleBranch(left, userPointcut, numFormals, names, leftBindings);
}
}
if (right instanceof OrPointcut) {
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
Pointcut[] newLeftBindings = new Pointcut[numFormals];
validateOrBranch((OrPointcut) right, userPointcut, numFormals, names, newLeftBindings, rightBindings);
} else {
if (right.couldMatchKinds() != Shadow.NO_SHADOW_KINDS_BITS) {
validateSingleBranch(right, userPointcut, numFormals, names, rightBindings);
}
}
int kindsInCommon = left.couldMatchKinds() & right.couldMatchKinds();
if (kindsInCommon != Shadow.NO_SHADOW_KINDS_BITS && couldEverMatchSameJoinPoints(left, right)) {
List<String> ambiguousNames = new ArrayList<String>();
for (int i = 0; i < numFormals; i++) {
if (leftBindings[i] == null) {
if (rightBindings[i] != null) {
ambiguousNames.add(names[i]);
}
} else if (!leftBindings[i].equals(rightBindings[i])) {
ambiguousNames.add(names[i]);
}
}
if (!ambiguousNames.isEmpty()) {
raiseAmbiguityInDisjunctionError(userPointcut, ambiguousNames);
}
}
}
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
private void validateSingleBranch(Pointcut pc, Pointcut userPointcut, int numFormals, String[] names, Pointcut[] bindings) {
boolean[] foundFormals = new boolean[numFormals];
for (int i = 0; i < foundFormals.length; i++) {
foundFormals[i] = false;
}
validateSingleBranchRecursion(pc, userPointcut, foundFormals, names, bindings);
for (int i = 0; i < foundFormals.length; i++) {
if (!foundFormals[i]) {
boolean ignore = false;
for (int j = 0; j < userPointcut.m_ignoreUnboundBindingForNames.length; j++) {
if (names[i] != null && names[i].equals(userPointcut.m_ignoreUnboundBindingForNames[j])) {
ignore = true;
break;
}
}
if (!ignore) {
raiseUnboundFormalError(names[i], userPointcut);
}
}
}
}
private void validateSingleBranchRecursion(Pointcut pc, Pointcut userPointcut, boolean[] foundFormals, String[] names,
Pointcut[] bindings) {
if (pc instanceof NotPointcut) {
NotPointcut not = (NotPointcut) pc;
if (not.getNegatedPointcut() instanceof NameBindingPointcut) {
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
NameBindingPointcut nnbp = (NameBindingPointcut) not.getNegatedPointcut();
if (!nnbp.getBindingAnnotationTypePatterns().isEmpty() && !nnbp.getBindingTypePatterns().isEmpty()) {
raiseNegationBindingError(userPointcut);
}
}
} else if (pc instanceof AndPointcut) {
AndPointcut and = (AndPointcut) pc;
validateSingleBranchRecursion(and.getLeft(), userPointcut, foundFormals, names, bindings);
validateSingleBranchRecursion(and.getRight(), userPointcut, foundFormals, names, bindings);
} else if (pc instanceof NameBindingPointcut) {
Listbtps = ((NameBindingPointcut) pc).getBindingTypePatterns();
for (Iterator iter = btps.iterator(); iter.hasNext();) {
BindingTypePattern btp = (BindingTypePattern) iter.next();
int index = btp.getFormalIndex();
bindings[index] = pc;
if (foundFormals[index]) {
raiseAmbiguousBindingError(names[index], userPointcut);
} else {
foundFormals[index] = true;
}
}
Listbaps = ((NameBindingPointcut) pc).getBindingAnnotationTypePatterns();
for (Iterator iter = baps.iterator(); iter.hasNext();) {
BindingPattern bap = (BindingPattern) iter.next();
int index = bap.getFormalIndex();
bindings[index] = pc;
if (foundFormals[index]) {
raiseAmbiguousBindingError(names[index], userPointcut);
} else {
foundFormals[index] = true;
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
}
}
} else if (pc instanceof ConcreteCflowPointcut) {
ConcreteCflowPointcut cfp = (ConcreteCflowPointcut) pc;
int[] slots = cfp.getUsedFormalSlots();
for (int i = 0; i < slots.length; i++) {
bindings[slots[i]] = cfp;
if (foundFormals[slots[i]]) {
raiseAmbiguousBindingError(names[slots[i]], userPointcut);
} else {
foundFormals[slots[i]] = true;
}
}
}
}
private boolean couldEverMatchSameJoinPoints(Pointcut left, Pointcut right) {
if (left instanceof OrPointcut) {
OrPointcut leftOrPointcut = (OrPointcut) left;
if (couldEverMatchSameJoinPoints(leftOrPointcut.getLeft(), right)) {
return true;
}
if (couldEverMatchSameJoinPoints(leftOrPointcut.getRight(), right)) {
return true;
}
return false;
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
}
if (right instanceof OrPointcut) {
OrPointcut rightOrPointcut = (OrPointcut) right;
if (couldEverMatchSameJoinPoints(left, rightOrPointcut.getLeft())) {
return true;
}
if (couldEverMatchSameJoinPoints(left, rightOrPointcut.getRight())) {
return true;
}
return false;
}
WithinPointcut leftWithin = (WithinPointcut) findFirstPointcutIn(left, WithinPointcut.class);
WithinPointcut rightWithin = (WithinPointcut) findFirstPointcutIn(right, WithinPointcut.class);
if ((leftWithin != null) && (rightWithin != null)) {
if (!leftWithin.couldEverMatchSameJoinPointsAs(rightWithin)) {
return false;
}
}
KindedPointcut leftKind = (KindedPointcut) findFirstPointcutIn(left, KindedPointcut.class);
KindedPointcut rightKind = (KindedPointcut) findFirstPointcutIn(right, KindedPointcut.class);
if ((leftKind != null) && (rightKind != null)) {
if (!leftKind.couldEverMatchSameJoinPointsAs(rightKind)) {
return false;
}
}
return true;
}
private Pointcut findFirstPointcutIn(Pointcut toSearch, Class toLookFor) {
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
if (toSearch instanceof NotPointcut) {
return null;
}
if (toLookFor.isInstance(toSearch)) {
return toSearch;
}
if (toSearch instanceof AndPointcut) {
AndPointcut apc = (AndPointcut) toSearch;
Pointcut left = findFirstPointcutIn(apc.getLeft(), toLookFor);
if (left != null) {
return left;
}
return findFirstPointcutIn(apc.getRight(), toLookFor);
}
return null;
}
/**
* @param userPointcut
*/
private void raiseNegationBindingError(Pointcut userPointcut) {
world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.NEGATION_DOESNT_ALLOW_BINDING), userPointcut
.getSourceContext().makeSourceLocation(userPointcut), null);
}
/**
* @param name
* @param userPointcut
*/
private void raiseAmbiguousBindingError(String name, Pointcut userPointcut) {
world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.AMBIGUOUS_BINDING, name), userPointcut
.getSourceContext().makeSourceLocation(userPointcut), null);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
}
/**
* @param userPointcut
*/
private void raiseAmbiguityInDisjunctionError(Pointcut userPointcut, List<String> names) {
StringBuffer formalNames = new StringBuffer(names.get(0).toString());
for (int i = 1; i < names.size(); i++) {
formalNames.append(", ");
formalNames.append(names.get(i));
}
world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.AMBIGUOUS_BINDING_IN_OR, formalNames), userPointcut
.getSourceContext().makeSourceLocation(userPointcut), null);
}
/**
* @param name
* @param userPointcut
*/
private void raiseUnboundFormalError(String name, Pointcut userPointcut) {
world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.UNBOUND_FORMAL, name),
userPointcut.getSourceLocation(), null);
}
public void addManifest(Manifest newManifest) {
if (manifest == null) {
manifest = newManifest;
}
}
public Manifest getManifest(boolean shouldCreate) {
if (manifest == null && shouldCreate) {
String WEAVER_MANIFEST_VERSION = "1.0";
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
Attributes.Name CREATED_BY = new Name("Created-By");
String WEAVER_CREATED_BY = "AspectJ Compiler";
manifest = new Manifest();
Attributes attributes = manifest.getMainAttributes();
attributes.put(Name.MANIFEST_VERSION, WEAVER_MANIFEST_VERSION);
attributes.put(CREATED_BY, WEAVER_CREATED_BY);
}
return manifest;
}
public Collection<String> weave(File file) throws IOException {
OutputStream os = FileUtil.makeOutputStream(file);
this.zipOutputStream = new ZipOutputStream(os);
prepareForWeave();
Collection<String> c = weave(new IClassFileProvider() {
public boolean isApplyAtAspectJMungersOnly() {
return false;
}
public Iterator<UnwovenClassFile> getClassFileIterator() {
return addedClasses.iterator();
}
public IWeaveRequestor getRequestor() {
return new IWeaveRequestor() {
public void acceptResult(IUnwovenClassFile result) {
try {
writeZipEntry(result.getFilename(), result.getBytes());
} catch (IOException ex) {
}
}
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
public void processingReweavableState() {
}
public void addingTypeMungers() {
}
public void weavingAspects() {
}
public void weavingClasses() {
}
public void weaveCompleted() {
}
};
}
});
zipOutputStream.close();
return c;
}
private Set<IProgramElement> candidatesForRemoval = null;
public Collection<String> weave(IClassFileProvider input) throws IOException {
if (trace.isTraceEnabled()) {
trace.enter("weave", this, input);
}
ContextToken weaveToken = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING, "");
Collection<String> wovenClassNames = new ArrayList<String>();
IWeaveRequestor requestor = input.getRequestor();
if (world.getModel() != null && world.isMinimalModel()) {
candidatesForRemoval = new HashSet<IProgramElement>();
}
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
if (world.getModel() != null && !isBatchWeave) {
AsmManager manager = world.getModelAsAsmManager();
for (Iterator<UnwovenClassFile> i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = i.next();
manager.removeRelationshipsTargettingThisType(classFile.getClassName());
}
}
for (Iterator<UnwovenClassFile> i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = i.next();
String className = classFile.getClassName();
ResolvedType theType = world.resolve(className);
if (theType != null) {
theType.ensureConsistent();
}
}
if (input.isApplyAtAspectJMungersOnly()) {
ContextToken atAspectJMungersOnly = CompilationAndWeavingContext.enteringPhase(
CompilationAndWeavingContext.PROCESSING_ATASPECTJTYPE_MUNGERS_ONLY, "");
requestor.weavingAspects();
CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING_ASPECTS, "");
for (Iterator<UnwovenClassFile> i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = i.next();
String className = classFile.getClassName();
ResolvedType theType = world.resolve(className);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
if (theType.isAnnotationStyleAspect()) {
BcelObjectType classType = BcelWorld.getBcelObjectType(theType);
if (classType == null) {
throw new BCException("Can't find bcel delegate for " + className + " type=" + theType.getClass());
}
LazyClassGen clazz = classType.getLazyClassGen();
BcelPerClauseAspectAdder selfMunger = new BcelPerClauseAspectAdder(theType, theType.getPerClause().getKind());
selfMunger.forceMunge(clazz, true);
classType.finishedWith();
UnwovenClassFile[] newClasses = getClassFilesFor(clazz);
for (int news = 0; news < newClasses.length; news++) {
requestor.acceptResult(newClasses[news]);
}
wovenClassNames.add(classFile.getClassName());
}
}
requestor.weaveCompleted();
CompilationAndWeavingContext.leavingPhase(atAspectJMungersOnly);
return wovenClassNames;
}
requestor.processingReweavableState();
ContextToken reweaveToken = CompilationAndWeavingContext.enteringPhase(
CompilationAndWeavingContext.PROCESSING_REWEAVABLE_STATE, "");
prepareToProcessReweavableState();
for (Iterator<UnwovenClassFile> i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = i.next();
String className = classFile.getClassName();
BcelObjectType classType = getClassType(className);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
if (classType != null) {
ContextToken tok = CompilationAndWeavingContext.enteringPhase(
CompilationAndWeavingContext.PROCESSING_REWEAVABLE_STATE, className);
processReweavableStateIfPresent(className, classType);
CompilationAndWeavingContext.leavingPhase(tok);
}
}
CompilationAndWeavingContext.leavingPhase(reweaveToken);
ContextToken typeMungingToken = CompilationAndWeavingContext.enteringPhase(
CompilationAndWeavingContext.PROCESSING_TYPE_MUNGERS, "");
requestor.addingTypeMungers();
List<String> typesToProcess = new ArrayList<String>();
for (Iterator<UnwovenClassFile> iter = input.getClassFileIterator(); iter.hasNext();) {
UnwovenClassFile clf = iter.next();
typesToProcess.add(clf.getClassName());
}
while (typesToProcess.size() > 0) {
weaveParentsFor(typesToProcess, typesToProcess.get(0), null);
}
for (Iterator<UnwovenClassFile> i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = i.next();
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
String className = classFile.getClassName();
addNormalTypeMungers(className);
}
CompilationAndWeavingContext.leavingPhase(typeMungingToken);
requestor.weavingAspects();
ContextToken aspectToken = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING_ASPECTS, "");
for (Iterator<UnwovenClassFile> i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = i.next();
String className = classFile.getClassName();
ResolvedType theType = world.resolve(className);
if (theType.isAspect()) {
BcelObjectType classType = BcelWorld.getBcelObjectType(theType);
if (classType == null) {
ReferenceTypeDelegate theDelegate = ((ReferenceType) theType).getDelegate();
if (theDelegate.getClass().getName().endsWith("EclipseSourceType")) {
continue;
}
throw new BCException("Can't find bcel delegate for " + className + " type=" + theType.getClass());
}
weaveAndNotify(classFile, classType, requestor);
wovenClassNames.add(className);
}
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
}
CompilationAndWeavingContext.leavingPhase(aspectToken);
requestor.weavingClasses();
ContextToken classToken = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.WEAVING_CLASSES, "");
for (Iterator<UnwovenClassFile> i = input.getClassFileIterator(); i.hasNext();) {
UnwovenClassFile classFile = i.next();
String className = classFile.getClassName();
ResolvedType theType = world.resolve(className);
if (!theType.isAspect()) {
BcelObjectType classType = BcelWorld.getBcelObjectType(theType);
if (classType == null) {
ReferenceTypeDelegate theDelegate = ((ReferenceType) theType).getDelegate();
if (theDelegate.getClass().getName().endsWith("EclipseSourceType")) {
continue;
}
throw new BCException("Can't find bcel delegate for " + className + " type=" + theType.getClass());
}
weaveAndNotify(classFile, classType, requestor);
wovenClassNames.add(className);
}
}
CompilationAndWeavingContext.leavingPhase(classToken);
addedClasses.clear();
deletedTypenames.clear();
requestor.weaveCompleted();
CompilationAndWeavingContext.leavingPhase(weaveToken);
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
if (trace.isTraceEnabled()) {
trace.exit("weave", wovenClassNames);
}
if (world.getModel() != null && world.isMinimalModel()) {
candidatesForRemoval.clear();
}
return wovenClassNames;
}
public void allWeavingComplete() {
warnOnUnmatchedAdvice();
}
/**
* In 1.5 mode and with XLint:adviceDidNotMatch enabled, put out messages for any mungers that did not match anything.
*/
private void warnOnUnmatchedAdvice() {
class AdviceLocation {
private final int lineNo;
private final UnresolvedType inAspect;
public AdviceLocation(BcelAdvice advice) {
this.lineNo = advice.getSourceLocation().getLine();
this.inAspect = advice.getDeclaringAspect();
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof AdviceLocation)) {
return false;
}
AdviceLocation other = (AdviceLocation) obj;
if (this.lineNo != other.lineNo) {
return false;
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
}
if (!this.inAspect.equals(other.inAspect)) {
return false;
}
return true;
}
@Override
public int hashCode() {
return 37 + 17 * lineNo + 17 * inAspect.hashCode();
}
}
if (world.isInJava5Mode() && world.getLint().adviceDidNotMatch.isEnabled()) {
List l = world.getCrosscuttingMembersSet().getShadowMungers();
Set<AdviceLocation> alreadyWarnedLocations = new HashSet<AdviceLocation>();
for (Iterator iter = l.iterator(); iter.hasNext();) {
ShadowMunger element = (ShadowMunger) iter.next();
if (element instanceof BcelAdvice) {
BcelAdvice ba = (BcelAdvice) element;
if (ba.getKind() == AdviceKind.CflowEntry || ba.getKind() == AdviceKind.CflowBelowEntry) {
continue;
}
if (!ba.hasMatchedSomething()) {
|
350,855 |
Bug 350855 overweaving misbehaving when subclassing WeavingURLClassLoader
|
Raised by the Spring Insight team, they observed that in a system where they are using a special classloader (subclassing weaving url classloader) they see it fail to weave an aspect if overweaving is on.
|
resolved fixed
|
2302e94
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2011-06-30T15:34:56Z | 2011-06-30T16:06:40Z |
weaver/src/org/aspectj/weaver/bcel/BcelWeaver.java
|
if (ba.getSignature() != null) {
AdviceLocation loc = new AdviceLocation(ba);
if (alreadyWarnedLocations.contains(loc)) {
continue;
} else {
alreadyWarnedLocations.add(loc);
}
if (!(ba.getSignature() instanceof BcelMethod)
|| !Utility.isSuppressing(ba.getSignature(), "adviceDidNotMatch")) {
world.getLint().adviceDidNotMatch.signal(ba.getDeclaringAspect().toString(), new SourceLocation(
element.getSourceLocation().getSourceFile(), element.getSourceLocation().getLine()));
}
}
}
}
}
}
}
/**
* 'typeToWeave' is one from the 'typesForWeaving' list. This routine ensures we process supertypes (classes/interfaces) of
* 'typeToWeave' that are in the 'typesForWeaving' list before 'typeToWeave' itself. 'typesToWeave' is then removed from the
* 'typesForWeaving' list.
*
* Note: Future gotcha in here ... when supplying partial hierarchies, this algorithm may break down. If you have a hierarchy
* A>B>C and only give A and C to the weaver, it may choose to weave them in either order - but you'll probably have other
* problems if you are supplying partial hierarchies like that !
*/
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.