private boolean hasValidModifiers( VariableElement field ) { Set<Modifier> modifiers = field.getModifiers(); return modifiers.contains( Modifier.PUBLIC ) && !modifiers.contains( Modifier.STATIC ) && !modifiers.contains( Modifier.FINAL ); }
public static boolean isConstant(VariableElement field) { Set<Modifier> modifiers = field.getModifiers(); return modifiers != null && modifiers.containsAll(STATIC_FINAL); }
private Stream<CompilationMessage> validateFieldModifiers( Element recordElement ) { return fieldsIn( recordElement.getEnclosedElements() ).stream().filter( element -> { Set<Modifier> modifiers = element.getModifiers(); return !modifiers.contains( PUBLIC ) && !modifiers.contains( STATIC ); } ).map( element -> new RecordTypeError( element, "Record definition error: field %s#%s must be public", recordElement.getSimpleName(), element.getSimpleName() ) ); }
private static Stream<CompilationMessage> validateNonContextField( VariableElement field ) { Set<Modifier> modifiers = field.getModifiers(); if ( !modifiers.contains( Modifier.STATIC ) ) { return Stream.of( new FieldError( field, "Field %s#%s should be static", field.getEnclosingElement().getSimpleName(), field.getSimpleName() ) ); } return Stream.empty(); }
private Stream<CompilationMessage> validateFieldType( Element recordElement ) { return fieldsIn( recordElement.getEnclosedElements() ).stream() .filter( element -> !element.getModifiers().contains( STATIC ) ) .filter( element -> !fieldTypeVisitor.visit( element.asType() ) ) .map( element -> new RecordTypeError( element, "Record definition error: type of field %s#%s is not supported", recordElement.getSimpleName(), element.getSimpleName() ) ); }
@Override public boolean isValidField(VariableElement field) { if (field.getAnnotation(QueryType.class) != null) { return true; } else { return field.getAnnotation(skipAnn) == null && !field.getModifiers().contains(Modifier.TRANSIENT) && !field.getModifiers().contains(Modifier.STATIC); } }
@Override public boolean isBlockedField(VariableElement field) { if (field.getAnnotation(QueryType.class) != null) { return false; } else { return field.getAnnotation(skipAnn) != null || field.getModifiers().contains(Modifier.TRANSIENT) || field.getModifiers().contains(Modifier.STATIC); } }
@Override protected boolean hasPropertyGeneratorForField(VariableElement field, DeclaredTypeName fieldType) { return field.getModifiers().containsAll(TypeConstants.PUBLIC_STATIC_FINAL) && JSONTypes.JSON_PROPERTY.equals(fieldType); }
public static ParameterSpec get(VariableElement element) { TypeName type = TypeName.get(element.asType()); String name = element.getSimpleName().toString(); return ParameterSpec.builder(type, name) .addModifiers(element.getModifiers()) .build(); }
public static boolean isVisibleConstant(VariableElement field) { return isConstant(field) && !field.getModifiers().contains(Modifier.PRIVATE); }
@Override protected boolean hasPropertyGeneratorForField(VariableElement field, DeclaredTypeName fieldType) { if (field.getAnnotation(JSONColumn.class) == null) { return false; } if (field.getModifiers().containsAll(TypeConstants.PUBLIC_STATIC_FINAL)) { // Might be a constant, ignore return false; } // Check that all type args are concrete types return recursivelyCheckTypes(field, fieldType, new AtomicBoolean(false)); }
private boolean isValidUsageOfNavigationModelField(VariableElement element) { final TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); boolean valid = true; // Verify modifiers. Set<Modifier> modifiers = element.getModifiers(); if (modifiers.contains(PRIVATE) || modifiers.contains(STATIC)) { loggingUtil.error( element, "@DartModel field must not be private or static. (%s.%s)", enclosingElement.getQualifiedName(), element.getSimpleName()); valid = false; } return valid; } }
private static ParameterSpec getParameter(VariableElement parameter) { TypeName type = TypeName.get(parameter.asType()); return ParameterSpec.builder(type, computeParameterName(parameter, type)) .addModifiers(parameter.getModifiers()) .addAnnotations(getAnnotations(parameter)) .build(); }
private static ImmutableList<PropDefaultModel> extractFromField(Element enclosedElement) { if (enclosedElement.getKind() != ElementKind.FIELD) { return ImmutableList.of(); } final VariableElement variableElement = (VariableElement) enclosedElement; final Annotation propDefaultAnnotation = variableElement.getAnnotation(PropDefault.class); if (propDefaultAnnotation == null) { return ImmutableList.of(); } final ResType propDefaultResType = ((PropDefault) propDefaultAnnotation).resType(); final int propDefaultResId = ((PropDefault) propDefaultAnnotation).resId(); return ImmutableList.of( new PropDefaultModel( TypeName.get(variableElement.asType()), variableElement.getSimpleName().toString(), ImmutableList.copyOf(new ArrayList<>(variableElement.getModifiers())), variableElement, propDefaultResType, propDefaultResId)); }
private void generateConstructors(TypeSpec.Builder builder) { // copy the existing constructors for (ExecutableElement constructor : ElementFilter.constructorsIn( typeElement.getEnclosedElements())) { // constructor params List<? extends VariableElement> parameters = constructor.getParameters(); if (!parameters.isEmpty()) { MethodSpec.Builder constructorBuilder = MethodSpec.constructorBuilder(); constructorBuilder.addModifiers(constructor.getModifiers()); List<String> parameterNames = new ArrayList<>(); for (VariableElement parameter : parameters) { Modifier[] modifiers = parameter.getModifiers().toArray( new Modifier[parameter.getModifiers().size()]); String parameterName = parameter.getSimpleName().toString(); parameterNames.add(parameterName); ParameterSpec.Builder parameterBuilder = ParameterSpec.builder( TypeName.get(parameter.asType()), parameterName, modifiers); constructorBuilder.addParameter(parameterBuilder.build()); } // super parameter/arguments StringJoiner joiner = new StringJoiner(",", "(", ")"); parameterNames.forEach(joiner::add); constructorBuilder.addStatement("super" + joiner.toString()); builder.addMethod(constructorBuilder.build()); } } }
&& !variableElement.getModifiers().contains(Modifier.PRIVATE)) { unbindMethodBuilder.addStatement("$N.$N = $L", NameStore.Variable.RESOLVER,
.filter(element -> !element.getModifiers().contains(Modifier.PRIVATE) && !element.getModifiers().contains(Modifier.STATIC) && (!element.getModifiers().contains(Modifier.FINAL) || isImmutable())) .collect(Collectors.toSet());
private boolean processAuxField(VariableElement field) { List<Term> expression = sourceMapper.getExpression(memberPath(field)); if (expression.isEmpty() || !field.getModifiers().contains(Modifier.FINAL)) { reporter.withElement(field) .error("Auxiliary field '%s' have to be final and initialized to some value,"
private void checkForMutableFields(Protoclass protoclass, TypeElement element) { Elements elementUtils = protoclass.environment().processing().getElementUtils(); for (VariableElement field : ElementFilter.fieldsIn( elementUtils.getAllMembers(CachingElements.getDelegate(element)))) { if (!field.getModifiers().contains(Modifier.FINAL)) { Reporter report = protoclass.report(); boolean ownField = CachingElements.equals(element, field.getEnclosingElement()); if (ownField) { report.withElement(field) .warning(About.INCOMPAT, "Avoid introduction of fields (except constants) in abstract value types"); } else { report.warning(About.INCOMPAT, "Abstract value type inherits mutable fields"); } } } }
if (field.getModifiers().contains(Modifier.STATIC)) { reporter.withElement(field) .error("@Encoding.Impl field '%s' cannot be static", if (!field.getModifiers().contains(Modifier.PRIVATE)) { reporter.withElement(field) .error("@Encoding.Impl field '%s' must be private. Other auxiliary fields may be of whatever visibility,"