12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861 |
- /* *******************************************************************
- * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
- * All rights reserved.
- * This program and the accompanying materials are made available
- * under the terms of the 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
- * Alexandre Vasseur @AspectJ ITDs
- * ******************************************************************/
-
- package org.aspectj.weaver;
-
- import java.lang.reflect.Modifier;
- import java.util.ArrayList;
- import java.util.Arrays;
- import java.util.Collection;
- import java.util.Collections;
- import java.util.HashMap;
- import java.util.HashSet;
- import java.util.Iterator;
- import java.util.LinkedList;
- import java.util.List;
- import java.util.Map;
- import java.util.Queue;
- import java.util.Set;
-
- import org.aspectj.bridge.IMessage;
- import org.aspectj.bridge.ISourceLocation;
- import org.aspectj.bridge.Message;
- import org.aspectj.bridge.MessageUtil;
- import org.aspectj.util.FuzzyBoolean;
- import org.aspectj.weaver.AjAttribute.WeaverVersionInfo;
- import org.aspectj.weaver.Iterators.Getter;
- import org.aspectj.weaver.patterns.Declare;
- import org.aspectj.weaver.patterns.PerClause;
-
- public abstract class ResolvedType extends UnresolvedType implements AnnotatedElement {
-
- public static final ResolvedType[] EMPTY_RESOLVED_TYPE_ARRAY = new ResolvedType[0];
- public static final String PARAMETERIZED_TYPE_IDENTIFIER = "P";
-
- // Set temporarily during a type pattern match call - this currently used to hold the
- // annotations that may be attached to a type when it used as a parameter
- public ResolvedType[] temporaryAnnotationTypes;
- private ResolvedType[] resolvedTypeParams;
- private String binaryPath;
-
- protected World world;
-
- protected int bits;
-
- private static int AnnotationBitsInitialized = 0x0001;
- private static int AnnotationMarkedInherited = 0x0002;
- private static int MungersAnalyzed = 0x0004;
- private static int HasParentMunger = 0x0008;
- private static int TypeHierarchyCompleteBit = 0x0010;
- private static int GroovyObjectInitialized = 0x0020;
- private static int IsGroovyObject = 0x0040;
-
- protected ResolvedType(String signature, World world) {
- super(signature);
- this.world = world;
- }
-
- protected ResolvedType(String signature, String signatureErasure, World world) {
- super(signature, signatureErasure);
- this.world = world;
- }
-
- public int getSize() {
- return 1;
- }
-
- /**
- * Returns an iterator through ResolvedType objects representing all the direct supertypes of this type. That is, through the
- * superclass, if any, and all declared interfaces.
- */
- public final Iterator<ResolvedType> getDirectSupertypes() {
- Iterator<ResolvedType> interfacesIterator = Iterators.array(getDeclaredInterfaces());
- ResolvedType superclass = getSuperclass();
- if (superclass == null) {
- return interfacesIterator;
- } else {
- return Iterators.snoc(interfacesIterator, superclass);
- }
- }
-
- public abstract ResolvedMember[] getDeclaredFields();
-
- public abstract ResolvedMember[] getDeclaredMethods();
-
- public abstract ResolvedType[] getDeclaredInterfaces();
-
- public abstract ResolvedMember[] getDeclaredPointcuts();
-
- public boolean isCacheable() {
- return true;
- }
-
- /**
- * @return the superclass of this type, or null (if this represents a jlObject, primitive, or void)
- */
- public abstract ResolvedType getSuperclass();
-
- public abstract int getModifiers();
-
- // return true if this resolved type couldn't be found (but we know it's name maybe)
- public boolean isMissing() {
- return false;
- }
-
- // FIXME asc I wonder if in some circumstances MissingWithKnownSignature
- // should not be considered
- // 'really' missing as some code can continue based solely on the signature
- public static boolean isMissing(UnresolvedType unresolved) {
- if (unresolved instanceof ResolvedType) {
- ResolvedType resolved = (ResolvedType) unresolved;
- return resolved.isMissing();
- } else {
- return (unresolved == MISSING);
- }
- }
-
- public ResolvedType[] getAnnotationTypes() {
- return EMPTY_RESOLVED_TYPE_ARRAY;
- }
-
- public AnnotationAJ getAnnotationOfType(UnresolvedType ofType) {
- return null;
- }
-
- // public final UnresolvedType getSuperclass(World world) {
- // return getSuperclass();
- // }
-
- // This set contains pairs of types whose signatures are concatenated
- // together, this means with a fast lookup we can tell if two types
- // are equivalent.
- protected static Set<String> validBoxing = new HashSet<String>();
-
- static {
- validBoxing.add("Ljava/lang/Byte;B");
- validBoxing.add("Ljava/lang/Character;C");
- validBoxing.add("Ljava/lang/Double;D");
- validBoxing.add("Ljava/lang/Float;F");
- validBoxing.add("Ljava/lang/Integer;I");
- validBoxing.add("Ljava/lang/Long;J");
- validBoxing.add("Ljava/lang/Short;S");
- validBoxing.add("Ljava/lang/Boolean;Z");
- validBoxing.add("BLjava/lang/Byte;");
- validBoxing.add("CLjava/lang/Character;");
- validBoxing.add("DLjava/lang/Double;");
- validBoxing.add("FLjava/lang/Float;");
- validBoxing.add("ILjava/lang/Integer;");
- validBoxing.add("JLjava/lang/Long;");
- validBoxing.add("SLjava/lang/Short;");
- validBoxing.add("ZLjava/lang/Boolean;");
- }
-
- // utilities
- public ResolvedType getResolvedComponentType() {
- return null;
- }
-
- public World getWorld() {
- return world;
- }
-
- // ---- things from object
-
- @Override
- public boolean equals(Object other) {
- if (other instanceof ResolvedType) {
- return this == other;
- } else {
- return super.equals(other);
- }
- }
-
- // ---- difficult things
-
- /**
- * returns an iterator through all of the fields of this type, in order for checking from JVM spec 2ed 5.4.3.2. This means that
- * the order is
- * <p/>
- * <ul>
- * <li>fields from current class</li>
- * <li>recur into direct superinterfaces</li>
- * <li>recur into superclass</li>
- * </ul>
- * <p/>
- * We keep a hashSet of interfaces that we've visited so we don't spiral out into 2^n land.
- */
- public Iterator<ResolvedMember> getFields() {
- final Iterators.Filter<ResolvedType> dupFilter = Iterators.dupFilter();
- Iterators.Getter<ResolvedType, ResolvedType> typeGetter = new Iterators.Getter<ResolvedType, ResolvedType>() {
- public Iterator<ResolvedType> get(ResolvedType o) {
- return dupFilter.filter(o.getDirectSupertypes());
- }
- };
- return Iterators.mapOver(Iterators.recur(this, typeGetter), FieldGetterInstance);
- }
-
- /**
- * returns an iterator through all of the methods of this type, in order for checking from JVM spec 2ed 5.4.3.3. This means that
- * the order is
- * <p/>
- * <ul>
- * <li>methods from current class</li>
- * <li>recur into superclass, all the way up, not touching interfaces</li>
- * <li>recur into all superinterfaces, in some unspecified order (but those 'closest' to this type are first)</li>
- * </ul>
- * <p/>
- *
- * @param wantGenerics is true if the caller would like all generics information, otherwise those methods are collapsed to their
- * erasure
- */
- public Iterator<ResolvedMember> getMethods(boolean wantGenerics, boolean wantDeclaredParents) {
- return Iterators.mapOver(getHierarchy(wantGenerics, wantDeclaredParents), MethodGetterInstance);
- }
-
- public Iterator<ResolvedMember> getMethodsIncludingIntertypeDeclarations(boolean wantGenerics, boolean wantDeclaredParents) {
- return Iterators.mapOver(getHierarchy(wantGenerics, wantDeclaredParents), MethodGetterWithItdsInstance);
- }
-
- /**
- * An Iterators.Getter that returns an iterator over all methods declared on some resolved type.
- */
- private static class MethodGetter implements Iterators.Getter<ResolvedType, ResolvedMember> {
- public Iterator<ResolvedMember> get(ResolvedType type) {
- return Iterators.array(type.getDeclaredMethods());
- }
- }
-
- /**
- * An Iterators.Getter that returns an iterator over all pointcuts declared on some resolved type.
- */
- private static class PointcutGetter implements Iterators.Getter<ResolvedType, ResolvedMember> {
- public Iterator<ResolvedMember> get(ResolvedType o) {
- return Iterators.array(o.getDeclaredPointcuts());
- }
- }
-
- // OPTIMIZE could cache the result of discovering ITDs
-
- // Getter that returns all declared methods for a type through an iterator - including intertype declarations
- private static class MethodGetterIncludingItds implements Iterators.Getter<ResolvedType, ResolvedMember> {
- public Iterator<ResolvedMember> get(ResolvedType type) {
- ResolvedMember[] methods = type.getDeclaredMethods();
- if (type.interTypeMungers != null) {
- int additional = 0;
- for (ConcreteTypeMunger typeTransformer : type.interTypeMungers) {
- ResolvedMember rm = typeTransformer.getSignature();
- // BUG won't this include fields? When we are looking for methods
- if (rm != null) { // new parent type munger can have null signature
- additional++;
- }
- }
- if (additional > 0) {
- ResolvedMember[] methods2 = new ResolvedMember[methods.length + additional];
- System.arraycopy(methods, 0, methods2, 0, methods.length);
- additional = methods.length;
- for (ConcreteTypeMunger typeTransformer : type.interTypeMungers) {
- ResolvedMember rm = typeTransformer.getSignature();
- if (rm != null) { // new parent type munger can have null signature
- methods2[additional++] = typeTransformer.getSignature();
- }
- }
- methods = methods2;
- }
- }
- return Iterators.array(methods);
- }
- }
-
- /**
- * An Iterators.Getter that returns an iterator over all fields declared on some resolved type.
- */
- private static class FieldGetter implements Iterators.Getter<ResolvedType, ResolvedMember> {
- public Iterator<ResolvedMember> get(ResolvedType type) {
- return Iterators.array(type.getDeclaredFields());
- }
- }
-
- private final static MethodGetter MethodGetterInstance = new MethodGetter();
- private final static MethodGetterIncludingItds MethodGetterWithItdsInstance = new MethodGetterIncludingItds();
- private final static PointcutGetter PointcutGetterInstance = new PointcutGetter();
- private final static FieldGetter FieldGetterInstance = new FieldGetter();
-
- /**
- * Return an iterator over the types in this types hierarchy - starting with this type first, then all superclasses up to Object
- * and then all interfaces (starting with those 'nearest' this type).
- *
- * @param wantGenerics true if the caller wants full generic information
- * @param wantDeclaredParents true if the caller even wants those parents introduced via declare parents
- * @return an iterator over all types in the hierarchy of this type
- */
- public Iterator<ResolvedType> getHierarchy() {
- return getHierarchy(false, false);
- }
-
- public Iterator<ResolvedType> getHierarchy(final boolean wantGenerics, final boolean wantDeclaredParents) {
-
- final Iterators.Getter<ResolvedType, ResolvedType> interfaceGetter = new Iterators.Getter<ResolvedType, ResolvedType>() {
- List<String> alreadySeen = new ArrayList<String>(); // Strings are signatures (ResolvedType.getSignature())
-
- public Iterator<ResolvedType> get(ResolvedType type) {
- ResolvedType[] interfaces = type.getDeclaredInterfaces();
-
- // remove interfaces introduced by declare parents
- // relatively expensive but hopefully uncommon
- if (!wantDeclaredParents && type.hasNewParentMungers()) {
- // Throw away interfaces from that array if they were decp'd onto here
- List<Integer> forRemoval = new ArrayList<Integer>();
- for (ConcreteTypeMunger munger : type.interTypeMungers) {
- if (munger.getMunger() != null) {
- ResolvedTypeMunger m = munger.getMunger();
- if (m.getKind() == ResolvedTypeMunger.Parent) {
- ResolvedType newType = ((NewParentTypeMunger) m).getNewParent();
- if (!wantGenerics && newType.isParameterizedOrGenericType()) {
- newType = newType.getRawType();
- }
- for (int ii = 0; ii < interfaces.length; ii++) {
- ResolvedType iface = interfaces[ii];
- if (!wantGenerics && iface.isParameterizedOrGenericType()) {
- iface = iface.getRawType();
- }
- if (newType.getSignature().equals(iface.getSignature())) { // pr171953
- forRemoval.add(ii);
- }
- }
- }
- }
- }
- // Found some to remove from those we are going to iterate over
- if (forRemoval.size() > 0) {
- ResolvedType[] interfaces2 = new ResolvedType[interfaces.length - forRemoval.size()];
- int p = 0;
- for (int ii = 0; ii < interfaces.length; ii++) {
- if (!forRemoval.contains(ii)) {
- interfaces2[p++] = interfaces[ii];
- }
- }
- interfaces = interfaces2;
- }
- }
- return new Iterators.ResolvedTypeArrayIterator(interfaces, alreadySeen, wantGenerics);
- }
- };
-
- // If this type is an interface, there are only interfaces to walk
- if (this.isInterface()) {
- return new SuperInterfaceWalker(interfaceGetter, this);
- } else {
- SuperInterfaceWalker superInterfaceWalker = new SuperInterfaceWalker(interfaceGetter);
- Iterator<ResolvedType> superClassesIterator = new SuperClassWalker(this, superInterfaceWalker, wantGenerics);
- // append() will check if the second iterator is empty before appending - but the types which the superInterfaceWalker
- // needs to visit are only accumulated whilst the superClassesIterator is in progress
- return Iterators.append1(superClassesIterator, superInterfaceWalker);
- }
- }
-
- /**
- * Return a list of methods, first those declared on this class, then those declared on the superclass (recurse) and then those
- * declared on the superinterfaces. This is expensive - use the getMethods() method if you can!
- */
- public List<ResolvedMember> getMethodsWithoutIterator(boolean includeITDs, boolean allowMissing, boolean genericsAware) {
- List<ResolvedMember> methods = new ArrayList<ResolvedMember>();
- Set<String> knowninterfaces = new HashSet<String>();
- addAndRecurse(knowninterfaces, methods, this, includeITDs, allowMissing, genericsAware);
- return methods;
- }
-
- /**
- * Return a list of the types in the hierarchy of this type, starting with this type. The order in the list is the superclasses
- * followed by the super interfaces.
- *
- * @param genericsAware should the list include parameterized/generic types (if not, they will be collapsed to raw)?
- * @return list of resolvedtypes in this types hierarchy, including this type first
- */
- public List<ResolvedType> getHierarchyWithoutIterator(boolean includeITDs, boolean allowMissing, boolean genericsAware) {
- List<ResolvedType> types = new ArrayList<ResolvedType>();
- Set<String> visited = new HashSet<String>();
- recurseHierarchy(visited, types, this, includeITDs, allowMissing, genericsAware);
- return types;
- }
-
- private void addAndRecurse(Set<String> knowninterfaces, List<ResolvedMember> collector, ResolvedType resolvedType,
- boolean includeITDs, boolean allowMissing, boolean genericsAware) {
- // Add the methods declared on this type
- collector.addAll(Arrays.asList(resolvedType.getDeclaredMethods()));
- // now add all the inter-typed members too
- if (includeITDs && resolvedType.interTypeMungers != null) {
- for (ConcreteTypeMunger typeTransformer : interTypeMungers) {
- ResolvedMember rm = typeTransformer.getSignature();
- if (rm != null) { // new parent type munger can have null signature
- collector.add(typeTransformer.getSignature());
- }
- }
- }
- // BUG? interface type superclass is Object - is that correct?
- if (!resolvedType.isInterface() && !resolvedType.equals(ResolvedType.OBJECT)) {
- ResolvedType superType = resolvedType.getSuperclass();
- if (superType != null && !superType.isMissing()) {
- if (!genericsAware && superType.isParameterizedOrGenericType()) {
- superType = superType.getRawType();
- }
- // Recurse if we are not at the top
- addAndRecurse(knowninterfaces, collector, superType, includeITDs, allowMissing, genericsAware);
- }
- }
- // Go through the interfaces on the way back down
- ResolvedType[] interfaces = resolvedType.getDeclaredInterfaces();
- for (int i = 0; i < interfaces.length; i++) {
- ResolvedType iface = interfaces[i];
- if (!genericsAware && iface.isParameterizedOrGenericType()) {
- iface = iface.getRawType();
- }
- // we need to know if it is an interface from Parent kind munger
- // as those are used for @AJ ITD and we precisely want to skip those
- boolean shouldSkip = false;
- for (int j = 0; j < resolvedType.interTypeMungers.size(); j++) {
- ConcreteTypeMunger munger = resolvedType.interTypeMungers.get(j);
- if (munger.getMunger() != null && munger.getMunger().getKind() == ResolvedTypeMunger.Parent
- && ((NewParentTypeMunger) munger.getMunger()).getNewParent().equals(iface) // pr171953
- ) {
- shouldSkip = true;
- break;
- }
- }
-
- // Do not do interfaces more than once
- if (!shouldSkip && !knowninterfaces.contains(iface.getSignature())) {
- knowninterfaces.add(iface.getSignature());
- if (allowMissing && iface.isMissing()) {
- if (iface instanceof MissingResolvedTypeWithKnownSignature) {
- ((MissingResolvedTypeWithKnownSignature) iface).raiseWarningOnMissingInterfaceWhilstFindingMethods();
- }
- } else {
- addAndRecurse(knowninterfaces, collector, iface, includeITDs, allowMissing, genericsAware);
- }
- }
- }
- }
-
- /**
- * Recurse up a type hierarchy, first the superclasses then the super interfaces.
- */
- private void recurseHierarchy(Set<String> knowninterfaces, List<ResolvedType> collector, ResolvedType resolvedType,
- boolean includeITDs, boolean allowMissing, boolean genericsAware) {
- collector.add(resolvedType);
- if (!resolvedType.isInterface() && !resolvedType.equals(ResolvedType.OBJECT)) {
- ResolvedType superType = resolvedType.getSuperclass();
- if (superType != null && !superType.isMissing()) {
- if (!genericsAware && (superType.isParameterizedType() || superType.isGenericType())) {
- superType = superType.getRawType();
- }
- // Recurse if we are not at the top
- recurseHierarchy(knowninterfaces, collector, superType, includeITDs, allowMissing, genericsAware);
- }
- }
- // Go through the interfaces on the way back down
- ResolvedType[] interfaces = resolvedType.getDeclaredInterfaces();
- for (int i = 0; i < interfaces.length; i++) {
- ResolvedType iface = interfaces[i];
- if (!genericsAware && (iface.isParameterizedType() || iface.isGenericType())) {
- iface = iface.getRawType();
- }
- // we need to know if it is an interface from Parent kind munger
- // as those are used for @AJ ITD and we precisely want to skip those
- boolean shouldSkip = false;
- for (int j = 0; j < resolvedType.interTypeMungers.size(); j++) {
- ConcreteTypeMunger munger = resolvedType.interTypeMungers.get(j);
- if (munger.getMunger() != null && munger.getMunger().getKind() == ResolvedTypeMunger.Parent
- && ((NewParentTypeMunger) munger.getMunger()).getNewParent().equals(iface) // pr171953
- ) {
- shouldSkip = true;
- break;
- }
- }
-
- // Do not do interfaces more than once
- if (!shouldSkip && !knowninterfaces.contains(iface.getSignature())) {
- knowninterfaces.add(iface.getSignature());
- if (allowMissing && iface.isMissing()) {
- if (iface instanceof MissingResolvedTypeWithKnownSignature) {
- ((MissingResolvedTypeWithKnownSignature) iface).raiseWarningOnMissingInterfaceWhilstFindingMethods();
- }
- } else {
- recurseHierarchy(knowninterfaces, collector, iface, includeITDs, allowMissing, genericsAware);
- }
- }
- }
- }
-
- public ResolvedType[] getResolvedTypeParameters() {
- if (resolvedTypeParams == null) {
- resolvedTypeParams = world.resolve(typeParameters);
- }
- return resolvedTypeParams;
- }
-
- /**
- * described in JVM spec 2ed 5.4.3.2
- */
- public ResolvedMember lookupField(Member field) {
- Iterator<ResolvedMember> i = getFields();
- while (i.hasNext()) {
- ResolvedMember resolvedMember = i.next();
- if (matches(resolvedMember, field)) {
- return resolvedMember;
- }
- if (resolvedMember.hasBackingGenericMember() && field.getName().equals(resolvedMember.getName())) {
- // might be worth checking the member behind the parameterized member (see pr137496)
- if (matches(resolvedMember.getBackingGenericMember(), field)) {
- return resolvedMember;
- }
- }
- }
- return null;
- }
-
- /**
- * described in JVM spec 2ed 5.4.3.3. Doesnt check ITDs.
- *
- * <p>
- * Check the current type for the method. If it is not found, check the super class and any super interfaces. Taking care not to
- * process interfaces multiple times.
- */
- public ResolvedMember lookupMethod(Member m) {
- List<ResolvedType> typesTolookat = new ArrayList<ResolvedType>();
- typesTolookat.add(this);
- int pos = 0;
- while (pos < typesTolookat.size()) {
- ResolvedType type = typesTolookat.get(pos++);
- if (!type.isMissing()) {
- ResolvedMember[] methods = type.getDeclaredMethods();
- if (methods != null) {
- for (int i = 0; i < methods.length; i++) {
- ResolvedMember method = methods[i];
- if (matches(method, m)) {
- return method;
- }
- // might be worth checking the method behind the parameterized method (137496)
- if (method.hasBackingGenericMember() && m.getName().equals(method.getName())) {
- if (matches(method.getBackingGenericMember(), m)) {
- return method;
- }
- }
- }
- }
- }
- // Queue the superclass:
- ResolvedType superclass = type.getSuperclass();
- if (superclass != null) {
- typesTolookat.add(superclass);
- }
- // Queue any interfaces not already checked:
- ResolvedType[] superinterfaces = type.getDeclaredInterfaces();
- if (superinterfaces != null) {
- for (int i = 0; i < superinterfaces.length; i++) {
- ResolvedType interf = superinterfaces[i];
- if (!typesTolookat.contains(interf)) {
- typesTolookat.add(interf);
- }
- }
- }
- }
- return null;
- }
-
- /**
- * @param member the member to lookup in intertype declarations affecting this type
- * @return the real signature defined by any matching intertype declaration, otherwise null
- */
- public ResolvedMember lookupMethodInITDs(Member member) {
- for (ConcreteTypeMunger typeTransformer : interTypeMungers) {
- if (matches(typeTransformer.getSignature(), member)) {
- return typeTransformer.getSignature();
- }
- }
- return null;
- }
-
- /**
- * return null if not found
- */
- private ResolvedMember lookupMember(Member m, ResolvedMember[] a) {
- for (int i = 0; i < a.length; i++) {
- ResolvedMember f = a[i];
- if (matches(f, m)) {
- return f;
- }
- }
- return null;
- }
-
- // Bug (1) Do callers expect ITDs to be involved in the lookup? or do they do their own walk over ITDs?
- /**
- * Looks for the first member in the hierarchy matching aMember. This method differs from lookupMember(Member) in that it takes
- * into account parameters which are type variables - which clearly an unresolved Member cannot do since it does not know
- * anything about type variables.
- */
- public ResolvedMember lookupResolvedMember(ResolvedMember aMember, boolean allowMissing, boolean eraseGenerics) {
- Iterator<ResolvedMember> toSearch = null;
- ResolvedMember found = null;
- if ((aMember.getKind() == Member.METHOD) || (aMember.getKind() == Member.CONSTRUCTOR)) {
- // toSearch = getMethodsWithoutIterator(true, allowMissing, !eraseGenerics).iterator();
- toSearch = getMethodsIncludingIntertypeDeclarations(!eraseGenerics, true);
- } else if (aMember.getKind()==Member.ADVICE) {
- return null;
- } else {
- assert aMember.getKind() == Member.FIELD;
- toSearch = getFields();
- }
- while (toSearch.hasNext()) {
- ResolvedMember candidate = toSearch.next();
- if (eraseGenerics) {
- if (candidate.hasBackingGenericMember()) {
- candidate = candidate.getBackingGenericMember();
- }
- }
- // OPTIMIZE speed up matches? optimize order of checks
- if (candidate.matches(aMember, eraseGenerics)) {
- found = candidate;
- break;
- }
- }
-
- return found;
- }
-
- public static boolean matches(Member m1, Member m2) {
- if (m1 == null) {
- return m2 == null;
- }
- if (m2 == null) {
- return false;
- }
-
- // Check the names
- boolean equalNames = m1.getName().equals(m2.getName());
- if (!equalNames) {
- return false;
- }
-
- // Check the signatures
- boolean equalSignatures = m1.getSignature().equals(m2.getSignature());
- if (equalSignatures) {
- return true;
- }
-
- // If they aren't the same, we need to allow for covariance ... where
- // one sig might be ()LCar; and
- // the subsig might be ()LFastCar; - where FastCar is a subclass of Car
- boolean equalCovariantSignatures = m1.getParameterSignature().equals(m2.getParameterSignature());
- if (equalCovariantSignatures) {
- return true;
- }
-
- return false;
- }
- public static boolean conflictingSignature(Member m1, Member m2) {
- return conflictingSignature(m1,m2,true);
- }
-
- /**
- * Do the two members conflict? Due to the change in 1.7.1, field itds on interfaces now act like 'default' fields - so types implementing
- * those fields get the field if they don't have it already, otherwise they keep what they have. The conflict detection below had to be
- * altered. Previously (<1.7.1) it is not a conflict if the declaring types are different. With v2itds it may still be a conflict if the
- * declaring types are different.
- */
- public static boolean conflictingSignature(Member m1, Member m2, boolean v2itds) {
- if (m1 == null || m2 == null) {
- return false;
- }
- if (!m1.getName().equals(m2.getName())) {
- return false;
- }
- if (m1.getKind() != m2.getKind()) {
- return false;
- }
- if (m1.getKind() == Member.FIELD) {
- if (v2itds) {
- if (m1.getDeclaringType().equals(m2.getDeclaringType())) {
- return true;
- }
- } else {
- return m1.getDeclaringType().equals(m2.getDeclaringType());
- }
- } else if (m1.getKind() == Member.POINTCUT) {
- return true;
- }
-
- UnresolvedType[] p1 = m1.getGenericParameterTypes();
- UnresolvedType[] p2 = m2.getGenericParameterTypes();
- if (p1 == null) {
- p1 = m1.getParameterTypes();
- }
- if (p2 == null) {
- p2 = m2.getParameterTypes();
- }
- int n = p1.length;
- if (n != p2.length) {
- return false;
- }
-
- for (int i = 0; i < n; i++) {
- if (!p1[i].equals(p2[i])) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * returns an iterator through all of the pointcuts of this type, in order for checking from JVM spec 2ed 5.4.3.2 (as for
- * fields). This means that the order is
- * <p/>
- * <ul>
- * <li>pointcuts from current class</li>
- * <li>recur into direct superinterfaces</li>
- * <li>recur into superclass</li>
- * </ul>
- * <p/>
- * We keep a hashSet of interfaces that we've visited so we don't spiral out into 2^n land.
- */
- public Iterator<ResolvedMember> getPointcuts() {
- final Iterators.Filter<ResolvedType> dupFilter = Iterators.dupFilter();
- // same order as fields
- Iterators.Getter<ResolvedType, ResolvedType> typeGetter = new Iterators.Getter<ResolvedType, ResolvedType>() {
- public Iterator<ResolvedType> get(ResolvedType o) {
- return dupFilter.filter(o.getDirectSupertypes());
- }
- };
- return Iterators.mapOver(Iterators.recur(this, typeGetter), PointcutGetterInstance);
- }
-
- public ResolvedPointcutDefinition findPointcut(String name) {
- for (Iterator<ResolvedMember> i = getPointcuts(); i.hasNext();) {
- ResolvedPointcutDefinition f = (ResolvedPointcutDefinition) i.next();
- // the ResolvedPointcutDefinition can be null if there are other problems that prevented its resolution
- if (f != null && name.equals(f.getName())) {
- return f;
- }
- }
- // pr120521
- if (!getOutermostType().equals(this)) {
- ResolvedType outerType = getOutermostType().resolve(world);
- ResolvedPointcutDefinition rpd = outerType.findPointcut(name);
- return rpd;
- }
- return null; // should we throw an exception here?
- }
-
- // all about collecting CrosscuttingMembers
-
- // ??? collecting data-structure, shouldn't really be a field
- public CrosscuttingMembers crosscuttingMembers;
-
- public CrosscuttingMembers collectCrosscuttingMembers(boolean shouldConcretizeIfNeeded) {
- crosscuttingMembers = new CrosscuttingMembers(this, shouldConcretizeIfNeeded);
- if (getPerClause() == null) {
- return crosscuttingMembers;
- }
- crosscuttingMembers.setPerClause(getPerClause());
- crosscuttingMembers.addShadowMungers(collectShadowMungers());
- // GENERICITDFIX
- // crosscuttingMembers.addTypeMungers(collectTypeMungers());
- crosscuttingMembers.addTypeMungers(getTypeMungers());
- // FIXME AV - skip but needed ?? or ??
- // crosscuttingMembers.addLateTypeMungers(getLateTypeMungers());
- crosscuttingMembers.addDeclares(collectDeclares(!this.doesNotExposeShadowMungers()));
- crosscuttingMembers.addPrivilegedAccesses(getPrivilegedAccesses());
-
- // System.err.println("collected cc members: " + this + ", " +
- // collectDeclares());
- return crosscuttingMembers;
- }
-
- public final List<Declare> collectDeclares(boolean includeAdviceLike) {
- if (!this.isAspect()) {
- return Collections.emptyList();
- }
-
- List<Declare> ret = new ArrayList<Declare>();
- // if (this.isAbstract()) {
- // for (Iterator i = getDeclares().iterator(); i.hasNext();) {
- // Declare dec = (Declare) i.next();
- // if (!dec.isAdviceLike()) ret.add(dec);
- // }
- //
- // if (!includeAdviceLike) return ret;
-
- if (!this.isAbstract()) {
- // ret.addAll(getDeclares());
- final Iterators.Filter<ResolvedType> dupFilter = Iterators.dupFilter();
- Iterators.Getter<ResolvedType, ResolvedType> typeGetter = new Iterators.Getter<ResolvedType, ResolvedType>() {
- public Iterator<ResolvedType> get(ResolvedType o) {
- return dupFilter.filter((o).getDirectSupertypes());
- }
- };
- Iterator<ResolvedType> typeIterator = Iterators.recur(this, typeGetter);
-
- while (typeIterator.hasNext()) {
- ResolvedType ty = typeIterator.next();
- // System.out.println("super: " + ty + ", " + );
- for (Iterator<Declare> i = ty.getDeclares().iterator(); i.hasNext();) {
- Declare dec = i.next();
- if (dec.isAdviceLike()) {
- if (includeAdviceLike) {
- ret.add(dec);
- }
- } else {
- ret.add(dec);
- }
- }
- }
- }
-
- return ret;
- }
-
- private final List<ShadowMunger> collectShadowMungers() {
- if (!this.isAspect() || this.isAbstract() || this.doesNotExposeShadowMungers()) {
- return Collections.emptyList();
- }
-
- List<ShadowMunger> acc = new ArrayList<ShadowMunger>();
- final Iterators.Filter<ResolvedType> dupFilter = Iterators.dupFilter();
- Iterators.Getter<ResolvedType, ResolvedType> typeGetter = new Iterators.Getter<ResolvedType, ResolvedType>() {
- public Iterator<ResolvedType> get(ResolvedType o) {
- return dupFilter.filter((o).getDirectSupertypes());
- }
- };
- Iterator<ResolvedType> typeIterator = Iterators.recur(this, typeGetter);
-
- while (typeIterator.hasNext()) {
- ResolvedType ty = typeIterator.next();
- acc.addAll(ty.getDeclaredShadowMungers());
- }
-
- return acc;
- }
-
- public void addParent(ResolvedType newParent) {
- // Nothing to do for anything except a ReferenceType
- }
-
- protected boolean doesNotExposeShadowMungers() {
- return false;
- }
-
- public PerClause getPerClause() {
- return null;
- }
-
- public Collection<Declare> getDeclares() {
- return Collections.emptyList();
- }
-
- public Collection<ConcreteTypeMunger> getTypeMungers() {
- return Collections.emptyList();
- }
-
- public Collection<ResolvedMember> getPrivilegedAccesses() {
- return Collections.emptyList();
- }
-
- // ---- useful things
-
- public final boolean isInterface() {
- return Modifier.isInterface(getModifiers());
- }
-
- public final boolean isAbstract() {
- return Modifier.isAbstract(getModifiers());
- }
-
- public boolean isClass() {
- return false;
- }
-
- public boolean isAspect() {
- return false;
- }
-
- public boolean isAnnotationStyleAspect() {
- return false;
- }
-
- /**
- * Note: Only overridden by Name subtype.
- */
- public boolean isEnum() {
- return false;
- }
-
- /**
- * Note: Only overridden by Name subtype.
- */
- public boolean isAnnotation() {
- return false;
- }
-
- public boolean isAnonymous() {
- return false;
- }
-
- public boolean isNested() {
- return false;
- }
-
- public ResolvedType getOuterClass() {
- return null;
- }
-
- public void addAnnotation(AnnotationAJ annotationX) {
- throw new RuntimeException("ResolvedType.addAnnotation() should never be called");
- }
-
- public AnnotationAJ[] getAnnotations() {
- throw new RuntimeException("ResolvedType.getAnnotations() should never be called");
- }
-
- public boolean hasAnnotations() {
- throw new RuntimeException("ResolvedType.getAnnotations() should never be called");
- }
-
-
- /**
- * Note: Only overridden by ReferenceType subtype
- */
- public boolean canAnnotationTargetType() {
- return false;
- }
-
- /**
- * Note: Only overridden by ReferenceType subtype
- */
- public AnnotationTargetKind[] getAnnotationTargetKinds() {
- return null;
- }
-
- /**
- * Note: Only overridden by Name subtype.
- */
- public boolean isAnnotationWithRuntimeRetention() {
- return false;
- }
-
- public boolean isSynthetic() {
- return signature.indexOf("$ajc") != -1;
- }
-
- public final boolean isFinal() {
- return Modifier.isFinal(getModifiers());
- }
-
- protected Map<String, UnresolvedType> getMemberParameterizationMap() {
- if (!isParameterizedType()) {
- return Collections.emptyMap();
- }
- TypeVariable[] tvs = getGenericType().getTypeVariables();
- Map<String, UnresolvedType> parameterizationMap = new HashMap<String, UnresolvedType>();
- for (int i = 0; i < tvs.length; i++) {
- parameterizationMap.put(tvs[i].getName(), typeParameters[i]);
- }
- return parameterizationMap;
- }
-
- public List<ShadowMunger> getDeclaredAdvice() {
- List<ShadowMunger> l = new ArrayList<ShadowMunger>();
- ResolvedMember[] methods = getDeclaredMethods();
- if (isParameterizedType()) {
- methods = getGenericType().getDeclaredMethods();
- }
- Map<String, UnresolvedType> typeVariableMap = getAjMemberParameterizationMap();
- for (int i = 0, len = methods.length; i < len; i++) {
- ShadowMunger munger = methods[i].getAssociatedShadowMunger();
- if (munger != null) {
- if (ajMembersNeedParameterization()) {
- // munger.setPointcut(munger.getPointcut().parameterizeWith(
- // typeVariableMap));
- munger = munger.parameterizeWith(this, typeVariableMap);
- if (munger instanceof Advice) {
- Advice advice = (Advice) munger;
- // update to use the parameterized signature...
- UnresolvedType[] ptypes = methods[i].getGenericParameterTypes();
- UnresolvedType[] newPTypes = new UnresolvedType[ptypes.length];
- for (int j = 0; j < ptypes.length; j++) {
- if (ptypes[j] instanceof TypeVariableReferenceType) {
- TypeVariableReferenceType tvrt = (TypeVariableReferenceType) ptypes[j];
- if (typeVariableMap.containsKey(tvrt.getTypeVariable().getName())) {
- newPTypes[j] = typeVariableMap.get(tvrt.getTypeVariable().getName());
- } else {
- newPTypes[j] = ptypes[j];
- }
- } else {
- newPTypes[j] = ptypes[j];
- }
- }
- advice.setBindingParameterTypes(newPTypes);
- }
- }
- munger.setDeclaringType(this);
- l.add(munger);
- }
- }
- return l;
- }
-
- public List<ShadowMunger> getDeclaredShadowMungers() {
- return getDeclaredAdvice();
- }
-
- // ---- only for testing!
-
- public ResolvedMember[] getDeclaredJavaFields() {
- return filterInJavaVisible(getDeclaredFields());
- }
-
- public ResolvedMember[] getDeclaredJavaMethods() {
- return filterInJavaVisible(getDeclaredMethods());
- }
-
- private ResolvedMember[] filterInJavaVisible(ResolvedMember[] ms) {
- List<ResolvedMember> l = new ArrayList<ResolvedMember>();
- for (int i = 0, len = ms.length; i < len; i++) {
- if (!ms[i].isAjSynthetic() && ms[i].getAssociatedShadowMunger() == null) {
- l.add(ms[i]);
- }
- }
- return l.toArray(new ResolvedMember[l.size()]);
- }
-
- public abstract ISourceContext getSourceContext();
-
- // ---- fields
-
- public static final ResolvedType[] NONE = new ResolvedType[0];
- public static final ResolvedType[] EMPTY_ARRAY = NONE;
-
- public static final Missing MISSING = new Missing();
-
- // ---- types
- public static ResolvedType makeArray(ResolvedType type, int dim) {
- if (dim == 0) {
- return type;
- }
- ResolvedType array = new ArrayReferenceType("[" + type.getSignature(), "[" + type.getErasureSignature(), type.getWorld(),
- type);
- return makeArray(array, dim - 1);
- }
-
- static class Primitive extends ResolvedType {
- private final int size;
- private final int index;
-
- Primitive(String signature, int size, int index) {
- super(signature, null);
- this.size = size;
- this.index = index;
- this.typeKind = TypeKind.PRIMITIVE;
- }
-
- @Override
- public final int getSize() {
- return size;
- }
-
- @Override
- public final int getModifiers() {
- return Modifier.PUBLIC | Modifier.FINAL;
- }
-
- @Override
- public final boolean isPrimitiveType() {
- return true;
- }
-
- public boolean hasAnnotation(UnresolvedType ofType) {
- return false;
- }
-
- @Override
- public final boolean isAssignableFrom(ResolvedType other) {
- if (!other.isPrimitiveType()) {
- if (!world.isInJava5Mode()) {
- return false;
- }
- return validBoxing.contains(this.getSignature() + other.getSignature());
- }
- return assignTable[((Primitive) other).index][index];
- }
-
- @Override
- public final boolean isAssignableFrom(ResolvedType other, boolean allowMissing) {
- return isAssignableFrom(other);
- }
-
- @Override
- public final boolean isCoerceableFrom(ResolvedType other) {
- if (this == other) {
- return true;
- }
- if (!other.isPrimitiveType()) {
- return false;
- }
- if (index > 6 || ((Primitive) other).index > 6) {
- return false;
- }
- return true;
- }
-
- @Override
- public ResolvedType resolve(World world) {
- if (this.world != world) {
- throw new IllegalStateException();
- }
- this.world = world;
- return super.resolve(world);
- }
-
- @Override
- public final boolean needsNoConversionFrom(ResolvedType other) {
- if (!other.isPrimitiveType()) {
- return false;
- }
- return noConvertTable[((Primitive) other).index][index];
- }
-
- private static final boolean[][] assignTable = {// to: B C D F I J S V Z
- // from
- { true, true, true, true, true, true, true, false, false }, // B
- { false, true, true, true, true, true, false, false, false }, // C
- { false, false, true, false, false, false, false, false, false }, // D
- { false, false, true, true, false, false, false, false, false }, // F
- { false, false, true, true, true, true, false, false, false }, // I
- { false, false, true, true, false, true, false, false, false }, // J
- { false, false, true, true, true, true, true, false, false }, // S
- { false, false, false, false, false, false, false, true, false }, // V
- { false, false, false, false, false, false, false, false, true }, // Z
- };
- private static final boolean[][] noConvertTable = {// to: B C D F I J S
- // V Z from
- { true, true, false, false, true, false, true, false, false }, // B
- { false, true, false, false, true, false, false, false, false }, // C
- { false, false, true, false, false, false, false, false, false }, // D
- { false, false, false, true, false, false, false, false, false }, // F
- { false, false, false, false, true, false, false, false, false }, // I
- { false, false, false, false, false, true, false, false, false }, // J
- { false, false, false, false, true, false, true, false, false }, // S
- { false, false, false, false, false, false, false, true, false }, // V
- { false, false, false, false, false, false, false, false, true }, // Z
- };
-
- // ----
-
- @Override
- public final ResolvedMember[] getDeclaredFields() {
- return ResolvedMember.NONE;
- }
-
- @Override
- public final ResolvedMember[] getDeclaredMethods() {
- return ResolvedMember.NONE;
- }
-
- @Override
- public final ResolvedType[] getDeclaredInterfaces() {
- return ResolvedType.NONE;
- }
-
- @Override
- public final ResolvedMember[] getDeclaredPointcuts() {
- return ResolvedMember.NONE;
- }
-
- @Override
- public final ResolvedType getSuperclass() {
- return null;
- }
-
- @Override
- public ISourceContext getSourceContext() {
- return null;
- }
-
- }
-
- static class Missing extends ResolvedType {
- Missing() {
- super(MISSING_NAME, null);
- }
-
- // public final String toString() {
- // return "<missing>";
- // }
- @Override
- public final String getName() {
- return MISSING_NAME;
- }
-
- @Override
- public final boolean isMissing() {
- return true;
- }
-
- public boolean hasAnnotation(UnresolvedType ofType) {
- return false;
- }
-
- @Override
- public final ResolvedMember[] getDeclaredFields() {
- return ResolvedMember.NONE;
- }
-
- @Override
- public final ResolvedMember[] getDeclaredMethods() {
- return ResolvedMember.NONE;
- }
-
- @Override
- public final ResolvedType[] getDeclaredInterfaces() {
- return ResolvedType.NONE;
- }
-
- @Override
- public final ResolvedMember[] getDeclaredPointcuts() {
- return ResolvedMember.NONE;
- }
-
- @Override
- public final ResolvedType getSuperclass() {
- return null;
- }
-
- @Override
- public final int getModifiers() {
- return 0;
- }
-
- @Override
- public final boolean isAssignableFrom(ResolvedType other) {
- return false;
- }
-
- @Override
- public final boolean isAssignableFrom(ResolvedType other, boolean allowMissing) {
- return false;
- }
-
- @Override
- public final boolean isCoerceableFrom(ResolvedType other) {
- return false;
- }
-
- @Override
- public boolean needsNoConversionFrom(ResolvedType other) {
- return false;
- }
-
- @Override
- public ISourceContext getSourceContext() {
- return null;
- }
-
- }
-
- /**
- * Look up a member, takes into account any ITDs on this type. return null if not found
- */
- public ResolvedMember lookupMemberNoSupers(Member member) {
- ResolvedMember ret = lookupDirectlyDeclaredMemberNoSupers(member);
- if (ret == null && interTypeMungers != null) {
- for (ConcreteTypeMunger tm : interTypeMungers) {
- if (matches(tm.getSignature(), member)) {
- return tm.getSignature();
- }
- }
- }
- return ret;
- }
-
- public ResolvedMember lookupMemberWithSupersAndITDs(Member member) {
- ResolvedMember ret = lookupMemberNoSupers(member);
- if (ret != null) {
- return ret;
- }
-
- ResolvedType supert = getSuperclass();
- while (ret == null && supert != null) {
- ret = supert.lookupMemberNoSupers(member);
- if (ret == null) {
- supert = supert.getSuperclass();
- }
- }
-
- return ret;
- }
-
- /**
- * as lookupMemberNoSupers, but does not include ITDs
- *
- * @param member
- * @return
- */
- public ResolvedMember lookupDirectlyDeclaredMemberNoSupers(Member member) {
- ResolvedMember ret;
- if (member.getKind() == Member.FIELD) {
- ret = lookupMember(member, getDeclaredFields());
- } else {
- // assert member.getKind() == Member.METHOD || member.getKind() ==
- // Member.CONSTRUCTOR
- ret = lookupMember(member, getDeclaredMethods());
- }
- return ret;
- }
-
- /**
- * This lookup has specialized behaviour - a null result tells the EclipseTypeMunger that it should make a default
- * implementation of a method on this type.
- *
- * @param member
- * @return
- */
- public ResolvedMember lookupMemberIncludingITDsOnInterfaces(Member member) {
- return lookupMemberIncludingITDsOnInterfaces(member, this);
- }
-
- private ResolvedMember lookupMemberIncludingITDsOnInterfaces(Member member, ResolvedType onType) {
- ResolvedMember ret = onType.lookupMemberNoSupers(member);
- if (ret != null) {
- return ret;
- } else {
- ResolvedType superType = onType.getSuperclass();
- if (superType != null) {
- ret = lookupMemberIncludingITDsOnInterfaces(member, superType);
- }
- if (ret == null) {
- // try interfaces then, but only ITDs now...
- ResolvedType[] superInterfaces = onType.getDeclaredInterfaces();
- for (int i = 0; i < superInterfaces.length; i++) {
- ret = superInterfaces[i].lookupMethodInITDs(member);
- if (ret != null) {
- return ret;
- }
- }
- }
- }
- return ret;
- }
-
- protected List<ConcreteTypeMunger> interTypeMungers = new ArrayList<ConcreteTypeMunger>();
-
- public List<ConcreteTypeMunger> getInterTypeMungers() {
- return interTypeMungers;
- }
-
- public List<ConcreteTypeMunger> getInterTypeParentMungers() {
- List<ConcreteTypeMunger> l = new ArrayList<ConcreteTypeMunger>();
- for (ConcreteTypeMunger element : interTypeMungers) {
- if (element.getMunger() instanceof NewParentTypeMunger) {
- l.add(element);
- }
- }
- return l;
- }
-
- /**
- * ??? This method is O(N*M) where N = number of methods and M is number of inter-type declarations in my super
- */
- public List<ConcreteTypeMunger> getInterTypeMungersIncludingSupers() {
- ArrayList<ConcreteTypeMunger> ret = new ArrayList<ConcreteTypeMunger>();
- collectInterTypeMungers(ret);
- return ret;
- }
-
- public List<ConcreteTypeMunger> getInterTypeParentMungersIncludingSupers() {
- ArrayList<ConcreteTypeMunger> ret = new ArrayList<ConcreteTypeMunger>();
- collectInterTypeParentMungers(ret);
- return ret;
- }
-
- private void collectInterTypeParentMungers(List<ConcreteTypeMunger> collector) {
- for (Iterator<ResolvedType> iter = getDirectSupertypes(); iter.hasNext();) {
- ResolvedType superType = iter.next();
- superType.collectInterTypeParentMungers(collector);
- }
- collector.addAll(getInterTypeParentMungers());
- }
-
- protected void collectInterTypeMungers(List<ConcreteTypeMunger> collector) {
- for (Iterator<ResolvedType> iter = getDirectSupertypes(); iter.hasNext();) {
- ResolvedType superType = iter.next();
- if (superType == null) {
- throw new BCException("UnexpectedProblem: a supertype in the hierarchy for " + this.getName() + " is null");
- }
- superType.collectInterTypeMungers(collector);
- }
-
- outer: for (Iterator<ConcreteTypeMunger> iter1 = collector.iterator(); iter1.hasNext();) {
- ConcreteTypeMunger superMunger = iter1.next();
- if (superMunger.getSignature() == null) {
- continue;
- }
-
- if (!superMunger.getSignature().isAbstract()) {
- continue;
- }
-
- for (ConcreteTypeMunger myMunger : getInterTypeMungers()) {
- if (conflictingSignature(myMunger.getSignature(), superMunger.getSignature())) {
- iter1.remove();
- continue outer;
- }
- }
-
- if (!superMunger.getSignature().isPublic()) {
- continue;
- }
-
- for (Iterator<ResolvedMember> iter = getMethods(true, true); iter.hasNext();) {
- ResolvedMember method = iter.next();
- if (conflictingSignature(method, superMunger.getSignature())) {
- iter1.remove();
- continue outer;
- }
- }
- }
-
- collector.addAll(getInterTypeMungers());
- }
-
- /**
- * Check: 1) That we don't have any abstract type mungers unless this type is abstract. 2) That an abstract ITDM on an interface
- * is declared public. (Compiler limitation) (PR70794)
- */
- public void checkInterTypeMungers() {
- if (isAbstract()) {
- return;
- }
-
- boolean itdProblem = false;
-
- for (ConcreteTypeMunger munger : getInterTypeMungersIncludingSupers()) {
- itdProblem = checkAbstractDeclaration(munger) || itdProblem; // Rule 2
- }
-
- if (itdProblem) {
- return; // If the rules above are broken, return right now
- }
-
- for (ConcreteTypeMunger munger : getInterTypeMungersIncludingSupers()) {
- if (munger.getSignature() != null && munger.getSignature().isAbstract() && munger.getMunger().getKind()!=ResolvedTypeMunger.PrivilegedAccess) { // Rule 1
- if (munger.getMunger().getKind() == ResolvedTypeMunger.MethodDelegate2) {
- // ignore for @AJ ITD as munger.getSignature() is the
- // interface method hence abstract
- } else {
- world.getMessageHandler()
- .handleMessage(
- new Message("must implement abstract inter-type declaration: " + munger.getSignature(), "",
- IMessage.ERROR, getSourceLocation(), null,
- new ISourceLocation[] { getMungerLocation(munger) }));
- }
- }
- }
- }
-
- /**
- * See PR70794. This method checks that if an abstract inter-type method declaration is made on an interface then it must also
- * be public. This is a compiler limitation that could be made to work in the future (if someone provides a worthwhile usecase)
- *
- * @return indicates if the munger failed the check
- */
- private boolean checkAbstractDeclaration(ConcreteTypeMunger munger) {
- if (munger.getMunger() != null && (munger.getMunger() instanceof NewMethodTypeMunger)) {
- ResolvedMember itdMember = munger.getSignature();
- ResolvedType onType = itdMember.getDeclaringType().resolve(world);
- if (onType.isInterface() && itdMember.isAbstract() && !itdMember.isPublic()) {
- world.getMessageHandler().handleMessage(
- new Message(WeaverMessages.format(WeaverMessages.ITD_ABSTRACT_MUST_BE_PUBLIC_ON_INTERFACE,
- munger.getSignature(), onType), "", Message.ERROR, getSourceLocation(), null,
- new ISourceLocation[] { getMungerLocation(munger) }));
- return true;
- }
- }
- return false;
- }
-
- /**
- * Get a source location for the munger. Until intertype mungers remember where they came from, the source location for the
- * munger itself is null. In these cases use the source location for the aspect containing the ITD.
- */
- private ISourceLocation getMungerLocation(ConcreteTypeMunger munger) {
- ISourceLocation sloc = munger.getSourceLocation();
- if (sloc == null) {
- sloc = munger.getAspectType().getSourceLocation();
- }
- return sloc;
- }
-
- /**
- * Returns a ResolvedType object representing the declaring type of this type, or null if this type does not represent a
- * non-package-level-type.
- * <p/>
- * <strong>Warning</strong>: This is guaranteed to work for all member types. For anonymous/local types, the only guarantee is
- * given in JLS 13.1, where it guarantees that if you call getDeclaringType() repeatedly, you will eventually get the top-level
- * class, but it does not say anything about classes in between.
- *
- * @return the declaring type, or null if it is not an nested type.
- */
- public ResolvedType getDeclaringType() {
- if (isArray()) {
- return null;
- }
- if (isNested() || isAnonymous()) {
- return getOuterClass();
- }
- return null;
- }
-
- public static boolean isVisible(int modifiers, ResolvedType targetType, ResolvedType fromType) {
- // System.err.println("mod: " + modifiers + ", " + targetType + " and "
- // + fromType);
-
- if (Modifier.isPublic(modifiers)) {
- return true;
- } else if (Modifier.isPrivate(modifiers)) {
- return targetType.getOutermostType().equals(fromType.getOutermostType());
- } else if (Modifier.isProtected(modifiers)) {
- return samePackage(targetType, fromType) || targetType.isAssignableFrom(fromType);
- } else { // package-visible
- return samePackage(targetType, fromType);
- }
- }
-
- private static boolean samePackage(ResolvedType targetType, ResolvedType fromType) {
- String p1 = targetType.getPackageName();
- String p2 = fromType.getPackageName();
- if (p1 == null) {
- return p2 == null;
- }
- if (p2 == null) {
- return false;
- }
- return p1.equals(p2);
- }
-
- /**
- * Checks if the generic type for 'this' and the generic type for 'other' are the same - it can be passed raw or parameterized
- * versions and will just compare the underlying generic type.
- */
- private boolean genericTypeEquals(ResolvedType other) {
- ResolvedType rt = other;
- if (rt.isParameterizedType() || rt.isRawType()) {
- rt.getGenericType();
- }
- if (((isParameterizedType() || isRawType()) && getGenericType().equals(rt)) || (this.equals(other))) {
- return true;
- }
- return false;
- }
-
- /**
- * Look up the actual occurence of a particular type in the hierarchy for 'this' type. The input is going to be a generic type,
- * and the caller wants to know if it was used in its RAW or a PARAMETERIZED form in this hierarchy.
- *
- * returns null if it can't be found.
- */
- public ResolvedType discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor) {
- if (!lookingFor.isGenericType()) {
- throw new BCException("assertion failed: method should only be called with generic type, but " + lookingFor + " is "
- + lookingFor.typeKind);
- }
-
- if (this.equals(ResolvedType.OBJECT)) {
- return null;
- }
-
- if (genericTypeEquals(lookingFor)) {
- return this;
- }
-
- ResolvedType superT = getSuperclass();
- if (superT.genericTypeEquals(lookingFor)) {
- return superT;
- }
-
- ResolvedType[] superIs = getDeclaredInterfaces();
- for (int i = 0; i < superIs.length; i++) {
- ResolvedType superI = superIs[i];
- if (superI.genericTypeEquals(lookingFor)) {
- return superI;
- }
- ResolvedType checkTheSuperI = superI.discoverActualOccurrenceOfTypeInHierarchy(lookingFor);
- if (checkTheSuperI != null) {
- return checkTheSuperI;
- }
- }
- return superT.discoverActualOccurrenceOfTypeInHierarchy(lookingFor);
- }
-
- /**
- * Called for all type mungers but only does something if they share type variables with a generic type which they target. When
- * this happens this routine will check for the target type in the target hierarchy and 'bind' any type parameters as
- * appropriate. For example, for the ITD "List<T> I<T>.x" against a type like this: "class A implements I<String>" this routine
- * will return a parameterized form of the ITD "List<String> I.x"
- */
- public ConcreteTypeMunger fillInAnyTypeParameters(ConcreteTypeMunger munger) {
- boolean debug = false;
- ResolvedMember member = munger.getSignature();
- if (munger.isTargetTypeParameterized()) {
- if (debug) {
- System.err.println("Processing attempted parameterization of " + munger + " targetting type " + this);
- }
- if (debug) {
- System.err.println(" This type is " + this + " (" + typeKind + ")");
- }
- // need to tailor this munger instance for the particular target...
- if (debug) {
- System.err.println(" Signature that needs parameterizing: " + member);
- }
- // Retrieve the generic type
- ResolvedType onTypeResolved = world.resolve(member.getDeclaringType());
- ResolvedType onType = onTypeResolved.getGenericType();
- if (onType == null) {
- // The target is not generic
- getWorld().getMessageHandler().handleMessage(
- MessageUtil.error("The target type for the intertype declaration is not generic",
- munger.getSourceLocation()));
- return munger;
- }
- member.resolve(world); // Ensure all parts of the member are resolved
- if (debug) {
- System.err.println(" Actual target ontype: " + onType + " (" + onType.typeKind + ")");
- }
- // quickly find the targettype in the type hierarchy for this type
- // (it will be either RAW or PARAMETERIZED)
- ResolvedType actualTarget = discoverActualOccurrenceOfTypeInHierarchy(onType);
- if (actualTarget == null) {
- throw new BCException("assertion failed: asked " + this + " for occurrence of " + onType + " in its hierarchy??");
- }
-
- // only bind the tvars if its a parameterized type or the raw type
- // (in which case they collapse to bounds) - don't do it
- // for generic types ;)
- if (!actualTarget.isGenericType()) {
- if (debug) {
- System.err.println("Occurrence in " + this + " is actually " + actualTarget + " (" + actualTarget.typeKind
- + ")");
- // parameterize the signature
- // ResolvedMember newOne =
- // member.parameterizedWith(actualTarget.getTypeParameters(),
- // onType,actualTarget.isParameterizedType());
- }
- }
- // if (!actualTarget.isRawType())
- munger = munger.parameterizedFor(actualTarget);
- if (debug) {
- System.err.println("New sig: " + munger.getSignature());
- }
-
- if (debug) {
- System.err.println("=====================================");
- }
- }
- return munger;
- }
-
- /**
- * Add an intertype munger to this type. isDuringCompilation tells us if we should be checking for an error scenario where two
- * ITD fields are trying to use the same name. When this happens during compilation one of them is altered to get mangled name
- * but when it happens during weaving it is too late and we need to put out an error asking them to recompile.
- */
- public void addInterTypeMunger(ConcreteTypeMunger munger, boolean isDuringCompilation) {
- ResolvedMember sig = munger.getSignature();
- bits = (bits & ~MungersAnalyzed); // clear the bit - as the mungers have changed
- if (sig == null || munger.getMunger() == null || munger.getMunger().getKind() == ResolvedTypeMunger.PrivilegedAccess) {
- interTypeMungers.add(munger);
- return;
- }
-
- // ConcreteTypeMunger originalMunger = munger;
- // we will use the 'parameterized' ITD for all the comparisons but we
- // say the original
- // one passed in actually matched as it will be added to the intertype
- // member finder
- // for the target type. It is possible we only want to do this if a
- // generic type
- // is discovered and the tvar is collapsed to a bound?
- munger = fillInAnyTypeParameters(munger);
- sig = munger.getSignature(); // possibly changed when type parms filled in
-
- if (sig.getKind() == Member.METHOD) {
- // OPTIMIZE can this be sped up?
- if (clashesWithExistingMember(munger, getMethods(true, false))) { // ITDs checked below
- return;
- }
- if (this.isInterface()) {
- // OPTIMIZE this set of methods are always the same - must we keep creating them as a list?
- if (clashesWithExistingMember(munger, Arrays.asList(world.getCoreType(OBJECT).getDeclaredMethods()).iterator())) {
- return;
- }
- }
- } else if (sig.getKind() == Member.FIELD) {
- if (clashesWithExistingMember(munger, Arrays.asList(getDeclaredFields()).iterator())) {
- return;
- }
- // Cannot cope with two version '2' style mungers for the same field on the same type
- // Must error and request the user recompile at least one aspect with the
- // -Xset:itdStyle=1 option
- if (!isDuringCompilation) {
- ResolvedTypeMunger thisRealMunger = munger.getMunger();
- if (thisRealMunger instanceof NewFieldTypeMunger) {
- NewFieldTypeMunger newFieldTypeMunger = (NewFieldTypeMunger) thisRealMunger;
- if (newFieldTypeMunger.version == NewFieldTypeMunger.VersionTwo) {
- String thisRealMungerSignatureName = newFieldTypeMunger.getSignature().getName();
- for (ConcreteTypeMunger typeMunger : interTypeMungers) {
- if (typeMunger.getMunger() instanceof NewFieldTypeMunger) {
- if (typeMunger.getSignature().getKind() == Member.FIELD) {
- NewFieldTypeMunger existing = (NewFieldTypeMunger) typeMunger.getMunger();
- if (existing.getSignature().getName().equals(thisRealMungerSignatureName)
- && existing.version == NewFieldTypeMunger.VersionTwo
- // this check ensures no problem for a clash with an ITD on an interface
- && existing.getSignature().getDeclaringType()
- .equals(newFieldTypeMunger.getSignature().getDeclaringType())) {
-
- // report error on the aspect
- StringBuffer sb = new StringBuffer();
- sb.append("Cannot handle two aspects both attempting to use new style ITDs for the same named field ");
- sb.append("on the same target type. Please recompile at least one aspect with '-Xset:itdVersion=1'.");
- sb.append(" Aspects involved: " + munger.getAspectType().getName() + " and "
- + typeMunger.getAspectType().getName() + ".");
- sb.append(" Field is named '" + existing.getSignature().getName() + "'");
- getWorld().getMessageHandler().handleMessage(
- new Message(sb.toString(), getSourceLocation(), true));
- return;
- }
- }
- }
- }
- }
- }
- }
- } else {
- if (clashesWithExistingMember(munger, Arrays.asList(getDeclaredMethods()).iterator())) {
- return;
- }
- }
-
- boolean needsAdding =true;
- boolean needsToBeAddedEarlier =false;
- // now compare to existingMungers
- for (Iterator<ConcreteTypeMunger> i = interTypeMungers.iterator(); i.hasNext();) {
- ConcreteTypeMunger existingMunger = i.next();
- boolean v2itds = munger.getSignature().getKind()== Member.FIELD && (munger.getMunger() instanceof NewFieldTypeMunger) && ((NewFieldTypeMunger)munger.getMunger()).version==NewFieldTypeMunger.VersionTwo;
-
- if (conflictingSignature(existingMunger.getSignature(), munger.getSignature(),v2itds)) {
- // System.err.println("match " + munger + " with " + existingMunger);
- if (isVisible(munger.getSignature().getModifiers(), munger.getAspectType(), existingMunger.getAspectType())) {
- // System.err.println(" is visible");
- int c = compareMemberPrecedence(sig, existingMunger.getSignature());
- if (c == 0) {
- c = getWorld().compareByPrecedenceAndHierarchy(munger.getAspectType(), existingMunger.getAspectType());
- }
- // System.err.println(" compare: " + c);
- if (c < 0) {
- // the existing munger dominates the new munger
- checkLegalOverride(munger.getSignature(), existingMunger.getSignature(), 0x11, null);
- needsAdding = false;
- if (munger.getSignature().getKind()== Member.FIELD && munger.getSignature().getDeclaringType().resolve(world).isInterface() && ((NewFieldTypeMunger)munger.getMunger()).version==NewFieldTypeMunger.VersionTwo) {
- // still need to add it
- needsAdding=true;
- }
- break;
- } else if (c > 0) {
- // the new munger dominates the existing one
- checkLegalOverride(existingMunger.getSignature(), munger.getSignature(), 0x11, null);
- // i.remove();
- if (existingMunger.getSignature().getKind()==Member.FIELD &&
- existingMunger.getSignature().getDeclaringType().resolve(world).isInterface()
- && ((NewFieldTypeMunger)existingMunger.getMunger()).version==NewFieldTypeMunger.VersionTwo) {
- needsToBeAddedEarlier=true;
- } else {
- i.remove();
- }
- break;
- } else {
- interTypeConflictError(munger, existingMunger);
- interTypeConflictError(existingMunger, munger);
- return;
- }
- }
- }
- }
- // System.err.println("adding: " + munger + " to " + this);
- // we are adding the parameterized form of the ITD to the list of
- // mungers. Within it, the munger knows the original declared
- // signature for the ITD so it can be retrieved.
- if (needsAdding) {
- if (!needsToBeAddedEarlier) {
- interTypeMungers.add(munger);
- } else {
- interTypeMungers.add(0,munger);
- }
- }
- }
-
- /**
- * Compare the type transformer with the existing members. A clash may not be an error (the ITD may be the 'default
- * implementation') so returning false is not always a sign of an error.
- *
- * @return true if there is a clash
- */
- private boolean clashesWithExistingMember(ConcreteTypeMunger typeTransformer, Iterator<ResolvedMember> existingMembers) {
- ResolvedMember typeTransformerSignature = typeTransformer.getSignature();
-
- // ResolvedType declaringAspectType = munger.getAspectType();
- // if (declaringAspectType.isRawType()) declaringAspectType =
- // declaringAspectType.getGenericType();
- // if (declaringAspectType.isGenericType()) {
- //
- // ResolvedType genericOnType =
- // getWorld().resolve(sig.getDeclaringType()).getGenericType();
- // ConcreteTypeMunger ctm =
- // munger.parameterizedFor(discoverActualOccurrenceOfTypeInHierarchy
- // (genericOnType));
- // sig = ctm.getSignature(); // possible sig change when type
- // }
- // if (munger.getMunger().hasTypeVariableAliases()) {
- // ResolvedType genericOnType =
- // getWorld().resolve(sig.getDeclaringType()).getGenericType();
- // ConcreteTypeMunger ctm =
- // munger.parameterizedFor(discoverActualOccurrenceOfTypeInHierarchy(
- // genericOnType));
- // sig = ctm.getSignature(); // possible sig change when type parameters
- // filled in
- // }
- ResolvedTypeMunger rtm = typeTransformer.getMunger();
- boolean v2itds = true;
- if (rtm instanceof NewFieldTypeMunger && ((NewFieldTypeMunger)rtm).version==NewFieldTypeMunger.VersionOne) {
- v2itds = false;
- }
- while (existingMembers.hasNext()) {
- ResolvedMember existingMember = existingMembers.next();
- // don't worry about clashing with bridge methods
- if (existingMember.isBridgeMethod()) {
- continue;
- }
- if (conflictingSignature(existingMember, typeTransformerSignature,v2itds)) {
- // System.err.println("conflict: existingMember=" +
- // existingMember + " typeMunger=" + munger);
- // System.err.println(munger.getSourceLocation() + ", " +
- // munger.getSignature() + ", " +
- // munger.getSignature().getSourceLocation());
-
- if (isVisible(existingMember.getModifiers(), this, typeTransformer.getAspectType())) {
- int c = compareMemberPrecedence(typeTransformerSignature, existingMember);
- // System.err.println(" c: " + c);
- if (c < 0) {
- ResolvedType typeTransformerTargetType = typeTransformerSignature.getDeclaringType().resolve(world);
- if (typeTransformerTargetType.isInterface()) {
- ResolvedType existingMemberType = existingMember.getDeclaringType().resolve(world);
- if ((rtm instanceof NewMethodTypeMunger) && !typeTransformerTargetType.equals(existingMemberType)) {
- // Might be pr404601. ITD is on an interface with a different visibility to the real member
- if (Modifier.isPrivate(typeTransformerSignature.getModifiers()) &&
- Modifier.isPublic(existingMember.getModifiers())) {
- world.getMessageHandler().handleMessage(new Message("private intertype declaration '"+typeTransformerSignature.toString()+"' clashes with public member '"+existingMember.toString()+"'",existingMember.getSourceLocation(),true));
- }
- }
- }
- // existingMember dominates munger
- checkLegalOverride(typeTransformerSignature, existingMember, 0x10, typeTransformer.getAspectType());
- return true;
- } else if (c > 0) {
- // munger dominates existingMember
- checkLegalOverride(existingMember, typeTransformerSignature, 0x01, typeTransformer.getAspectType());
- // interTypeMungers.add(munger);
- // ??? might need list of these overridden abstracts
- continue;
- } else {
- // bridge methods can differ solely in return type.
- // FIXME this whole method seems very hokey - unaware of covariance/varargs/bridging - it
- // could do with a rewrite !
- boolean sameReturnTypes = (existingMember.getReturnType().equals(typeTransformerSignature.getReturnType()));
- if (sameReturnTypes) {
- // pr206732 - if the existingMember is due to a
- // previous application of this same ITD (which can
- // happen if this is a binary type being brought in
- // from the aspectpath). The 'better' fix is
- // to recognize it is from the aspectpath at a
- // higher level and dont do this, but that is rather
- // more work.
- boolean isDuplicateOfPreviousITD = false;
- ResolvedType declaringRt = existingMember.getDeclaringType().resolve(world);
- WeaverStateInfo wsi = declaringRt.getWeaverState();
- if (wsi != null) {
- List<ConcreteTypeMunger> mungersAffectingThisType = wsi.getTypeMungers(declaringRt);
- if (mungersAffectingThisType != null) {
- for (Iterator<ConcreteTypeMunger> iterator = mungersAffectingThisType.iterator(); iterator
- .hasNext() && !isDuplicateOfPreviousITD;) {
- ConcreteTypeMunger ctMunger = iterator.next();
- // relatively crude check - is the ITD
- // for the same as the existingmember
- // and does it come
- // from the same aspect
- if (ctMunger.getSignature().equals(existingMember)
- && ctMunger.aspectType.equals(typeTransformer.getAspectType())) {
- isDuplicateOfPreviousITD = true;
- }
- }
- }
- }
- if (!isDuplicateOfPreviousITD) {
- // b275032 - this is OK if it is the default ctor and that default ctor was generated
- // at compile time, otherwise we cannot overwrite it
- if (!(typeTransformerSignature.getName().equals("<init>") && existingMember.isDefaultConstructor())) {
- String aspectName = typeTransformer.getAspectType().getName();
- ISourceLocation typeTransformerLocation = typeTransformer.getSourceLocation();
- ISourceLocation existingMemberLocation = existingMember.getSourceLocation();
- String msg = WeaverMessages.format(WeaverMessages.ITD_MEMBER_CONFLICT, aspectName,
- existingMember);
-
- // this isn't quite right really... as I think the errors should only be recorded against
- // what is currently being processed or they may get lost or reported twice
-
- // report error on the aspect
- getWorld().getMessageHandler().handleMessage(new Message(msg, typeTransformerLocation, true));
-
- // report error on the affected type, if we can
- if (existingMemberLocation != null) {
- getWorld().getMessageHandler()
- .handleMessage(new Message(msg, existingMemberLocation, true));
- }
- return true; // clash - so ignore this itd
- }
- }
- }
- }
- } else if (isDuplicateMemberWithinTargetType(existingMember, this, typeTransformerSignature)) {
- getWorld().getMessageHandler().handleMessage(
- MessageUtil.error(WeaverMessages.format(WeaverMessages.ITD_MEMBER_CONFLICT, typeTransformer
- .getAspectType().getName(), existingMember), typeTransformer.getSourceLocation()));
- return true;
- }
- }
- }
- return false;
- }
-
- // we know that the member signature matches, but that the member in the
- // target type is not visible to the aspect.
- // this may still be disallowed if it would result in two members within the
- // same declaring type with the same
- // signature AND more than one of them is concrete AND they are both visible
- // within the target type.
- private boolean isDuplicateMemberWithinTargetType(ResolvedMember existingMember, ResolvedType targetType,
- ResolvedMember itdMember) {
- if ((existingMember.isAbstract() || itdMember.isAbstract())) {
- return false;
- }
- UnresolvedType declaringType = existingMember.getDeclaringType();
- if (!targetType.equals(declaringType)) {
- return false;
- }
- // now have to test that itdMember is visible from targetType
- if (Modifier.isPrivate(itdMember.getModifiers())) {
- return false;
- }
- if (itdMember.isPublic()) {
- return true;
- }
- // must be in same package to be visible then...
- if (!targetType.getPackageName().equals(itdMember.getDeclaringType().getPackageName())) {
- return false;
- }
-
- // trying to put two members with the same signature into the exact same
- // type..., and both visible in that type.
- return true;
- }
-
- /**
- * @param transformerPosition which parameter is the type transformer (0x10 for first, 0x01 for second, 0x11 for both, 0x00 for
- * neither)
- * @param aspectType the declaring type of aspect defining the *first* type transformer
- * @return true if the override is legal note: calling showMessage with two locations issues TWO messages, not ONE message with
- * an additional source location.
- */
- public boolean checkLegalOverride(ResolvedMember parent, ResolvedMember child, int transformerPosition, ResolvedType aspectType) {
- // System.err.println("check: " + child.getDeclaringType() + " overrides " + parent.getDeclaringType());
- if (Modifier.isFinal(parent.getModifiers())) {
- // If the ITD matching is occurring due to pulling in a BinaryTypeBinding then this check can incorrectly
- // signal an error because the ITD transformer being examined here will exactly match the member it added
- // during the first round of compilation. This situation can only occur if the ITD is on an interface whilst
- // the class is the top most implementor. If the ITD is on the same type that received it during compilation,
- // this method won't be called as the previous check for precedence level will return 0.
-
- if (transformerPosition == 0x10 && aspectType != null) {
- ResolvedType nonItdDeclaringType = child.getDeclaringType().resolve(world);
- WeaverStateInfo wsi = nonItdDeclaringType.getWeaverState();
- if (wsi != null) {
- List<ConcreteTypeMunger> transformersOnThisType = wsi.getTypeMungers(nonItdDeclaringType);
- if (transformersOnThisType != null) {
- for (ConcreteTypeMunger transformer : transformersOnThisType) {
- // relatively crude check - is the ITD for the same as the existingmember
- // and does it come from the same aspect
- if (transformer.aspectType.equals(aspectType)) {
- if (parent.equalsApartFromDeclaringType(transformer.getSignature())) {
- return true;
- }
- }
- }
- }
- }
- }
-
- world.showMessage(Message.ERROR, WeaverMessages.format(WeaverMessages.CANT_OVERRIDE_FINAL_MEMBER, parent),
- child.getSourceLocation(), null);
- return false;
- }
-
- boolean incompatibleReturnTypes = false;
- // In 1.5 mode, allow for covariance on return type
- if (world.isInJava5Mode() && parent.getKind() == Member.METHOD) {
-
- // Look at the generic types when doing this comparison
- ResolvedType rtParentReturnType = parent.resolve(world).getGenericReturnType().resolve(world);
- ResolvedType rtChildReturnType = child.resolve(world).getGenericReturnType().resolve(world);
- incompatibleReturnTypes = !rtParentReturnType.isAssignableFrom(rtChildReturnType);
- // For debug, uncomment this bit and we'll repeat the check - stick
- // a breakpoint on the call
- // if (incompatibleReturnTypes) {
- // incompatibleReturnTypes =
- // !rtParentReturnType.isAssignableFrom(rtChildReturnType);
- // }
- } else {
- ResolvedType rtParentReturnType = parent.resolve(world).getGenericReturnType().resolve(world);
- ResolvedType rtChildReturnType = child.resolve(world).getGenericReturnType().resolve(world);
-
- incompatibleReturnTypes = !rtParentReturnType.equals(rtChildReturnType);
- }
-
- if (incompatibleReturnTypes) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_RETURN_TYPE_MISMATCH, parent, child),
- child.getSourceLocation(), parent.getSourceLocation());
- return false;
- }
- if (parent.getKind() == Member.POINTCUT) {
- UnresolvedType[] pTypes = parent.getParameterTypes();
- UnresolvedType[] cTypes = child.getParameterTypes();
- if (!Arrays.equals(pTypes, cTypes)) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_PARAM_TYPE_MISMATCH, parent, child),
- child.getSourceLocation(), parent.getSourceLocation());
- return false;
- }
- }
- // System.err.println("check: " + child.getModifiers() +
- // " more visible " + parent.getModifiers());
- if (isMoreVisible(parent.getModifiers(), child.getModifiers())) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_VISIBILITY_REDUCTION, parent, child),
- child.getSourceLocation(), parent.getSourceLocation());
- return false;
- }
-
- // check declared exceptions
- ResolvedType[] childExceptions = world.resolve(child.getExceptions());
- ResolvedType[] parentExceptions = world.resolve(parent.getExceptions());
- ResolvedType runtimeException = world.resolve("java.lang.RuntimeException");
- ResolvedType error = world.resolve("java.lang.Error");
-
- outer: for (int i = 0, leni = childExceptions.length; i < leni; i++) {
- // System.err.println("checking: " + childExceptions[i]);
- if (runtimeException.isAssignableFrom(childExceptions[i])) {
- continue;
- }
- if (error.isAssignableFrom(childExceptions[i])) {
- continue;
- }
-
- for (int j = 0, lenj = parentExceptions.length; j < lenj; j++) {
- if (parentExceptions[j].isAssignableFrom(childExceptions[i])) {
- continue outer;
- }
- }
-
- // this message is now better handled my MethodVerifier in JDT core.
- // world.showMessage(IMessage.ERROR,
- // WeaverMessages.format(WeaverMessages.ITD_DOESNT_THROW,
- // childExceptions[i].getName()),
- // child.getSourceLocation(), null);
-
- return false;
- }
- boolean parentStatic = Modifier.isStatic(parent.getModifiers());
- boolean childStatic = Modifier.isStatic(child.getModifiers());
- if (parentStatic && !childStatic) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_OVERRIDDEN_STATIC, child, parent),
- child.getSourceLocation(), null);
- return false;
- } else if (childStatic && !parentStatic) {
- world.showMessage(IMessage.ERROR, WeaverMessages.format(WeaverMessages.ITD_OVERIDDING_STATIC, child, parent),
- child.getSourceLocation(), null);
- return false;
- }
- return true;
-
- }
-
- private int compareMemberPrecedence(ResolvedMember m1, ResolvedMember m2) {
- // if (!m1.getReturnType().equals(m2.getReturnType())) return 0;
-
- // need to allow for the special case of 'clone' - which is like
- // abstract but is
- // not marked abstract. The code below this next line seems to make
- // assumptions
- // about what will have gotten through the compiler based on the normal
- // java rules. clone goes against these...
- if (Modifier.isProtected(m2.getModifiers()) && m2.getName().charAt(0) == 'c') {
- UnresolvedType declaring = m2.getDeclaringType();
- if (declaring != null) {
- if (declaring.getName().equals("java.lang.Object") && m2.getName().equals("clone")) {
- return +1;
- }
- }
- }
-
- if (Modifier.isAbstract(m1.getModifiers())) {
- return -1;
- }
- if (Modifier.isAbstract(m2.getModifiers())) {
- return +1;
- }
-
- if (m1.getDeclaringType().equals(m2.getDeclaringType())) {
- return 0;
- }
-
- ResolvedType t1 = m1.getDeclaringType().resolve(world);
- ResolvedType t2 = m2.getDeclaringType().resolve(world);
- if (t1.isAssignableFrom(t2)) {
- return -1;
- }
- if (t2.isAssignableFrom(t1)) {
- return +1;
- }
- return 0;
- }
-
- public static boolean isMoreVisible(int m1, int m2) {
- if (Modifier.isPrivate(m1)) {
- return false;
- }
- if (isPackage(m1)) {
- return Modifier.isPrivate(m2);
- }
- if (Modifier.isProtected(m1)) {
- return /* private package */(Modifier.isPrivate(m2) || isPackage(m2));
- }
- if (Modifier.isPublic(m1)) {
- return /* private package protected */!Modifier.isPublic(m2);
- }
- throw new RuntimeException("bad modifier: " + m1);
- }
-
- private static boolean isPackage(int i) {
- return (0 == (i & (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED)));
- }
-
- private void interTypeConflictError(ConcreteTypeMunger m1, ConcreteTypeMunger m2) {
- // XXX this works only if we ignore separate compilation issues
- // XXX dual errors possible if (this instanceof BcelObjectType) return;
- /*
- * if (m1.getMunger().getKind() == ResolvedTypeMunger.Field && m2.getMunger().getKind() == ResolvedTypeMunger.Field) { // if
- * *exactly* the same, it's ok return true; }
- */
- // System.err.println("conflict at " + m2.getSourceLocation());
- getWorld().showMessage(
- IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.ITD_CONFLICT, m1.getAspectType().getName(), m2.getSignature(), m2
- .getAspectType().getName()), m2.getSourceLocation(), getSourceLocation());
- // return false;
- }
-
- public ResolvedMember lookupSyntheticMember(Member member) {
- // ??? horribly inefficient
- // for (Iterator i =
- // System.err.println("lookup " + member + " in " + interTypeMungers);
- for (ConcreteTypeMunger m : interTypeMungers) {
- ResolvedMember ret = m.getMatchingSyntheticMember(member);
- if (ret != null) {
- // System.err.println(" found: " + ret);
- return ret;
- }
- }
-
- // Handling members for the new array join point
- if (world.isJoinpointArrayConstructionEnabled() && this.isArray()) {
- if (member.getKind() == Member.CONSTRUCTOR) {
- ResolvedMemberImpl ret = new ResolvedMemberImpl(Member.CONSTRUCTOR, this, Modifier.PUBLIC, UnresolvedType.VOID,
- "<init>", world.resolve(member.getParameterTypes()));
- // Give the parameters names - they are going to be the dimensions uses to build the array (dim0 > dimN)
- int count = ret.getParameterTypes().length;
- String[] paramNames = new String[count];
- for (int i = 0; i < count; i++) {
- paramNames[i] = new StringBuffer("dim").append(i).toString();
- }
- ret.setParameterNames(paramNames);
- return ret;
- }
- }
-
- // if (this.getSuperclass() != ResolvedType.OBJECT &&
- // this.getSuperclass() != null) {
- // return getSuperclass().lookupSyntheticMember(member);
- // }
-
- return null;
- }
-
- static class SuperClassWalker implements Iterator<ResolvedType> {
-
- private ResolvedType curr;
- private SuperInterfaceWalker iwalker;
- private boolean wantGenerics;
-
- public SuperClassWalker(ResolvedType type, SuperInterfaceWalker iwalker, boolean genericsAware) {
- this.curr = type;
- this.iwalker = iwalker;
- this.wantGenerics = genericsAware;
- }
-
- public boolean hasNext() {
- return curr != null;
- }
-
- public ResolvedType next() {
- ResolvedType ret = curr;
- if (!wantGenerics && ret.isParameterizedOrGenericType()) {
- ret = ret.getRawType();
- }
- iwalker.push(ret); // tell the interface walker about another class whose interfaces need visiting
- curr = curr.getSuperclass();
- return ret;
- }
-
- public void remove() {
- throw new UnsupportedOperationException();
- }
- }
-
- static class SuperInterfaceWalker implements Iterator<ResolvedType> {
-
- private Getter<ResolvedType, ResolvedType> ifaceGetter;
- Iterator<ResolvedType> delegate = null;
- public Queue<ResolvedType> toPersue = new LinkedList<ResolvedType>();
- public Set<ResolvedType> visited = new HashSet<ResolvedType>();
-
- SuperInterfaceWalker(Iterators.Getter<ResolvedType, ResolvedType> ifaceGetter) {
- this.ifaceGetter = ifaceGetter;
- }
-
- SuperInterfaceWalker(Iterators.Getter<ResolvedType, ResolvedType> ifaceGetter, ResolvedType interfaceType) {
- this.ifaceGetter = ifaceGetter;
- this.delegate = Iterators.one(interfaceType);
- }
-
- public boolean hasNext() {
- if (delegate == null || !delegate.hasNext()) {
- // either we set it up or we have run out, is there anything else to look at?
- if (toPersue.isEmpty()) {
- return false;
- }
- do {
- ResolvedType next = toPersue.remove();
- visited.add(next);
- delegate = ifaceGetter.get(next); // retrieve interfaces from a class or another interface
- } while (!delegate.hasNext() && !toPersue.isEmpty());
- }
- return delegate.hasNext();
- }
-
- public void push(ResolvedType ret) {
- toPersue.add(ret);
- }
-
- public ResolvedType next() {
- ResolvedType next = delegate.next();
- // BUG should check for generics and erase?
- // if (!visited.contains(next)) {
- // visited.add(next);
- if (visited.add(next)) {
- toPersue.add(next); // pushes on interfaces already visited?
- }
- return next;
- }
-
- public void remove() {
- throw new UnsupportedOperationException();
- }
- }
-
- public void clearInterTypeMungers() {
- if (isRawType()) {
- ResolvedType genericType = getGenericType();
- if (genericType.isRawType()) { // ERROR SITUATION: PR341926
- // For some reason the raw type is pointing to another raw form (possibly itself)
- System.err.println("DebugFor341926: Type " + this.getName() + " has an incorrect generic form");
- } else {
- genericType.clearInterTypeMungers();
- }
- }
- // interTypeMungers.clear();
- // BUG? Why can't this be clear() instead: 293620 c6
- interTypeMungers = new ArrayList<ConcreteTypeMunger>();
- }
-
- public boolean isTopmostImplementor(ResolvedType interfaceType) {
- boolean b = true;
- if (isInterface()) {
- b = false;
- } else if (!interfaceType.isAssignableFrom(this, true)) {
- b = false;
- } else {
- ResolvedType superclass = this.getSuperclass();
- if (superclass.isMissing()) {
- b = true; // we don't know anything about supertype, and it can't be exposed to weaver
- } else if (interfaceType.isAssignableFrom(superclass, true)) { // check that I'm truly the topmost implementor
- b = false;
- }
- }
- // System.out.println("is " + getName() + " topmostimplementor of " + interfaceType + "? " + b);
- return b;
- }
-
- public ResolvedType getTopmostImplementor(ResolvedType interfaceType) {
- if (isInterface()) {
- return null;
- }
- if (!interfaceType.isAssignableFrom(this)) {
- return null;
- }
- // Check if my super class is an implementor?
- ResolvedType higherType = this.getSuperclass().getTopmostImplementor(interfaceType);
- if (higherType != null) {
- return higherType;
- }
- return this;
- }
-
- public List<ResolvedMember> getExposedPointcuts() {
- List<ResolvedMember> ret = new ArrayList<ResolvedMember>();
- if (getSuperclass() != null) {
- ret.addAll(getSuperclass().getExposedPointcuts());
- }
-
- for (ResolvedType type : getDeclaredInterfaces()) {
- addPointcutsResolvingConflicts(ret, Arrays.asList(type.getDeclaredPointcuts()), false);
- }
-
- addPointcutsResolvingConflicts(ret, Arrays.asList(getDeclaredPointcuts()), true);
-
- for (ResolvedMember member : ret) {
- ResolvedPointcutDefinition inherited = (ResolvedPointcutDefinition) member;
- if (inherited != null && inherited.isAbstract()) {
- if (!this.isAbstract()) {
- getWorld().showMessage(IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.POINCUT_NOT_CONCRETE, inherited, this.getName()),
- inherited.getSourceLocation(), this.getSourceLocation());
- }
- }
- }
- return ret;
- }
-
- private void addPointcutsResolvingConflicts(List<ResolvedMember> acc, List<ResolvedMember> added, boolean isOverriding) {
- for (Iterator<ResolvedMember> i = added.iterator(); i.hasNext();) {
- ResolvedPointcutDefinition toAdd = (ResolvedPointcutDefinition) i.next();
- for (Iterator<ResolvedMember> j = acc.iterator(); j.hasNext();) {
- ResolvedPointcutDefinition existing = (ResolvedPointcutDefinition) j.next();
- if (toAdd == null || existing == null || existing == toAdd) {
- continue;
- }
- UnresolvedType pointcutDeclaringTypeUT = existing.getDeclaringType();
- if (pointcutDeclaringTypeUT != null) {
- ResolvedType pointcutDeclaringType = pointcutDeclaringTypeUT.resolve(getWorld());
- if (!isVisible(existing.getModifiers(), pointcutDeclaringType, this)) {
- // if they intended to override it but it is not visible,
- // give them a nicer message
- if (existing.isAbstract() && conflictingSignature(existing, toAdd)) {
- getWorld().showMessage(
- IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.POINTCUT_NOT_VISIBLE, existing.getDeclaringType()
- .getName() + "." + existing.getName() + "()", this.getName()),
- toAdd.getSourceLocation(), null);
- j.remove();
- }
- continue;
- }
- }
- if (conflictingSignature(existing, toAdd)) {
- if (isOverriding) {
- checkLegalOverride(existing, toAdd, 0x00, null);
- j.remove();
- } else {
- getWorld().showMessage(
- IMessage.ERROR,
- WeaverMessages.format(WeaverMessages.CONFLICTING_INHERITED_POINTCUTS,
- this.getName() + toAdd.getSignature()), existing.getSourceLocation(),
- toAdd.getSourceLocation());
- j.remove();
- }
- }
- }
- acc.add(toAdd);
- }
- }
-
- public ISourceLocation getSourceLocation() {
- return null;
- }
-
- public boolean isExposedToWeaver() {
- return false;
- }
-
- public WeaverStateInfo getWeaverState() {
- return null;
- }
-
- /**
- * Overridden by ReferenceType to return a sensible answer for parameterized and raw types.
- *
- * @return
- */
- public ReferenceType getGenericType() {
- // if (!(isParameterizedType() || isRawType()))
- // throw new BCException("The type " + getBaseName() + " is not parameterized or raw - it has no generic type");
- return null;
- }
-
- @Override
- public ResolvedType getRawType() {
- return super.getRawType().resolve(world);
- }
-
- public ResolvedType parameterizedWith(UnresolvedType[] typeParameters) {
- if (!(isGenericType() || isParameterizedType())) {
- return this;
- }
- return TypeFactory.createParameterizedType(this.getGenericType(), typeParameters, getWorld());
- }
-
- /**
- * Iff I am a parameterized type, and any of my parameters are type variable references (or nested parameterized types),
- * return a version with those type parameters replaced in accordance with the passed bindings.
- */
- @Override
- public UnresolvedType parameterize(Map<String, UnresolvedType> typeBindings) {
- if (!isParameterizedType()) {
- // throw new IllegalStateException("Can't parameterize a type that is not a parameterized type");
- return this;
- }
- boolean workToDo = false;
- for (int i = 0; i < typeParameters.length; i++) {
- if (typeParameters[i].isTypeVariableReference() || (typeParameters[i] instanceof BoundedReferenceType) || typeParameters[i].isParameterizedType()) {
- workToDo = true;
- }
- }
- if (!workToDo) {
- return this;
- } else {
- UnresolvedType[] newTypeParams = new UnresolvedType[typeParameters.length];
- for (int i = 0; i < newTypeParams.length; i++) {
- newTypeParams[i] = typeParameters[i];
- if (newTypeParams[i].isTypeVariableReference()) {
- TypeVariableReferenceType tvrt = (TypeVariableReferenceType) newTypeParams[i];
- UnresolvedType binding = typeBindings.get(tvrt.getTypeVariable().getName());
- if (binding != null) {
- newTypeParams[i] = binding;
- }
- } else if (newTypeParams[i] instanceof BoundedReferenceType) {
- BoundedReferenceType brType = (BoundedReferenceType) newTypeParams[i];
- newTypeParams[i] = brType.parameterize(typeBindings);
- // brType.parameterize(typeBindings)
- } else if (newTypeParams[i].isParameterizedType()) {
- newTypeParams[i] = newTypeParams[i].parameterize(typeBindings);
- }
- }
- return TypeFactory.createParameterizedType(getGenericType(), newTypeParams, getWorld());
- }
- }
-
- // public boolean hasParameterizedSuperType() {
- // getParameterizedSuperTypes();
- // return parameterizedSuperTypes.length > 0;
- // }
-
- // public boolean hasGenericSuperType() {
- // ResolvedType[] superTypes = getDeclaredInterfaces();
- // for (int i = 0; i < superTypes.length; i++) {
- // if (superTypes[i].isGenericType())
- // return true;
- // }
- // return false;
- // }
-
- // private ResolvedType[] parameterizedSuperTypes = null;
-
- /**
- * Similar to the above method, but accumulates the super types
- *
- * @return
- */
- // public ResolvedType[] getParameterizedSuperTypes() {
- // if (parameterizedSuperTypes != null)
- // return parameterizedSuperTypes;
- // List accumulatedTypes = new ArrayList();
- // accumulateParameterizedSuperTypes(this, accumulatedTypes);
- // ResolvedType[] ret = new ResolvedType[accumulatedTypes.size()];
- // parameterizedSuperTypes = (ResolvedType[]) accumulatedTypes.toArray(ret);
- // return parameterizedSuperTypes;
- // }
- // private void accumulateParameterizedSuperTypes(ResolvedType forType, List
- // parameterizedTypeList) {
- // if (forType.isParameterizedType()) {
- // parameterizedTypeList.add(forType);
- // }
- // if (forType.getSuperclass() != null) {
- // accumulateParameterizedSuperTypes(forType.getSuperclass(),
- // parameterizedTypeList);
- // }
- // ResolvedType[] interfaces = forType.getDeclaredInterfaces();
- // for (int i = 0; i < interfaces.length; i++) {
- // accumulateParameterizedSuperTypes(interfaces[i], parameterizedTypeList);
- // }
- // }
- /**
- * @return true if assignable to java.lang.Exception
- */
- public boolean isException() {
- return (world.getCoreType(UnresolvedType.JL_EXCEPTION).isAssignableFrom(this));
- }
-
- /**
- * @return true if it is an exception and it is a checked one, false otherwise.
- */
- public boolean isCheckedException() {
- if (!isException()) {
- return false;
- }
- if (world.getCoreType(UnresolvedType.RUNTIME_EXCEPTION).isAssignableFrom(this)) {
- return false;
- }
- return true;
- }
-
- /**
- * Determines if variables of this type could be assigned values of another with lots of help. java.lang.Object is convertable
- * from all types. A primitive type is convertable from X iff it's assignable from X. A reference type is convertable from X iff
- * it's coerceable from X. In other words, X isConvertableFrom Y iff the compiler thinks that _some_ value of Y could be
- * assignable to a variable of type X without loss of precision.
- *
- * @param other the other type
- * @param world the {@link World} in which the possible assignment should be checked.
- * @return true iff variables of this type could be assigned values of other with possible conversion
- */
- public final boolean isConvertableFrom(ResolvedType other) {
-
- // // version from TypeX
- // if (this.equals(OBJECT)) return true;
- // if (this.isPrimitiveType() || other.isPrimitiveType()) return
- // this.isAssignableFrom(other);
- // return this.isCoerceableFrom(other);
- //
-
- // version from ResolvedTypeX
- if (this.equals(OBJECT)) {
- return true;
- }
- if (world.isInJava5Mode()) {
- if (this.isPrimitiveType() ^ other.isPrimitiveType()) { // If one is
- // primitive
- // and the
- // other
- // isnt
- if (validBoxing.contains(this.getSignature() + other.getSignature())) {
- return true;
- }
- }
- }
- if (this.isPrimitiveType() || other.isPrimitiveType()) {
- return this.isAssignableFrom(other);
- }
- return this.isCoerceableFrom(other);
- }
-
- /**
- * Determines if the variables of this type could be assigned values of another type without casting. This still allows for
- * assignment conversion as per JLS 2ed 5.2. For object types, this means supertypeOrEqual(THIS, OTHER).
- *
- * @param other the other type
- * @param world the {@link World} in which the possible assignment should be checked.
- * @return true iff variables of this type could be assigned values of other without casting
- * @throws NullPointerException if other is null
- */
- public abstract boolean isAssignableFrom(ResolvedType other);
-
- public abstract boolean isAssignableFrom(ResolvedType other, boolean allowMissing);
-
- /**
- * Determines if values of another type could possibly be cast to this type. The rules followed are from JLS 2ed 5.5,
- * "Casting Conversion".
- * <p/>
- * <p>
- * This method should be commutative, i.e., for all UnresolvedType a, b and all World w:
- * <p/>
- * <blockquote>
- *
- * <pre>
- * a.isCoerceableFrom(b, w) == b.isCoerceableFrom(a, w)
- * </pre>
- *
- * </blockquote>
- *
- * @param other the other type
- * @param world the {@link World} in which the possible coersion should be checked.
- * @return true iff values of other could possibly be cast to this type.
- * @throws NullPointerException if other is null.
- */
- public abstract boolean isCoerceableFrom(ResolvedType other);
-
- public boolean needsNoConversionFrom(ResolvedType o) {
- return isAssignableFrom(o);
- }
-
- public String getSignatureForAttribute() {
- return signature; // Assume if this is being called that it is for a
- // simple type (eg. void, int, etc)
- }
-
- private FuzzyBoolean parameterizedWithTypeVariable = FuzzyBoolean.MAYBE;
-
- /**
- * return true if the parameterization of this type includes a member type variable. Member type variables occur in generic
- * methods/ctors.
- */
- public boolean isParameterizedWithTypeVariable() {
- // MAYBE means we haven't worked it out yet...
- if (parameterizedWithTypeVariable == FuzzyBoolean.MAYBE) {
-
- // if there are no type parameters then we cant be...
- if (typeParameters == null || typeParameters.length == 0) {
- parameterizedWithTypeVariable = FuzzyBoolean.NO;
- return false;
- }
-
- for (int i = 0; i < typeParameters.length; i++) {
- ResolvedType aType = (ResolvedType) typeParameters[i];
- if (aType.isTypeVariableReference()
- // Changed according to the problems covered in bug 222648
- // Don't care what kind of type variable - the fact that there
- // is one
- // at all means we can't risk caching it against we get confused
- // later
- // by another variation of the parameterization that just
- // happens to
- // use the same type variable name
-
- // assume the worst - if its definetly not a type declared one,
- // it could be anything
- // && ((TypeVariableReference)aType).getTypeVariable().
- // getDeclaringElementKind()!=TypeVariable.TYPE
- ) {
- parameterizedWithTypeVariable = FuzzyBoolean.YES;
- return true;
- }
- if (aType.isParameterizedType()) {
- boolean b = aType.isParameterizedWithTypeVariable();
- if (b) {
- parameterizedWithTypeVariable = FuzzyBoolean.YES;
- return true;
- }
- }
- if (aType.isGenericWildcard()) {
- BoundedReferenceType boundedRT = (BoundedReferenceType) aType;
- if (boundedRT.isExtends()) {
- boolean b = false;
- UnresolvedType upperBound = boundedRT.getUpperBound();
- if (upperBound.isParameterizedType()) {
- b = ((ResolvedType) upperBound).isParameterizedWithTypeVariable();
- } else if (upperBound.isTypeVariableReference()
- && ((TypeVariableReference) upperBound).getTypeVariable().getDeclaringElementKind() == TypeVariable.METHOD) {
- b = true;
- }
- if (b) {
- parameterizedWithTypeVariable = FuzzyBoolean.YES;
- return true;
- }
- // FIXME asc need to check additional interface bounds
- }
- if (boundedRT.isSuper()) {
- boolean b = false;
- UnresolvedType lowerBound = boundedRT.getLowerBound();
- if (lowerBound.isParameterizedType()) {
- b = ((ResolvedType) lowerBound).isParameterizedWithTypeVariable();
- } else if (lowerBound.isTypeVariableReference()
- && ((TypeVariableReference) lowerBound).getTypeVariable().getDeclaringElementKind() == TypeVariable.METHOD) {
- b = true;
- }
- if (b) {
- parameterizedWithTypeVariable = FuzzyBoolean.YES;
- return true;
- }
- }
- }
- }
- parameterizedWithTypeVariable = FuzzyBoolean.NO;
- }
- return parameterizedWithTypeVariable.alwaysTrue();
- }
-
- protected boolean ajMembersNeedParameterization() {
- if (isParameterizedType()) {
- return true;
- }
- ResolvedType superclass = getSuperclass();
- if (superclass != null && !superclass.isMissing()) {
- return superclass.ajMembersNeedParameterization();
- }
- return false;
- }
-
- protected Map<String, UnresolvedType> getAjMemberParameterizationMap() {
- Map<String, UnresolvedType> myMap = getMemberParameterizationMap();
- if (myMap.isEmpty()) {
- // might extend a parameterized aspect that we also need to
- // consider...
- if (getSuperclass() != null) {
- return getSuperclass().getAjMemberParameterizationMap();
- }
- }
- return myMap;
- }
-
- public void setBinaryPath(String binaryPath) {
- this.binaryPath = binaryPath;
- }
-
- /**
- * Returns the path to the jar or class file from which this binary aspect came or null if not a binary aspect
- */
- public String getBinaryPath() {
- return binaryPath;
- }
-
- /**
- * Undo any temporary modifications to the type (for example it may be holding annotations temporarily whilst some matching is
- * occurring - These annotations will be added properly during weaving but sometimes for type completion they need to be held
- * here for a while).
- */
- public void ensureConsistent() {
- // Nothing to do for anything except a ReferenceType
- }
-
- /**
- * For an annotation type, this will return if it is marked with @Inherited
- */
- public boolean isInheritedAnnotation() {
- ensureAnnotationBitsInitialized();
- return (bits & AnnotationMarkedInherited) != 0;
- }
-
- /*
- * Setup the bitflags if they have not already been done.
- */
- private void ensureAnnotationBitsInitialized() {
- if ((bits & AnnotationBitsInitialized) == 0) {
- bits |= AnnotationBitsInitialized;
- // Is it marked @Inherited?
- if (hasAnnotation(UnresolvedType.AT_INHERITED)) {
- bits |= AnnotationMarkedInherited;
- }
- }
- }
-
- private boolean hasNewParentMungers() {
- if ((bits & MungersAnalyzed) == 0) {
- bits |= MungersAnalyzed;
- for (ConcreteTypeMunger munger : interTypeMungers) {
- ResolvedTypeMunger resolvedTypeMunger = munger.getMunger();
- if (resolvedTypeMunger != null && resolvedTypeMunger.getKind() == ResolvedTypeMunger.Parent) {
- bits |= HasParentMunger;
- }
- }
- }
- return (bits & HasParentMunger) != 0;
- }
-
- public void tagAsTypeHierarchyComplete() {
- if (isParameterizedOrRawType()) {
- ReferenceType genericType = this.getGenericType();
- genericType.tagAsTypeHierarchyComplete();
- return;
- }
- bits |= TypeHierarchyCompleteBit;
- }
-
- public boolean isTypeHierarchyComplete() {
- if (isParameterizedOrRawType()) {
- return this.getGenericType().isTypeHierarchyComplete();
- }
- return (bits & TypeHierarchyCompleteBit) != 0;
- }
-
- /**
- * return the weaver version used to build this type - defaults to the most recent version unless discovered otherwise.
- *
- * @return the (major) version, {@link WeaverVersionInfo}
- */
- public int getCompilerVersion() {
- return WeaverVersionInfo.getCurrentWeaverMajorVersion();
- }
-
- public boolean isPrimitiveArray() {
- return false;
- }
-
- public boolean isGroovyObject() {
- if ((bits & GroovyObjectInitialized) == 0) {
- ResolvedType[] intfaces = getDeclaredInterfaces();
- boolean done = false;
- // TODO do we need to walk more of these? (i.e. the interfaces interfaces and supertypes supertype). Check what groovy
- // does in the case where a hierarchy is involved and there are types in between GroovyObject/GroovyObjectSupport and
- // the type
- if (intfaces != null) {
- for (ResolvedType intface : intfaces) {
- if (intface.getName().equals("groovy.lang.GroovyObject")) {
- bits |= IsGroovyObject;
- done = true;
- break;
- }
- }
- }
- if (!done) {
- // take a look at the supertype
- if (getSuperclass().getName().equals("groovy.lang.GroovyObjectSupport")) {
- bits |= IsGroovyObject;
- }
- }
- bits |= GroovyObjectInitialized;
- }
- return (bits & IsGroovyObject) != 0;
- }
-
- }
|