/* *******************************************************************
* 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.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.bridge.SourceLocation;
import org.aspectj.util.TypeSafeEnum;
/**
* This is an abstraction over method/field introduction. It might not have the chops to handle other inter-type declarations. This
* is the thing that is used on the eclipse side and serialized into a ConcreteTypeMunger.
*/
public abstract class ResolvedTypeMunger {
protected Kind kind;
protected ResolvedMember signature;
/**
* The declared signature is filled in when a type munger is parameterized for application to a particular type. It represents
* the signature originally declared in the source file.
*/
protected ResolvedMember declaredSignature;
// This list records the occurences (in order) of any names specified in the <>
// for a target type for the ITD. So for example, for List<C,B,A> this list
// will be C,B,A - the list is used later to map other occurrences of C,B,A
// across the intertype declaration to the right type variables in the generic
// type upon which the itd is being made.
// might need serializing the class file for binary weaving.
protected List<String> typeVariableAliases;
private Set<ResolvedMember> superMethodsCalled = Collections.emptySet();
private ISourceLocation location;
private ResolvedType onType = null;
public ResolvedTypeMunger(Kind kind, ResolvedMember signature) {
this.kind = kind;
this.signature = signature;
UnresolvedType declaringType = signature != null ? signature.getDeclaringType() : null;
if (declaringType != null) {
if (declaringType.isRawType()) {
throw new IllegalStateException("Use generic type, not raw type");
}
if (declaringType.isParameterizedType()) {
throw new IllegalStateException("Use generic type, not parameterized type");
}
}
// boolean aChangeOccurred = false;
//
// UnresolvedType rt = signature.getReturnType();
// if (rt.isParameterizedType() || rt.isGenericType()) {rt = rt.getRawType();aChangeOccurred=true;}
// UnresolvedType[] pt = signature.getParameterTypes();
// for (int i = 0; i < pt.length; i++) {
// if (pt[i].isParameterizedType() || pt[i].isGenericType()) { pt[i] = pt[i].getRawType();aChangeOccurred=true;}
// }
// if (aChangeOccurred) {
// this.signature = new
// ResolvedMemberImpl(signature.getKind(),signature.getDeclaringType(),signature.getModifiers(),rt,signature
// .getName(),pt,signature.getExceptions());
// }
}
public void setSourceLocation(ISourceLocation isl) {
location = isl;
}
public ISourceLocation getSourceLocation() {
return location;
}
// ----
// fromType is guaranteed to be a non-abstract aspect
// public ConcreteTypeMunger concretize(World world, ResolvedType aspectType) {
//
// ConcreteTypeMunger munger = world.concreteTypeMunger(this, aspectType);
// return munger;
// }
public boolean matches(ResolvedType matchType, ResolvedType aspectType) {
if (onType == null) {
onType = matchType.getWorld().resolve(getDeclaringType());
if (onType.isRawType()) {
onType = onType.getGenericType();
}
}
// System.err.println("matching: " + this + " to " + matchType + " onType = " + onType);
if (matchType.equals(onType)) {
if (!onType.isExposedToWeaver()) {
// if the onType is an interface, and it already has the member we are about
// to munge, then this is ok...
boolean ok = (onType.isInterface() && (onType.lookupMemberWithSupersAndITDs(getSignature()) != null));
if (!ok && onType.getWeaverState() == null) {
if (matchType.getWorld().getLint().typeNotExposedToWeaver.isEnabled()) {
matchType.getWorld().getLint().typeNotExposedToWeaver.signal(matchType.getName(), signature
.getSourceLocation());
}
}
}
return true;
}
// System.err.println("NO MATCH DIRECT");
if (onType.isInterface()) {
return matchType.isTopmostImplementor(onType);
} else {
return false;
}
}
// ----
@Override
public String toString() {
return "ResolvedTypeMunger(" + getKind() + ", " + getSignature() + ")";
// .superMethodsCalled + ")";
}
// ----
public static ResolvedTypeMunger read(VersionedDataInputStream s, ISourceContext context) throws IOException {
Kind kind = Kind.read(s);
if (kind == Field) {
return NewFieldTypeMunger.readField(s, context);
} else if (kind == Method) {
return NewMethodTypeMunger.readMethod(s, context);
} else if (kind == Constructor) {
return NewConstructorTypeMunger.readConstructor(s, context);
} else if (kind == MethodDelegate) {
return MethodDelegateTypeMunger.readMethod(s, context, false);
} else if (kind == FieldHost) {
return MethodDelegateTypeMunger.FieldHostTypeMunger.readFieldHost(s, context);
} else if (kind == MethodDelegate2) {
return MethodDelegateTypeMunger.readMethod(s, context, true);
} else if (kind == InnerClass) {
return NewMemberClassTypeMunger.readInnerClass(s, context);
} else {
throw new RuntimeException("unimplemented");
}
}
protected static Set<ResolvedMember> readSuperMethodsCalled(VersionedDataInputStream s) throws IOException {
Set<ResolvedMember> ret = new HashSet<ResolvedMember>();
int n = -1;
if (s.isAtLeast169()) {
n = s.readByte();
} else {
n = s.readInt();
}
if (n < 0) {
throw new BCException("Problem deserializing type munger");
}
for (int i = 0; i < n; i++) {
ret.add(ResolvedMemberImpl.readResolvedMember(s, null));
}
return ret;
}
protected final void writeSuperMethodsCalled(CompressingDataOutputStream s) throws IOException {
if (superMethodsCalled == null || superMethodsCalled.size() == 0) {
s.writeByte(0);
return;
}
List<ResolvedMember> ret = new ArrayList<ResolvedMember>(superMethodsCalled);
Collections.sort(ret);
int n = ret.size();
s.writeByte(n);
for (ResolvedMember m : ret) {
m.write(s);
}
}
protected static ISourceLocation readSourceLocation(VersionedDataInputStream s) throws IOException {
// Location persistence for type mungers was added after 1.2.1 was shipped...
if (s.getMajorVersion() < AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) {
return null;
}
SourceLocation ret = null;
ObjectInputStream ois = null;
try {
// This logic copes with the location missing from the attribute - an EOFException will
// occur on the next line and we ignore it.
byte b = 0;
// if we aren't on 1.6.9 or we are on 1.6.9 but not compressed, then read as object stream
if (!s.isAtLeast169() || (b = s.readByte()) == 0) {
ois = new ObjectInputStream(s);
boolean validLocation = (Boolean) ois.readObject();
if (validLocation) {
File f = (File) ois.readObject();
Integer ii = (Integer) ois.readObject();
Integer offset = (Integer) ois.readObject();
ret = new SourceLocation(f, ii.intValue());
ret.setOffset(offset.intValue());
}
} else {
boolean validLocation = b == 2;
if (validLocation) {
String path = s.readUtf8(s.readShort());
File f = new File(path);
ret = new SourceLocation(f, s.readInt());
int offset = s.readInt();
ret.setOffset(offset);
}
}
} catch (EOFException eof) {
return null; // This exception occurs if processing an 'old style' file where the
// type munger attributes don't include the source location.
} catch (IOException ioe) {
// Something went wrong, maybe this is an 'old style' file that doesnt attach locations to mungers?
// (but I thought that was just an EOFException?)
ioe.printStackTrace();
return null;
} catch (ClassNotFoundException e) {
} finally {
if (ois != null) {
ois.close();
}
}
return ret;
}
protected final void writeSourceLocation(CompressingDataOutputStream s) throws IOException {
if (s.canCompress()) {
s.writeByte(1 + (location == null ? 0 : 1)); // 1==compressed no location 2==compressed with location
if (location != null) {
s.writeCompressedPath(location.getSourceFile().getPath());
s.writeInt(location.getLine());
s.writeInt(location.getOffset());
}
} else {
s.writeByte(0);
ObjectOutputStream oos = new ObjectOutputStream(s);
oos.writeObject(new Boolean(location != null));
if (location != null) {
oos.writeObject(location.getSourceFile());
oos.writeObject(new Integer(location.getLine()));
oos.writeObject(new Integer(location.getOffset()));
}
oos.flush();
oos.close();
}
}
public abstract void write(CompressingDataOutputStream s) throws IOException;
public Kind getKind() {
return kind;
}
public static class Kind extends TypeSafeEnum {
/* private */Kind(String name, int key) {
super(name, key);
}
public static Kind read(DataInputStream s) throws IOException {
int key = s.readByte();
switch (key) {
case 1:
return Field;
case 2:
return Method;
case 5:
return Constructor;
case 9:
return MethodDelegate;
case 10:
return FieldHost;
case 11:
return MethodDelegate2;
case 12:
return InnerClass;
}
throw new BCException("bad kind: " + key);
}
@Override
public String toString() {
// we want MethodDelegate to appear as Method in WeaveInfo messages
// TODO we may want something for fieldhost ?
if (getName().startsWith(MethodDelegate.getName())) {// startsWith will cover MethodDelegate2 as well
return Method.toString();
} else {
return super.toString();
}
}
}
// ---- fields
public static final Kind Field = new Kind("Field", 1);
public static final Kind Method = new Kind("Method", 2);
public static final Kind Constructor = new Kind("Constructor", 5);
// not serialized, only created during concretization of aspects
public static final Kind PerObjectInterface = new Kind("PerObjectInterface", 3);
public static final Kind PrivilegedAccess = new Kind("PrivilegedAccess", 4);
public static final Kind Parent = new Kind("Parent", 6);
// PTWIMPL not serialized, used during concretization of aspects
public static final Kind PerTypeWithinInterface = new Kind("PerTypeWithinInterface", 7);
public static final Kind AnnotationOnType = new Kind("AnnotationOnType", 8); // not serialized
public static final Kind MethodDelegate = new Kind("MethodDelegate", 9);// serialized, @AJ ITDs
public static final Kind FieldHost = new Kind("FieldHost", 10);// serialized, @AJ ITDs
public static final Kind MethodDelegate2 = new Kind("MethodDelegate2", 11);// serialized, @AJ ITDs
public static final Kind InnerClass = new Kind("InnerClass", 12);
public static final String SUPER_DISPATCH_NAME = "superDispatch";
public void setSuperMethodsCalled(Set<ResolvedMember> c) {
this.superMethodsCalled = c;
}
public Set<ResolvedMember> getSuperMethodsCalled() {
return superMethodsCalled;
}
public ResolvedMember getSignature() {
return signature;
}
// ----
public ResolvedMember getMatchingSyntheticMember(Member member, ResolvedType aspectType) {
if ((getSignature() != null) && getSignature().isPublic() && member.equals(getSignature())) {
return getSignature();
}
return null;
}
public boolean changesPublicSignature() {
return kind == Field || kind == Method || kind == Constructor;
}
public boolean needsAccessToTopmostImplementor() {
if (kind == Field) {
return true;
} else if (kind == Method) {
return !signature.isAbstract();
} else {
return false;
}
}
protected static List<String> readInTypeAliases(VersionedDataInputStream s) throws IOException {
if (s.getMajorVersion() >= AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) {
int count = -1;
if (s.isAtLeast169()) {
count = s.readByte();
} else {
count = s.readInt();
}
if (count != 0) {
List<String> aliases = new ArrayList<String>();
for (int i = 0; i < count; i++) {
aliases.add(s.readUTF());
}
return aliases;
}
}
return null;
}
protected final void writeOutTypeAliases(DataOutputStream s) throws IOException {
// Write any type variable aliases
if (typeVariableAliases == null || typeVariableAliases.size() == 0) {
s.writeByte(0);
} else {
s.writeByte(typeVariableAliases.size());
for (String element : typeVariableAliases) {
s.writeUTF(element);
}
}
}
public List<String> getTypeVariableAliases() {
return typeVariableAliases;
}
protected void setTypeVariableAliases(List<String> typeVariableAliases) {
this.typeVariableAliases = typeVariableAliases;
}
public boolean hasTypeVariableAliases() {
return (typeVariableAliases != null && typeVariableAliases.size() > 0);
}
/**
* return true if type variables are specified with the target type for this ITD. e.g. this would return true:
* "int I<A,B>.m() { return 42; }"
*/
public boolean sharesTypeVariablesWithGenericType() {
return (typeVariableAliases != null && typeVariableAliases.size() > 0);
}
/**
* Parameterizes a resolved type munger for a particular usage of its target type (this is used when the target type is generic
* and the ITD shares type variables with the target) see ConcreteTypeMunger.parameterizedFor
*/
public ResolvedTypeMunger parameterizedFor(ResolvedType target) {
throw new BCException("Dont call parameterizedFor on a type munger of this kind: " + this.getClass());
}
// ResolvedType genericType = target;
// if (target.isRawType() || target.isParameterizedType()) genericType = genericType.getGenericType();
// ResolvedMember parameterizedSignature = null;
// // If we are parameterizing it for a generic type, we just need to 'swap the letters' from the ones used
// // in the original ITD declaration to the ones used in the actual target type declaration.
// if (target.isGenericType()) {
// TypeVariable vars[] = target.getTypeVariables();
// UnresolvedTypeVariableReferenceType[] varRefs = new UnresolvedTypeVariableReferenceType[vars.length];
// for (int i = 0; i < vars.length; i++) {
// varRefs[i] = new UnresolvedTypeVariableReferenceType(vars[i]);
// }
// parameterizedSignature = getSignature().parameterizedWith(varRefs,genericType,true,typeVariableAliases);
// } else {
// // For raw and 'normal' parameterized targets (e.g. Interface, Interface<String>)
// parameterizedSignature =
// getSignature().parameterizedWith(target.getTypeParameters(),genericType,target.isParameterizedType(),typeVariableAliases);
// }
// return new NewMethodTypeMunger(parameterizedSignature,getSuperMethodsCalled(),typeVariableAliases);
// }
// /**
// * see ResolvedTypeMunger.parameterizedFor(ResolvedType)
// */
// public ResolvedTypeMunger parameterizedFor(ResolvedType target) {
// ResolvedType genericType = target;
// if (target.isRawType() || target.isParameterizedType()) genericType = genericType.getGenericType();
// ResolvedMember parameterizedSignature =
// getSignature().parameterizedWith(target.getTypeParameters(),genericType,target.isParameterizedType(),typeVariableAliases);
// return new NewFieldTypeMunger(parameterizedSignature,getSuperMethodsCalled(),typeVariableAliases);
// }
public void setDeclaredSignature(ResolvedMember rm) {
declaredSignature = rm;
}
public ResolvedMember getDeclaredSignature() {
return declaredSignature;
}
/**
* A late munger has to be done after shadow munging since which shadows are matched can affect the operation of the late
* munger. e.g. perobjectinterfacemunger
*/
public boolean isLateMunger() {
return false;
}
/**
* Some type mungers are created purely to help with the implementation of shadow mungers. For example to support the cflow()
* pointcut we create a new cflow field in the aspect, and that is added via a BcelCflowCounterFieldAdder.
*
* During compilation we need to compare sets of type mungers, and if some only come into existence after the 'shadowy' type
* things have been processed, we need to ignore them during the comparison.
*
* Returning true from this method indicates the type munger exists to support 'shadowy' stuff - and so can be ignored in some
* comparison.
*/
public boolean existsToSupportShadowMunging() {
return false;
}
public ResolvedTypeMunger parameterizeWith(Map<String, UnresolvedType> m, World w) {
throw new BCException("Dont call parameterizeWith() on a type munger of this kind: " + this.getClass());
}
public UnresolvedType getDeclaringType() {
return getSignature().getDeclaringType();
}
}