Java Kind.ANNOTATION属性代码示例

public static void sanityCheckForMethodGeneratingAnnotationsOnBuilderClass(EclipseNode typeNode, EclipseNode errorNode) {
	List<String> disallowed = null;
	for (EclipseNode child : typeNode.down()) {
		if (child.getKind() != Kind.ANNOTATION) continue;
		for (Class<? extends java.lang.annotation.Annotation> annType : INVALID_ON_BUILDERS) {
			if (annotationTypeMatches(annType, child)) {
				if (disallowed == null) disallowed = new ArrayList<String>();
				disallowed.add(annType.getSimpleName());
			}
		}
	}
	
	int size = disallowed == null ? 0 : disallowed.size();
	if (size == 0) return;
	if (size == 1) {
		errorNode.addError("@" + disallowed.get(0) + " is not allowed on builder classes.");
		return;
	}
	StringBuilder out = new StringBuilder();
	for (String a : disallowed) out.append("@").append(a).append(", ");
	out.setLength(out.length() - 2);
	errorNode.addError(out.append(" are not allowed on builder classes.").toString());
}
 

/**
 * Searches the given field node for annotations and returns each one that matches the provided regular expression pattern.
 * 
 * Only the simple name is checked - the package and any containing class are ignored.
 */
public static List<JCAnnotation> findAnnotations(JavacNode fieldNode, Pattern namePattern) {
	ListBuffer<JCAnnotation> result = new ListBuffer<JCAnnotation>();
	for (JavacNode child : fieldNode.down()) {
		if (child.getKind() == Kind.ANNOTATION) {
			JCAnnotation annotation = (JCAnnotation) child.get();
			String name = annotation.annotationType.toString();
			int idx = name.lastIndexOf(".");
			String suspect = idx == -1 ? name : name.substring(idx + 1);
			if (namePattern.matcher(suspect).matches()) {
				result.append(annotation);
			}
		}
	}	
	return result.toList();
}
 

/**
 * {@code @Foo int x, y;} is stored in both javac and ecj as 2 FieldDeclarations, both with the same annotation as child.
 * The normal {@code up()} method can't handle having multiple parents, but this one can.
 */
public Collection<L> upFromAnnotationToFields() {
	if (getKind() != Kind.ANNOTATION) return Collections.emptyList();
	L field = up();
	if (field == null || field.getKind() != Kind.FIELD) return Collections.emptyList();
	L type = field.up();
	if (type == null || type.getKind() != Kind.TYPE) return Collections.emptyList();
	
	List<L> fields = new ArrayList<L>();
	for (L potentialField : type.down()) {
		if (potentialField.getKind() != Kind.FIELD) continue;
		if (fieldContainsAnnotation(potentialField.get(), get())) fields.add(potentialField);
	}
	
	return fields;
}
 

/**
 * Searches the given field node for annotations and returns each one that matches the provided regular expression pattern.
 * 
 * Only the simple name is checked - the package and any containing class are ignored.
 */
public static List<JCAnnotation> findAnnotations(JavacNode fieldNode, Pattern namePattern) {
	ListBuffer<JCAnnotation> result = ListBuffer.lb();
	for (JavacNode child : fieldNode.down()) {
		if (child.getKind() == Kind.ANNOTATION) {
			JCAnnotation annotation = (JCAnnotation) child.get();
			String name = annotation.annotationType.toString();
			int idx = name.lastIndexOf(".");
			String suspect = idx == -1 ? name : name.substring(idx + 1);
			if (namePattern.matcher(suspect).matches()) {
				result.append(annotation);
			}
		}
	}	
	return result.toList();
}
 

static boolean lookForGetter(EclipseNode field, FieldAccess fieldAccess) {
	if (fieldAccess == FieldAccess.GETTER) return true;
	if (fieldAccess == FieldAccess.ALWAYS_FIELD) return false;
	
	// If @Getter(lazy = true) is used, then using it is mandatory.
	for (EclipseNode child : field.down()) {
		if (child.getKind() != Kind.ANNOTATION) continue;
		if (annotationTypeMatches(Getter.class, child)) {
			AnnotationValues<Getter> ann = createAnnotation(Getter.class, child);
			if (ann.getInstance().lazy()) return true;
		}
	}
	return false;
}
 

/**
 * Generates a wither on the stated field.
 * 
 * Used by {@link HandleValue}.
 * 
 * The difference between this call and the handle method is as follows:
 * 
 * If there is a {@code lombok.experimental.Wither} annotation on the field, it is used and the
 * same rules apply (e.g. warning if the method already exists, stated access level applies).
 * If not, the wither is still generated if it isn't already there, though there will not
 * be a warning if its already there. The default access level is used.
 */
public void generateWitherForField(EclipseNode fieldNode, EclipseNode sourceNode, AccessLevel level) {
	for (EclipseNode child : fieldNode.down()) {
		if (child.getKind() == Kind.ANNOTATION) {
			if (annotationTypeMatches(Wither.class, child)) {
				//The annotation will make it happen, so we can skip it.
				return;
			}
		}
	}
	
	List<Annotation> empty = Collections.emptyList();
	createWitherForField(level, fieldNode, sourceNode, false, empty, empty);
}
 

public void generateConstructor(JavacNode typeNode, AccessLevel level, List<JCAnnotation> onConstructor, List<JavacNode> fields, boolean allToDefault, String staticName, SkipIfConstructorExists skipIfConstructorExists, Boolean suppressConstructorProperties, JavacNode source) {
	boolean staticConstrRequired = staticName != null && !staticName.equals("");
	
	if (skipIfConstructorExists != SkipIfConstructorExists.NO && constructorExists(typeNode) != MemberExistsResult.NOT_EXISTS) return;
	if (skipIfConstructorExists != SkipIfConstructorExists.NO) {
		for (JavacNode child : typeNode.down()) {
			if (child.getKind() == Kind.ANNOTATION) {
				boolean skipGeneration = annotationTypeMatches(NoArgsConstructor.class, child) ||
					annotationTypeMatches(AllArgsConstructor.class, child) ||
					annotationTypeMatches(RequiredArgsConstructor.class, child);
				
				if (!skipGeneration && skipIfConstructorExists == SkipIfConstructorExists.YES) {
					skipGeneration = annotationTypeMatches(Builder.class, child);
				}
				
				if (skipGeneration) {
					if (staticConstrRequired) {
						// @Data has asked us to generate a constructor, but we're going to skip this instruction, as an explicit 'make a constructor' annotation
						// will take care of it. However, @Data also wants a specific static name; this will be ignored; the appropriate way to do this is to use
						// the 'staticName' parameter of the @XArgsConstructor you've stuck on your type.
						// We should warn that we're ignoring @Data's 'staticConstructor' param.
						source.addWarning("Ignoring static constructor name: explicit @XxxArgsConstructor annotation present; its `staticName` parameter will be used.");
					}
					return;
				}
			}
		}
	}
	
	JCMethodDecl constr = createConstructor(staticConstrRequired ? AccessLevel.PRIVATE : level, onConstructor, typeNode, fields, allToDefault, suppressConstructorProperties, source);
	injectMethod(typeNode, constr);
	if (staticConstrRequired) {
		JCMethodDecl staticConstr = createStaticConstructor(staticName, level, typeNode, allToDefault ? List.<JavacNode>nil() : fields, source.get());
		injectMethod(typeNode, staticConstr);
	}
}
 

static boolean lookForGetter(JavacNode field, FieldAccess fieldAccess) {
	if (fieldAccess == FieldAccess.GETTER) return true;
	if (fieldAccess == FieldAccess.ALWAYS_FIELD) return false;
	
	// If @Getter(lazy = true) is used, then using it is mandatory.
	for (JavacNode child : field.down()) {
		if (child.getKind() != Kind.ANNOTATION) continue;
		if (annotationTypeMatches(Getter.class, child)) {
			AnnotationValues<Getter> ann = createAnnotation(Getter.class, child);
			if (ann.getInstance().lazy()) return true;
		}
	}
	return false;
}
 

public void generateConstructor(JavacNode typeNode, AccessLevel level, List<JCAnnotation> onConstructor, List<JavacNode> fields, String staticName, SkipIfConstructorExists skipIfConstructorExists, Boolean suppressConstructorProperties, JavacNode source) {
	boolean staticConstrRequired = staticName != null && !staticName.equals("");
	
	if (skipIfConstructorExists != SkipIfConstructorExists.NO && constructorExists(typeNode) != MemberExistsResult.NOT_EXISTS) return;
	if (skipIfConstructorExists != SkipIfConstructorExists.NO) {
		for (JavacNode child : typeNode.down()) {
			if (child.getKind() == Kind.ANNOTATION) {
				boolean skipGeneration = annotationTypeMatches(NoArgsConstructor.class, child) ||
						annotationTypeMatches(AllArgsConstructor.class, child) ||
						annotationTypeMatches(RequiredArgsConstructor.class, child);
				
				if (!skipGeneration && skipIfConstructorExists == SkipIfConstructorExists.YES) {
					skipGeneration = annotationTypeMatches(Builder.class, child);
				}
				
				if (skipGeneration) {
					if (staticConstrRequired) {
						// @Data has asked us to generate a constructor, but we're going to skip this instruction, as an explicit 'make a constructor' annotation
						// will take care of it. However, @Data also wants a specific static name; this will be ignored; the appropriate way to do this is to use
						// the 'staticName' parameter of the @XArgsConstructor you've stuck on your type.
						// We should warn that we're ignoring @Data's 'staticConstructor' param.
						source.addWarning("Ignoring static constructor name: explicit @XxxArgsConstructor annotation present; its `staticName` parameter will be used.");
					}
					return;
				}
			}
		}
	}
	
	JCMethodDecl constr = createConstructor(staticConstrRequired ? AccessLevel.PRIVATE : level, onConstructor, typeNode, fields, suppressConstructorProperties, source);
	injectMethod(typeNode, constr);
	if (staticConstrRequired) {
		JCMethodDecl staticConstr = createStaticConstructor(staticName, level, typeNode, fields, source.get());
		injectMethod(typeNode, staticConstr);
	}
}
 

public void generateConstructor(EclipseNode typeNode, AccessLevel level, List<EclipseNode> fields, String staticName, boolean skipIfConstructorExists, boolean suppressConstructorProperties, List<Annotation> onConstructor, ASTNode source) {
	boolean staticConstrRequired = staticName != null && !staticName.equals("");
	
	if (skipIfConstructorExists && constructorExists(typeNode) != MemberExistsResult.NOT_EXISTS) return;
	if (skipIfConstructorExists) {
		for (EclipseNode child : typeNode.down()) {
			if (child.getKind() == Kind.ANNOTATION) {
				if (annotationTypeMatches(NoArgsConstructor.class, child) ||
						annotationTypeMatches(AllArgsConstructor.class, child) ||
						annotationTypeMatches(RequiredArgsConstructor.class, child)) {
					
					if (staticConstrRequired) {
						// @Data has asked us to generate a constructor, but we're going to skip this instruction, as an explicit 'make a constructor' annotation
						// will take care of it. However, @Data also wants a specific static name; this will be ignored; the appropriate way to do this is to use
						// the 'staticName' parameter of the @XArgsConstructor you've stuck on your type.
						// We should warn that we're ignoring @Data's 'staticConstructor' param.
						typeNode.addWarning("Ignoring static constructor name: explicit @XxxArgsConstructor annotation present; its `staticName` parameter will be used.", source.sourceStart, source.sourceEnd);
					}
					return;
				}
			}
		}
	}
	
	ConstructorDeclaration constr = createConstructor(staticConstrRequired ? AccessLevel.PRIVATE : level, typeNode, fields, suppressConstructorProperties, source, onConstructor);
	injectMethod(typeNode, constr);
	if (staticConstrRequired) {
		MethodDeclaration staticConstr = createStaticConstructor(level, staticName, typeNode, fields, source);
		injectMethod(typeNode, staticConstr);
	}
}
 

/**
 * Generates a wither on the stated field.
 * 
 * Used by {@link HandleValue}.
 * 
 * The difference between this call and the handle method is as follows:
 * 
 * If there is a {@code lombok.experimental.Wither} annotation on the field, it is used and the
 * same rules apply (e.g. warning if the method already exists, stated access level applies).
 * If not, the wither is still generated if it isn't already there, though there will not
 * be a warning if its already there. The default access level is used.
 */
public void generateWitherForField(EclipseNode fieldNode, ASTNode pos, AccessLevel level) {
	for (EclipseNode child : fieldNode.down()) {
		if (child.getKind() == Kind.ANNOTATION) {
			if (annotationTypeMatches(Wither.class, child)) {
				//The annotation will make it happen, so we can skip it.
				return;
			}
		}
	}
	
	List<Annotation> empty = Collections.emptyList();
	createWitherForField(level, fieldNode, fieldNode, pos, false, empty, empty);
}
 

public void generateConstructor(JavacNode typeNode, AccessLevel level, List<JCAnnotation> onConstructor, List<JavacNode> fields, String staticName, boolean skipIfConstructorExists, boolean suppressConstructorProperties, JavacNode source) {
	boolean staticConstrRequired = staticName != null && !staticName.equals("");
	
	if (skipIfConstructorExists && constructorExists(typeNode) != MemberExistsResult.NOT_EXISTS) return;
	if (skipIfConstructorExists) {
		for (JavacNode child : typeNode.down()) {
			if (child.getKind() == Kind.ANNOTATION) {
				if (annotationTypeMatches(NoArgsConstructor.class, child) ||
						annotationTypeMatches(AllArgsConstructor.class, child) ||
						annotationTypeMatches(RequiredArgsConstructor.class, child)) {
					
					if (staticConstrRequired) {
						// @Data has asked us to generate a constructor, but we're going to skip this instruction, as an explicit 'make a constructor' annotation
						// will take care of it. However, @Data also wants a specific static name; this will be ignored; the appropriate way to do this is to use
						// the 'staticName' parameter of the @XArgsConstructor you've stuck on your type.
						// We should warn that we're ignoring @Data's 'staticConstructor' param.
						source.addWarning("Ignoring static constructor name: explicit @XxxArgsConstructor annotation present; its `staticName` parameter will be used.");
					}
					return;
				}
			}
		}
	}
	
	JCMethodDecl constr = createConstructor(staticConstrRequired ? AccessLevel.PRIVATE : level, onConstructor, typeNode, fields, suppressConstructorProperties, source.get());
	injectMethod(typeNode, constr);
	if (staticConstrRequired) {
		JCMethodDecl staticConstr = createStaticConstructor(staticName, level, typeNode, fields, source.get());
		injectMethod(typeNode, staticConstr);
	}
}
 

public void generateConstructor(
	EclipseNode typeNode, AccessLevel level, List<EclipseNode> fields, boolean allToDefault, String staticName, SkipIfConstructorExists skipIfConstructorExists,
	Boolean suppressConstructorProperties, List<Annotation> onConstructor, EclipseNode sourceNode) {
	
	ASTNode source = sourceNode.get();
	boolean staticConstrRequired = staticName != null && !staticName.equals("");
	
	if (skipIfConstructorExists != SkipIfConstructorExists.NO && constructorExists(typeNode) != MemberExistsResult.NOT_EXISTS) return;
	if (skipIfConstructorExists != SkipIfConstructorExists.NO) {
		for (EclipseNode child : typeNode.down()) {
			if (child.getKind() == Kind.ANNOTATION) {
				boolean skipGeneration = (annotationTypeMatches(NoArgsConstructor.class, child) ||
					annotationTypeMatches(AllArgsConstructor.class, child) ||
					annotationTypeMatches(RequiredArgsConstructor.class, child));
				
				if (!skipGeneration && skipIfConstructorExists == SkipIfConstructorExists.YES) {
					skipGeneration = annotationTypeMatches(Builder.class, child);
				}
				
				if (skipGeneration) {
					if (staticConstrRequired) {
						// @Data has asked us to generate a constructor, but we're going to skip this instruction, as an explicit 'make a constructor' annotation
						// will take care of it. However, @Data also wants a specific static name; this will be ignored; the appropriate way to do this is to use
						// the 'staticName' parameter of the @XArgsConstructor you've stuck on your type.
						// We should warn that we're ignoring @Data's 'staticConstructor' param.
						typeNode.addWarning(
							"Ignoring static constructor name: explicit @XxxArgsConstructor annotation present; its `staticName` parameter will be used.",
							source.sourceStart, source.sourceEnd);
					}
					return;
				}
			}
		}
	}
	
	ConstructorDeclaration constr = createConstructor(
		staticConstrRequired ? AccessLevel.PRIVATE : level, typeNode, fields, allToDefault,
		suppressConstructorProperties, sourceNode, onConstructor);
	injectMethod(typeNode, constr);
	if (staticConstrRequired) {
		MethodDeclaration staticConstr = createStaticConstructor(level, staticName, typeNode, allToDefault ? Collections.<EclipseNode>emptyList() : fields, source);
		injectMethod(typeNode, staticConstr);
	}
}
 

@Override public void visitType(JavacNode typeNode, JCClassDecl type) {
	AnnotationValues<FieldDefaults> fieldDefaults = null;
	JavacNode source = typeNode;
	
	boolean levelIsExplicit = false;
	boolean makeFinalIsExplicit = false;
	FieldDefaults fd = null;
	for (JavacNode jn : typeNode.down()) {
		if (jn.getKind() != Kind.ANNOTATION) continue;
		JCAnnotation ann = (JCAnnotation) jn.get();
		JCTree typeTree = ann.annotationType;
		if (typeTree == null) continue;
		String typeTreeToString = typeTree.toString();
		if (!typeTreeToString.equals("FieldDefaults") && !typeTreeToString.equals("lombok.experimental.FieldDefaults")) continue;
		if (!typeMatches(FieldDefaults.class, jn, typeTree)) continue;
		
		source = jn;
		fieldDefaults = createAnnotation(FieldDefaults.class, jn);
		levelIsExplicit = fieldDefaults.isExplicit("level");
		makeFinalIsExplicit = fieldDefaults.isExplicit("makeFinal");
		
		handleExperimentalFlagUsage(jn, ConfigurationKeys.FIELD_DEFAULTS_FLAG_USAGE, "@FieldDefaults");
		
		fd = fieldDefaults.getInstance();
		if (!levelIsExplicit && !makeFinalIsExplicit) {
			jn.addError("This does nothing; provide either level or makeFinal or both.");
		}
		
		if (levelIsExplicit && fd.level() == AccessLevel.NONE) {
			jn.addError("AccessLevel.NONE doesn't mean anything here. Pick another value.");
			levelIsExplicit = false;
		}
		
		deleteAnnotationIfNeccessary(jn, FieldDefaults.class);
		deleteImportFromCompilationUnit(jn, "lombok.AccessLevel");
		break;
	}
	
	if (fd == null && (type.mods.flags & (Flags.INTERFACE | Flags.ANNOTATION)) != 0) return;
	
	boolean defaultToPrivate = levelIsExplicit ? false : Boolean.TRUE.equals(typeNode.getAst().readConfiguration(ConfigurationKeys.FIELD_DEFAULTS_PRIVATE_EVERYWHERE));
	boolean defaultToFinal = makeFinalIsExplicit ? false : Boolean.TRUE.equals(typeNode.getAst().readConfiguration(ConfigurationKeys.FIELD_DEFAULTS_FINAL_EVERYWHERE));
	
	if (!defaultToPrivate && !defaultToFinal && fieldDefaults == null) return;
	AccessLevel fdAccessLevel = (fieldDefaults != null && levelIsExplicit) ? fd.level() : defaultToPrivate ? AccessLevel.PRIVATE : null;
	boolean fdToFinal = (fieldDefaults != null && makeFinalIsExplicit) ? fd.makeFinal() : defaultToFinal;
	
	generateFieldDefaultsForType(typeNode, source, fdAccessLevel, fdToFinal, false);
}
 

public void generateConstructor(
		EclipseNode typeNode, AccessLevel level, List<EclipseNode> fields, String staticName, SkipIfConstructorExists skipIfConstructorExists,
		Boolean suppressConstructorProperties, List<Annotation> onConstructor, EclipseNode sourceNode) {
	
	ASTNode source = sourceNode.get();
	boolean staticConstrRequired = staticName != null && !staticName.equals("");
	
	if (skipIfConstructorExists != SkipIfConstructorExists.NO && constructorExists(typeNode) != MemberExistsResult.NOT_EXISTS) return;
	if (skipIfConstructorExists != SkipIfConstructorExists.NO) {
		for (EclipseNode child : typeNode.down()) {
			if (child.getKind() == Kind.ANNOTATION) {
				boolean skipGeneration = (annotationTypeMatches(NoArgsConstructor.class, child) ||
						annotationTypeMatches(AllArgsConstructor.class, child) ||
						annotationTypeMatches(RequiredArgsConstructor.class, child));
				
				if (!skipGeneration && skipIfConstructorExists == SkipIfConstructorExists.YES) {
					skipGeneration = annotationTypeMatches(Builder.class, child);
				}
				
				if (skipGeneration) {
					if (staticConstrRequired) {
						// @Data has asked us to generate a constructor, but we're going to skip this instruction, as an explicit 'make a constructor' annotation
						// will take care of it. However, @Data also wants a specific static name; this will be ignored; the appropriate way to do this is to use
						// the 'staticName' parameter of the @XArgsConstructor you've stuck on your type.
						// We should warn that we're ignoring @Data's 'staticConstructor' param.
						typeNode.addWarning(
								"Ignoring static constructor name: explicit @XxxArgsConstructor annotation present; its `staticName` parameter will be used.",
								source.sourceStart, source.sourceEnd);
					}
					return;
				}
			}
		}
	}
	
	ConstructorDeclaration constr = createConstructor(
			staticConstrRequired ? AccessLevel.PRIVATE : level, typeNode, fields,
			suppressConstructorProperties, sourceNode, onConstructor);
	injectMethod(typeNode, constr);
	if (staticConstrRequired) {
		MethodDeclaration staticConstr = createStaticConstructor(level, staticName, typeNode, fields, source);
		injectMethod(typeNode, staticConstr);
	}
}