aspect TypeCheckCJP {

	public void ClosureJoinpointAccess.typeCheck() {
		super.typeCheck();
		
  		TypeDecl decl = getName().type();
  		if(decl.isJoinpointTypeDecl()) {
  			JoinpointTypeDecl d = (JoinpointTypeDecl)decl;
  			int i=0;
  			for(ParameterDeclaration p: getParameters()) {
				if(p.type()!=d.getParameter(i).type()) {
					error(p.getID()+" must be of type "+d.getParameter(i).type().name()+" but is of type "+p.type().name()+" instead.");
				}
				i++;
  			}
		}
	}

	syn lazy boolean AdviceSpec.isAround() = false;
	eq AroundSpec.isAround() = true;

	syn lazy boolean AdviceSpec.isAfterReturning() = false;
	eq AfterReturningSpec.isAfterReturning() = true;
	
	syn lazy boolean AdviceSpec.isAfterThrowing() = false;
	eq AfterThrowingSpec.isAfterThrowing() = true;
	
	syn lazy boolean TypeDecl.isCJPTypeDecl() = false;
	eq JoinpointTypeDecl.isCJPTypeDecl() = true;
	
	
  public void CJPAdviceDecl.doTypeChecking(JoinpointTypeDecl jpiDecl){
		/***
		 * 1) check that the type of SuperAccess is JPITypeDecl.
		 * 2) check the arguments types.
		 * 3) check the return types.
		 * 4) check the exceptions.
		 */		
		AdviceSpec currentAdviceSpec = getAdviceSpec();	  
		int paramNum = 0;
		for(int i=0; i<currentAdviceSpec.getNumParameter(); i++){
			ParameterDeclaration adviceParameter = currentAdviceSpec.getParameter(i);
			if(!adviceParameter.isImplicit()) paramNum++;			
		}		
		
		if (jpiDecl.getNumParameter() != paramNum){
			error("TypeCheck: Advice declaration must have the same number of parameter as "+jpiDecl.getID());
		} else {
			ParameterDeclaration adviceParameter;
			ParameterDeclaration jpiParameter;
			for(int i=0; i<jpiDecl.getNumParameter(); i++){
				adviceParameter = currentAdviceSpec.getParameter(i);
				jpiParameter = jpiDecl.getParameter(i);
				if(!adviceParameter.type().equals(jpiParameter.type())){
					error("TypeCheck: Parameter "+adviceParameter.getID()+" must be the type of "+jpiParameter.type().name()+" instead "+adviceParameter.type().name());
				}
			}
		}
		
		if (currentAdviceSpec.isAround()){
			if (!jpiDecl.getTypeAccess().type().equals(returnType())){
				error("TypeCheck: Advice return type: "+returnType().name()+" instead "+jpiDecl.getTypeAccess().type().name());
			}			
		}
		
		if (currentAdviceSpec.isAfterReturning()){
			AfterReturningSpec r = (AfterReturningSpec) currentAdviceSpec;
			if(r.hasReturnParameter()) {
				TypeDecl jpiReturnType = jpiDecl.getTypeAccess().type();
				TypeDecl adviceReturnType = r.getReturnParameter().getTypeAccess().type();
				if(!jpiReturnType.castingConversionTo(adviceReturnType)) {
					error("TypeCheck: jpi "+ jpiDecl.getID() + " returns type "+jpiReturnType.name()+
					      " which is incompatible with advice return type "+adviceReturnType.name());
				}
			}
			
		}
		
		if(currentAdviceSpec.isAfterThrowing()) {
			AfterThrowingSpec r = (AfterThrowingSpec) currentAdviceSpec;
			if(r.hasExceptionParameter()) {
				TypeDecl adviceSpecException = r.getExceptionParameter().getTypeAccess().type();
	 	    	//note: the notion of checked and unchecked exceptions is apparently incorrectly reversed in JastAdd!!! 
				if(!adviceSpecException.isCheckedException()) {
					boolean found = false;
			        for(Access ex: jpiDecl.getExceptions()) {
			        	TypeDecl declared = ex.type();
			    		if(declared.castingConversionTo(adviceSpecException)) {
			    			found = true;
		    				break;
	    				}
		    			if(!found)
		    				error("TypeCheck: jpi "+ jpiDecl.getID() + " cannot throw checked exceptions of type "+adviceSpecException.name()); 
			        }
		        }
			}
		}		
		
		boolean foundError;
		for(Access exceptionAccess: getExceptionList()){
			foundError = false;
			for(Access parentExceptionAccess: jpiDecl.getExceptionList()){
				if(exceptionAccess.type().instanceOf(parentExceptionAccess.type())){
					foundError = true;
					break;
				}
			}
			if (!foundError){
				error("TypeCheck: Advice cannot throw exception of type "+exceptionAccess.type().name());
			}
		}	  
	}	

	public void CJPAdviceDecl.typeCheck() {
		super.typeCheck();
		TypeAccess joinpointAccess = (TypeAccess) getName();
		
		if (joinpointAccess.decls().isEmpty()){
			error("TypeChecking: "+joinpointAccess.getID()+" is not a valid type for JoinpointTypeDeclaration");
			return;
		} 
		else { 			
			if (!joinpointAccess.decl().isCJPTypeDecl()){
				error("TypeChecking: "+joinpointAccess.decl().typeName()+" is not a valid type for JoinpointTypeDeclaration");
				return;				
			}
		}	
		doTypeChecking((JoinpointTypeDecl)joinpointAccess.type());
	}
	
	refine NameCheck public void TypeDecl.nameCheck() {
		correctTheReturnTypeAndThrowsList();	
		NameCheck.TypeDecl.nameCheck();
	}
	
	public void ASTNode.correctTheReturnTypeAndThrowsList() {
		for(int i = 0; i < getNumChild(); i++)
			getChild(i).correctTheReturnTypeAndThrowsList();
	}
	
	public void ClosureJoinpointAccess.correctTheReturnTypeAndThrowsList() {
		TypeDecl t = getName().type();
		if(t instanceof JoinpointTypeDecl) {
			JoinpointTypeDecl joinpointTypeDecl = (JoinpointTypeDecl) t;
			try{
				setReturnType(joinpointTypeDecl.getTypeAccess().clone());
				setExceptionList(joinpointTypeDecl.getExceptionList().clone());
			} catch(CloneNotSupportedException e) {
				throw new RuntimeException(e); //cannot occur
			}
		}
	}
	
	public void ClosureJoinpointAccess.nameCheck() {
		TypeDecl t = getName().type();
		if(!t.isUnknown() && !t.isJoinpointTypeDecl()) {
			error("type "+getName()+" is not a joinpoint type");	
		} 
	}

 	eq AnonymousMethod.getParameter().outerScope() = this;
 	inh VariableScope AnonymousMethod.outerScope();
 	 	
 	AnonymousMethod implements VariableScope;
 	
 	eq AnonymousMethod.getBlock().returnType() = type();
 	
	refine MultiCatch public void ParameterDeclaration.nameCheck() {
		//do nothing
	}

	syn lazy JoinpointTypeDecl CJPAdviceDecl.cjpTypeDecl() {
		TypeAccess name = (TypeAccess) getName();	
		return (JoinpointTypeDecl) name.decl();
	}

  //copied from Advice.jrag
  eq CJPAdviceDecl.getAdviceSpec().lookupVariable(String name) {
    SimpleSet v = getAdviceSpec().localLookupVariable(name);
    if(!v.isEmpty()) return v;
    v = getAdviceSpec().lookupAfterVariable(name);
    if(!v.isEmpty()) return v;
    return lookupVariable(name);
  }
  eq CJPAdviceDecl.getBlock().lookupVariable(String name) {
    SimpleSet v = getAdviceSpec().localLookupVariable(name);
    if(!v.isEmpty()) return v;
    v = getAdviceSpec().lookupAfterVariable(name);
    if(!v.isEmpty()) return v;
    return lookupVariable(name);
  }
  inh SimpleSet CJPAdviceDecl.lookupVariable(String name);
  
  eq CJPAdviceDecl.getBlock().returnType() = returnType();
  
  //copied from AdviceCodegen.jrag
  eq CJPAdviceDecl.getBlock().aroundSpec() = getAdviceSpec().aroundSpec();
  
}