aspect DataFlow {
	public void ASTNode.lockDataFlow() {
		for(int i=0;i<getNumChild();++i)
			getChild(i).lockDataFlow();
	}
	
	protected SmallSet<CFGNode> Access.lockedReachingDefs = null;
	
	public void Access.lockReachingDefs() {
		if(lockedReachingDefs == null)
			lockedReachingDefs = reachingDefinitions();
	}
	
	public void ArrayAccess.lockDataFlow() {
		lockReachingDefs();
		super.lockDataFlow();
	}
	
	public void ClassInstanceExpr.lockDataFlow() {
		lockReachingDefs();
		super.lockDataFlow();
	}
	
	public void ConstructorAccess.lockDataFlow() {
		lockReachingDefs();
		super.lockDataFlow();
	}
	
	public void MethodAccess.lockDataFlow() {
		lockReachingDefs();
		super.lockDataFlow();
	}
	
	public void VarAccess.lockDataFlow() {
		lockReachingDefs();
		super.lockDataFlow();
	}
	
	public void ASTNode.unlockDataFlow() { 
		for(int i=0;i<getNumChild();++i) {
			ASTNode ch = getChild(i);
			if(ch != null)
				ch.unlockDataFlow();
		}
	}
	
	public void Access.unlockDataFlow() {
		if(lockedReachingDefs != null) {
			if(hostType() != null)
				hostType().flushCollectionCache();
			if(!reachingDefinitions().equals(lockedReachingDefs))
				throw new RefactoringException("couldn't preserve data flow");
			lockedReachingDefs = null;
		}
		super.unlockDataFlow();
	}
	
	public static LanguageExtension ASTNode.LOCKED_DATAFLOW = new LanguageExtension("locked data flow") {
		public void eliminateOn(ASTNode n) {
			n.unlockDataFlow();
			n.flushCaches();
		}
	};
	
	// more precise analysis for fields of the receiver object (well-defined, since our analysis is always intra-procedural)
	class FieldInReceiver implements Location {
		private MethodDecl method;
		private FieldDeclaration field;
		
		public FieldInReceiver(MethodDecl method, FieldDeclaration field) {
			this.method = method;
			this.field = field;
		}
		
		public MethodDecl getMethod() {
			return method;
		}
		
		public FieldDeclaration getField() {
			return field;
		}
		
		public boolean isHeapLocation() {
			return true;
		}
		
		public boolean mayAlias(Location l) {
			return this.equals(l)
				|| l == field
				|| l instanceof AnyHeapLocation;
		}
		
		public boolean mustAlias(Location l) {
			return this.equals(l);
		}
		
		public boolean equals(Object o) {
			if(!(o instanceof FieldInReceiver))
				return false;
			FieldInReceiver that = (FieldInReceiver)o;
			return this.method.equals(that.method) && this.field.equals(that.field);
		}
	}
	
	refine Alias eq VarAccess.getLocation() {
		Variable decl = decl();
		BodyDecl host = hostBodyDecl();
		if(decl.isInstanceVariable() && host instanceof MethodDecl && 
				(!isQualified() || qualifier().isThisAccess() || qualifier().isSuperAccess()))
			return new FieldInReceiver((MethodDecl)host, (FieldDeclaration)decl);
		return decl;
	}
	
	refine Alias public boolean FieldDeclaration.mayAlias(Location l) {
		return l instanceof FieldInReceiver && this == ((FieldInReceiver)l).getField()
			|| refined(l);
	}
}