Java Verification类代码示例

import org.aikodi.chameleon.core.validation.Verification; //导入依赖的package包/类
@Override
public void analyze(AssignmentExpression assignment) throws LookupException {
	Verification result = Valid.create();
	Method method = assignment.nearestAncestor(Method.class);
	Java7 language = method.language(Java7.class);
	if(method != null && Predicates.EXTERNALLY_ACCESSIBLE.eval(method)) {
		Variable v = assignment.variable();
		if(v instanceof RegularMemberVariable && v.isTrue(language.INSTANCE)) {
			Expression e = assignment.getValue();
			if(e instanceof CrossReference) {
				Declaration rhs = ((CrossReference) e).getElement();
				if(rhs instanceof FormalParameter) {
					Type type_of_value = ((FormalParameter)rhs).getType();
					if((!Predicates.IMMUTABLE_COLLECTION.eval(type_of_value)) && Predicates.COLLECTION.eval(type_of_value)) {
						result = result.and(new IncomingCollectionEncapsulationViolationResult(v,(FormalParameter) rhs));
					}
				}
			}
		}
	}

	setResult(result().and(result));
}
 

import org.aikodi.chameleon.core.validation.Verification; //导入依赖的package包/类
/**
 * @{inheritDoc}
 */
@Override
protected void analyze(ReturnStatement statement) throws LookupException {
  Verification result = Valid.create();
  Method nearestAncestor = statement.nearestAncestor(Method.class);
  if(nearestAncestor != null && 
  		Predicates.EXTERNALLY_ACCESSIBLE.eval(nearestAncestor)) {
          Expression expr = statement.getExpression();
          if(expr instanceof CrossReference) {
              Declaration declaration = ((CrossReference) expr).getElement();
          		Java7 language = statement.language(Java7.class);
              if(declaration instanceof RegularMemberVariable && declaration.isTrue(language.INSTANCE)) {
                  Type type = ((RegularMemberVariable) declaration).getType();
                  if((!Predicates.IMMUTABLE_COLLECTION.eval(type)) && Predicates.COLLECTION.eval(type)) {
                      result = new OutgoingCollectionEncapsulationViolation(nearestAncestor, (Variable) declaration);
                  }
              }
          }
  }
  setResult(result().and(result));
}
 

import org.aikodi.chameleon.core.validation.Verification; //导入依赖的package包/类
@Override
public Verification verifySelf() {
	Verification result = Valid.create();
	if(newSignature() == null) {
		result = result.and(new BasicProblem(this, "The renaming clause does not contain a new name."));
	}
	QualifiedName fqn = oldFQN();
	if(fqn == null) {
		result = result.and(new BasicProblem(this, "The renaming clause does not contain an old name."));
	}
	try {
		oldDeclaration();
	} catch(LookupException exc) {
		String id = "";
		if(fqn != null) {
			id = fqn.toString();
		}
		result = result.and(new BasicProblem(this, "The exported declaration "+id+"cannot be found."));
	}
	return result;
}
 

import org.aikodi.chameleon.core.validation.Verification; //导入依赖的package包/类
@Override
public Verification verifySelf() {
	Type referencedElement;
	try {
		referencedElement = getElement();
		if(referencedElement != null) {
			return Valid.create();
		} else {
			return new UnresolvableCrossReference(this);
		}
	} catch (LookupException e) {
		return new UnresolvableCrossReference(this);
	}
}
 

import org.aikodi.chameleon.core.validation.Verification; //导入依赖的package包/类
@Override
protected void analyze(AssignmentExpression assignment) throws LookupException {
	Verification result = Valid.create();
		final Method method = assignment.nearestAncestor(Method.class);
		if(method != null && method.isTrue(method.language(Java7.class).PUBLIC)) {
			Variable v = assignment.variable();
			if(v instanceof RegularMemberVariable) {
				Expression e = assignment.getValue();
				if(e instanceof CrossReference) {
					final Declaration rhs = ((CrossReference) e).getElement();
					if(rhs instanceof FormalParameter) {
						Type booleanType = assignment.view(JavaView.class).primitiveType("boolean");
						if(! ((FormalParameter) rhs).getType().sameAs(booleanType)) {
							boolean notMentioned = true;
							Statement stat = assignment.lexical().farthestAncestor(new UniversalPredicate<Statement,Nothing>(Statement.class) {
								@Override
								public boolean uncheckedEval(Statement s) {
									// If s.parent() == the implementation object, then we have reached the
									// block of the implementation, so we have to stop before that to object
									// the child statement of the block of the implementation
									return (! (s.parent() instanceof Implementation)) && s.nearestAncestor(Method.class) == method;
								}
							});
							Block b = (Block) stat.parent();
							List<Statement> befores = b.statementsBefore(stat);
							for(Statement before : befores) {
								List<CrossReference> crefs = before.descendants(CrossReference.class, cref -> cref.getElement().sameAs(rhs));
								if(! crefs.isEmpty()) {
									notMentioned = false; 
								}
							}
							if(notMentioned) {
								result = new NonDefensiveFieldAssignmentResult((FormalParameter)rhs,v);
							}
						}
					}
				}
			}
		}
	setResult(result().and(result));
}
 

import org.aikodi.chameleon.core.validation.Verification; //导入依赖的package包/类
@Override
public Verification verifySelf() {
 return Valid.create();
}
 

import org.aikodi.chameleon.core.validation.Verification; //导入依赖的package包/类
@Override
public Verification verifySelf() {
	return Valid.create();
}
 

import org.aikodi.chameleon.core.validation.Verification; //导入依赖的package包/类
@Override
public Verification verifySelf() {
   return Valid.create();
}
 

import org.aikodi.chameleon.core.validation.Verification; //导入依赖的package包/类
@Override
public Verification verifySelf() {
  return Valid.create();
}
 

import org.aikodi.chameleon.core.validation.Verification; //导入依赖的package包/类
/**
 * A super target is always valid. If invocations on a super target must always resolve to an effective declaration, 
 * as is the case in Java, then the language must add that rule. For mixins, for example, that must only be the case for
 * an actual combination of mixins.
 */
@Override
public Verification verifySelf() {
	return Valid.create();
}