org.aspectj.ajdt.internal.compiler.lookup.PrivilegedHandler Maven / Gradle / Ivy

/* *******************************************************************
 * 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 
 * ******************************************************************/

package org.aspectj.ajdt.internal.compiler.lookup;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.aspectj.ajdt.internal.compiler.ast.AspectDeclaration;
import org.aspectj.ajdt.internal.compiler.ast.AstUtil;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.IPrivilegedHandler;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.ParameterizedFieldBinding;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.ParameterizedMethodBinding;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.aspectj.weaver.AjcMemberMaker;
import org.aspectj.weaver.Lint;
import org.aspectj.weaver.Member;
import org.aspectj.weaver.PrivilegedAccessMunger;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedMemberImpl;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.World;

public class PrivilegedHandler implements IPrivilegedHandler {
	private AspectDeclaration inAspect;
	private Map accessors = new HashMap();

	public PrivilegedHandler(AspectDeclaration inAspect) {
		this.inAspect = inAspect;
	}

	@Override
	public boolean definesPrivilegedAccessToField(FieldBinding field) {
		if (field instanceof ParameterizedFieldBinding) {
			field = ((ParameterizedFieldBinding) field).originalField;
		}
		ResolvedMember key = inAspect.factory.makeResolvedMember(field);
		return (accessors.containsKey(key));
	}

	@Override
	public FieldBinding getPrivilegedAccessField(FieldBinding baseField, ASTNode location) {
		if (baseField instanceof ParameterizedFieldBinding) {
			baseField = ((ParameterizedFieldBinding) baseField).originalField;
		}
		ResolvedMember key = inAspect.factory.makeResolvedMember(baseField);
		if (accessors.containsKey(key))
			return (FieldBinding) accessors.get(key);
		FieldBinding ret = new PrivilegedFieldBinding(inAspect, baseField);
		checkWeaveAccess(key.getDeclaringType(), location);
		if (!baseField.alwaysNeedsAccessMethod(true))
			accessors.put(key, ret);
		// 307120
		ResolvedType rt = inAspect.factory.fromEclipse(baseField.declaringClass);
		if (rt != null) {
			// ReferenceTypeDelegate rtd = ((ReferenceType) rt).getDelegate();
			// if (rtd instanceof EclipseSourceType) {
			rt.addInterTypeMunger(new EclipseTypeMunger(inAspect.factory, new PrivilegedAccessMunger(key, true), inAspect.typeX,
					null), true);
			// }
		}
		return ret;
	}

	@Override
	public MethodBinding getPrivilegedAccessMethod(MethodBinding baseMethod, ASTNode location) {
		if (baseMethod.alwaysNeedsAccessMethod())
			return baseMethod;

		ResolvedMember key = null;

		if (baseMethod instanceof ParameterizedMethodBinding) {
			key = inAspect.factory.makeResolvedMember(((ParameterizedMethodBinding) baseMethod).original());
		} else {
			key = inAspect.factory.makeResolvedMember(baseMethod);
		}
		if (accessors.containsKey(key))
			return (MethodBinding) accessors.get(key);

		MethodBinding ret;
		if (baseMethod.isConstructor()) {
			ret = new MethodBinding(baseMethod, baseMethod.declaringClass);
			ret.modifiers = AstUtil.makePublic(ret.modifiers);
			baseMethod.modifiers = ret.modifiers;
		} else {
			ret = inAspect.factory.makeMethodBinding(AjcMemberMaker.privilegedAccessMethodForMethod(inAspect.typeX, key));
		}
		checkWeaveAccess(key.getDeclaringType(), location);
		accessors.put(key, ret);
		// if (!baseMethod.isConstructor()) {
		// ResolvedType rt = inAspect.factory.fromEclipse(baseMethod.declaringClass);
		// if (rt!=null) {
		// ReferenceTypeDelegate rtd = ((ReferenceType)rt).getDelegate();
		// if (rtd instanceof EclipseSourceType) {
		// rt.addInterTypeMunger(new EclipseTypeMunger(inAspect.factory,new PrivilegedAccessMunger(key, true),inAspect.typeX,null),
		// true);
		// }
		// }
		// }
		return ret;
	}

	@Override
	public void notePrivilegedTypeAccess(ReferenceBinding type, ASTNode location) {
		ResolvedMember key = new ResolvedMemberImpl(Member.STATIC_INITIALIZATION, inAspect.factory.fromEclipse(type), 0,
				UnresolvedType.VOID, "", UnresolvedType.NONE);

		checkWeaveAccess(key.getDeclaringType(), location);
		accessors.put(key, key);
	}

	private void checkWeaveAccess(UnresolvedType typeX, ASTNode location) {
		World world = inAspect.factory.getWorld();
		Lint.Kind check = world.getLint().typeNotExposedToWeaver;
		if (check.isEnabled()) {
			if (!world.resolve(typeX).isExposedToWeaver()) {
				ISourceLocation loc = null;
				if (location != null) {
					loc = new EclipseSourceLocation(inAspect.compilationResult, location.sourceStart, location.sourceEnd);
				}
				check.signal(typeX.getName() + " (needed for privileged access)", loc);
			}
		}
	}

	public ResolvedMember[] getMembers() {
		Collection m = accessors.keySet();
		int len = m.size();
		ResolvedMember[] ret = new ResolvedMember[len];
		int index = 0;
		for (Iterator i = m.iterator(); i.hasNext();) {
			ret[index++] = (ResolvedMember) i.next();
		}
		return ret;
	}
}