private void parseBindViews(Element element, Map<TypeElement, BindingSet.Builder> builderMap, Set<TypeElement> erasedTargetNames) { TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); TypeMirror elementType = element.asType(); String erasedType = doubleErasure(elementType); TypeMirror viewType = null; FieldCollectionViewBinding.Kind kind = null; if (elementType.getKind() == TypeKind.ARRAY) { ArrayType arrayType = (ArrayType) elementType; viewType = arrayType.getComponentType(); kind = FieldCollectionViewBinding.Kind.ARRAY; } else if (LIST_TYPE.equals(erasedType)) { DeclaredType declaredType = (DeclaredType) elementType; List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); if (typeArguments.size() != 1) { error(element, "@%s List must have a generic component. (%s.%s)", BindViews.class.getSimpleName(), enclosingElement.getQualifiedName(), element.getSimpleName()); hasError = true; } else { if (viewType != null && viewType.getKind() == TypeKind.TYPEVAR) { TypeVariable typeVariable = (TypeVariable) viewType; viewType = typeVariable.getUpperBound();
private void buildGenericType(TypeMirror type, Map<String, Integer> typeVariableIndexes, StringBuilder builder) { if (type.getKind() == TypeKind.DECLARED) { DeclaredType declaredType = (DeclaredType) type; if (declaredType.getTypeArguments().isEmpty()) { builder.append(type.toString()).append(".class"); } else { TypeElement typeElement = (TypeElement) declaredType.asElement(); builder.append("com.dslplatform.json.runtime.Generics.makeParameterizedType(").append(typeElement.getQualifiedName()).append(".class"); for (TypeMirror typeArgument : declaredType.getTypeArguments()) { builder.append(", "); buildGenericType(typeArgument, typeVariableIndexes, builder); } builder.append(")"); } } else if (type.getKind() == TypeKind.ARRAY) { ArrayType arrayType = (ArrayType) type; builder.append("com.dslplatform.json.runtime.Generics.makeGenericArrayType("); buildGenericType(arrayType.getComponentType(), typeVariableIndexes, builder); builder.append(")"); } else if (typeVariableIndexes.containsKey(type.toString())) { builder.append("actualTypes[").append(typeVariableIndexes.get(type.toString())).append("]"); } }
private PrismWriter getWriter(ExecutableElement m,String access, Map<DeclaredType,String> otherPrisms) { Elements elements = processingEnv.getElementUtils(); Types types = processingEnv.getTypeUtils(); WildcardType q = types.getWildcardType(null,null); TypeMirror enumType = types.getDeclaredType(elements.getTypeElement("java.lang.Enum"),q); TypeMirror typem = m.getReturnType(); PrismWriter result = null; if(typem.getKind() == TypeKind.ARRAY) { typem = ((ArrayType)typem).getComponentType(); result = new PrismWriter(m,true,access); } else { result = new PrismWriter(m,false,access); if(types.isSameType(type,elements.getTypeElement("java.lang.String").asType())) { } else if (type.asElement().equals(elements.getTypeElement("java.lang.Class"))) { result.setPrismType("String"); result.setM2pFormat("%s.getSimpleName().toString()"); } else if (types.isSubtype(type,elements.getTypeElement("java.lang.annotation.Annotation").asType())) { result.setMirrorType("AnnotationMirror"); DeclaredType annType = (DeclaredType)type; } else { String prismType = annType.asElement().getSimpleName().toString(); result.setPrismType(prismType); result.setM2pFormat(prismType + ".getInstance(%s)");
public void canBePutInABundle(Element element, ElementValidation valid) { TypeMirror typeMirror = element.asType(); String typeString = element.asType().toString(); if (!isKnownBundleCompatibleType(typeString)) { if (typeMirror instanceof ArrayType) { ArrayType arrayType = (ArrayType) element.asType(); typeMirror = arrayType.getComponentType(); } if (typeMirror.getKind() != TypeKind.NONE) { TypeMirror parcelableType = annotationHelper.typeElementFromQualifiedName(CanonicalNameConstants.PARCELABLE).asType(); TypeMirror serializableType = annotationHelper.typeElementFromQualifiedName("java.io.Serializable").asType(); if (typeString.startsWith(CanonicalNameConstants.SPARSE_ARRAY)) { DeclaredType declaredType = (DeclaredType) typeMirror; List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); if (typeArguments.size() != 1 || !annotationHelper.isSubtype(typeArguments.get(0), parcelableType)) { valid.addError("Unrecognized type. The type argument of SparseArray should implement Parcelable."); } } else if (!annotationHelper.isSubtype(typeMirror, parcelableType) && !annotationHelper.isSubtype(typeMirror, serializableType) && !parcelerHelper.isParcelType(typeMirror)) { valid.addError("Unrecognized type. Please let your attribute be primitive or implement Serializable or Parcelable or an annotated Parceler bean."); } } } }
TypeElement jClass = elems.getTypeElement("java.lang.Class"); TypeElement jString = elems.getTypeElement("java.lang.String"); Element tclassDoc = types.asElement(t); switch (t.getKind()) { case ARRAY: { TypeMirror ct = ((ArrayType) t).getComponentType(); switch (ct.getKind()) { case BOOLEAN: return "jbooleanArray"; case BYTE: return "jbyteArray"; case ARRAY: case DECLARED: return "jobjectArray"; default: throw new Error(ct.toString()); if (tclassDoc.equals(jString)) return "jstring"; else if (types.isAssignable(t, throwable.asType())) return "jthrowable"; else if (types.isAssignable(t, jClass.asType())) return "jclass"; else
public Type(TypeMirror type) { if (type.getKind() == TypeKind.VOID) { packageName = ""; enclosingNames = ""; typeArguments = emptyList(); array = false; } else if (type.getKind() == TypeKind.ARRAY) { packageName = ""; enclosingNames = ""; simpleName = ""; typeArguments = singletonList(new Type(asArray(type).getComponentType())); array = true; } else if (isType(type)) { DeclaredType declaredType = asDeclared(type); Element element = declaredType.asElement(); simpleName = element.getSimpleName().toString(); typeArguments = from(declaredType.getTypeArguments()) .transform(TYPE_MIRROR_TO_TYPE) .toList(); Element enclosingElement = element.getEnclosingElement(); while (enclosingElement != null && enclosingElement.getKind() != ElementKind.PACKAGE) { enclosingElementNames.insert(0, enclosingElement.getSimpleName() + "."); enclosingElement = enclosingElement.getEnclosingElement();
return typeOf(((ArrayType) typeMirror).getComponentType()).array(); } else if (typeMirror instanceof WildcardType) { final WildcardType wildcardType = (WildcardType) typeMirror; } else if (typeMirror instanceof TypeVariable) { final TypeVariable typeVariable = (TypeVariable) typeMirror; final String name = typeVariable.asElement().getSimpleName().toString(); return typeNamed(name); } else if (typeMirror instanceof DeclaredType) { final DeclaredType declaredType = (DeclaredType) typeMirror; final TypeElement typeElement = (TypeElement) declaredType.asElement(); final TypeMirror enclosingType = declaredType.getEnclosingType(); if (enclosingType != null && enclosingType.getKind() == TypeKind.DECLARED) { return typeOf(enclosingType).nestedType(typeElement.getSimpleName().toString()); final String name = typeElement.getQualifiedName().toString(); final JType rawType = JTypes.typeNamed(name); final List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); if (typeArguments.isEmpty()) { return rawType; switch (typeMirror.getKind()) { case VOID: return JType.VOID; switch (typeMirror.getKind()) { case BOOLEAN: return JType.BOOLEAN; case BYTE: return JType.BYTE;
boolean map = false; if (typeMirror.getKind() == TypeKind.DECLARED) { logger.finest("CompileTimeTypeInfo DECLARED typeMirror " + typeMirror); Element element = ((DeclaredType) typeMirror).asElement(); if (element.getKind().isClass() || element.getKind().isInterface()) { tempTypeElement = (TypeElement) element; logger.finest("element is class or interface " + tempTypeElement); collection = !map && find("java.util.Collection", tempTypeElement); aux = ((DeclaredType) typeMirror).getTypeArguments(); actualGenericTypeArguments = new ArrayList<String>(); for (TypeMirror typeMirror : aux) { actualGenericTypeArguments.add(typeMirror.toString()); } else if (typeMirror.getKind() == TypeKind.ARRAY) { aux = Arrays.asList(((ArrayType) typeMirror).getComponentType()); actualGenericTypeArguments = Arrays.asList(aux.get(0).toString()); } else {
if (expectedType.getKind() == TypeKind.DECLARED) { DeclaredType declaredType = (DeclaredType) expectedType; List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments(); TypeElement declaredElement = (TypeElement) declaredType.asElement(); } else if (expectedType.getKind() == TypeKind.ARRAY) { ArrayType arrayType = (ArrayType) expectedType; TypeMirror componentType = arrayType.getComponentType(); return resolveResponseClass(componentType, holder, false).array();
for (TypeMirror smart : smarts) { if (smart != null) { if (smart.getKind() == TypeKind.DECLARED) { for (DeclaredType subtype : getSubtypesOf(env, (DeclaredType) smart)) { TypeElement elem = (TypeElement) subtype.asElement(); if ((Utilities.isShowDeprecatedMembers() || !elements.isDeprecated(elem)) && !Utilities.isExcluded(elem.getQualifiedName())) { results.add(itemFactory.createTypeItem(env.getController(), elem, subtype, anchorOffset, env.getReferencesCount(), elements.isDeprecated(elem), false, false, false, true, false)); } else if (smart.getKind() == TypeKind.ARRAY) { try { TypeMirror tm = smart; while (tm.getKind() == TypeKind.ARRAY) { tm = ((ArrayType) tm).getComponentType(); if (tm.getKind().isPrimitive() && startsWith(env, tm.toString())) { results.add(itemFactory.createArrayItem(env.getController(), (ArrayType) smart, anchorOffset, env.getReferencesCount(), env.getController().getElements())); } else if ((tm.getKind() == TypeKind.DECLARED || tm.getKind() == TypeKind.ERROR) && startsWith(env, ((DeclaredType) tm).asElement().getSimpleName().toString())) { results.add(itemFactory.createArrayItem(env.getController(), (ArrayType) smart, anchorOffset, env.getReferencesCount(), env.getController().getElements()));
/** * Gets the parameter type argument at the given index of the given type. * * @return if the given type represents a parameterized type, then the * indexed parameter type argument. Otherwise null. */ TypeMirror getTypeParameter(Element e, TypeMirror mirror, int index, boolean checkTarget) { if (mirror.getKind() == TypeKind.ARRAY) return ((ArrayType)mirror).getComponentType(); if (mirror.getKind() != TypeKind.DECLARED) return null; if (checkTarget) { TypeMirror target = getTargetEntityType(e); if (target != null) return target; } List<? extends TypeMirror> params = ((DeclaredType)mirror).getTypeArguments(); TypeMirror param = (params == null || params.size() < index+1) ? typeUtility.getNullType() : params.get(index); if (param.getKind() == TypeKind.NULL || param.getKind() == TypeKind.WILDCARD) { logger.warn(_loc.get("generic-type-param", e, getDeclaredType(e), e.getEnclosingElement())); } return param; }
private static boolean isReferenceArrayType(TypeMirror type) { return type.getKind() == TypeKind.ARRAY && !((ArrayType) type).getComponentType().getKind().isPrimitive(); }
/** * Get the element name of the class the given mirror represents. If the * mirror is primitive then returns the corresponding boxed class name. * If the mirror is parameterized returns only the generic type i.e. * if the given declared type is * <code>java.util.Set<java.lang.String></code> this method will * return <code>java.util.Set</code>. */ String getDeclaredTypeName(TypeMirror mirror, boolean box, boolean persistentCollection) { if (mirror == null || mirror.getKind() == TypeKind.NULL || mirror.getKind() == TypeKind.WILDCARD) return "java.lang.Object"; if (mirror.getKind() == TypeKind.ARRAY) { if(persistentCollection) { TypeMirror comp = ((ArrayType)mirror).getComponentType(); return getDeclaredTypeName(comp, false); } else { return mirror.toString(); } } mirror = box ? box(mirror) : mirror; if (isPrimitive(mirror)) return ((PrimitiveType)mirror).toString(); Element elem = typeUtility.asElement(mirror); if (elem == null) throw new RuntimeException(_loc.get("mmg-no-type", mirror).getMessage()); return elem.toString(); }
private final void buildMappedType(StringBuilder stringBuilder, TypeMirror type) { switch (type.getKind()) { case DECLARED: DeclaredType declaredType = (DeclaredType) type; Element element = declaredType.asElement(); String elementName = element.toString(); String mapped = context.getTypeMappingTarget(elementName); stringBuilder.append(mapped); } else { stringBuilder.append(element.getSimpleName().toString()); if (!"any".equals(mapped) && !declaredType.getTypeArguments().isEmpty()) { stringBuilder.append("<"); for (TypeMirror arg : declaredType.getTypeArguments()) { buildMappedType(stringBuilder, arg); stringBuilder.append(", "); buildMappedType(stringBuilder, ((javax.lang.model.type.ArrayType) type).getComponentType()); stringBuilder.append("[]"); break; break; default: if (context.isMappedType(type.toString())) { stringBuilder.append(context.getTypeMappingTarget(type.toString())); } else { stringBuilder.append(type.toString());
public static String getTypeId(TypeMirror mirror) { switch (mirror.getKind()) { case BOOLEAN: return "Boolean"; return "Long"; case DECLARED: return fixECJBinaryNameIssue(((DeclaredType) mirror).asElement().getSimpleName().toString()); case ARRAY: return getTypeId(((ArrayType) mirror).getComponentType()) + "Array"; case VOID: return "Void"; throw new CompileErrorException("Type error " + mirror); default: throw new RuntimeException("Unknown type specified " + mirror.getKind() + " mirror: " + mirror);
public static TypeElement fromTypeMirror(TypeMirror mirror) { switch (mirror.getKind()) { case DECLARED: return (TypeElement) ((DeclaredType) mirror).asElement(); case ARRAY: return fromTypeMirror(((ArrayType) mirror).getComponentType()); default: return null; } }
/** * Returns a method name from the {@code android.content.res.Resources} class for array resource * binding, null if the element type is not supported. */ private static @Nullable FieldResourceBinding.Type getArrayResourceMethodName(Element element) { TypeMirror typeMirror = element.asType(); if (TYPED_ARRAY_TYPE.equals(typeMirror.toString())) { return FieldResourceBinding.Type.TYPED_ARRAY; } if (TypeKind.ARRAY.equals(typeMirror.getKind())) { ArrayType arrayType = (ArrayType) typeMirror; String componentType = arrayType.getComponentType().toString(); if (STRING_TYPE.equals(componentType)) { return FieldResourceBinding.Type.STRING_ARRAY; } else if ("int".equals(componentType)) { return FieldResourceBinding.Type.INT_ARRAY; } else if ("java.lang.CharSequence".equals(componentType)) { return FieldResourceBinding.Type.TEXT_ARRAY; } } return null; }
private TypeMirror getArrayComponentType(TypeMirror typeMirror) { TypeMirror compType = null; if (typeMirror instanceof ArrayType) { ArrayType propType = (ArrayType) typeMirror; compType = propType.getComponentType(); } else if (typeMirror instanceof DeclaredType) { TypeElement typeElem = (TypeElement)((DeclaredType)typeMirror).asElement(); String qname = typeElem.getQualifiedName().toString(); if (qname.equals("java.util.ArrayList") || qname.equals("java.util.List")) { Collection<? extends TypeMirror> args = ((DeclaredType) typeMirror).getTypeArguments(); if (args.size() == 1) compType = args.iterator().next(); } } return compType; } }
private void checkRelatedPropertyRecursively(TypeMirror returnType, DeclaredType discoveredBy, String access, Element inside, Stack<String> path) { String typeName = returnType.toString(); if (structs.containsKey(typeName) || typeSupport.isSupported(typeName)) return; if (returnType.getKind() == TypeKind.DECLARED) { DeclaredType declaredType = (DeclaredType) returnType; String rawTypeName = declaredType.asElement().toString(); if (!structs.containsKey(rawTypeName) && !typeSupport.isSupported(rawTypeName)) { Element el = declaredType.asElement(); findStructs(el, discoveredBy, el + " is referenced as " + access + " from '" + inside.asType() + "' through CompiledJson annotation.", path, null, null); } for (TypeMirror typeArgument : declaredType.getTypeArguments()) { checkRelatedPropertyRecursively(typeArgument, discoveredBy, access, inside, path); } } else if (returnType.getKind() == TypeKind.ARRAY) { ArrayType at = (ArrayType) returnType; checkRelatedPropertyRecursively(at.getComponentType(), discoveredBy, access, inside, path); } else { Element el = elements.getTypeElement(typeName); if (el != null) { findStructs(el, discoveredBy, el + " is referenced as " + access + " from '" + inside.asType() + "' through CompiledJson annotation.", path, null, null); } } }
if (tm.getKind() == TypeKind.WILDCARD) { TypeMirror extendsBound = ((WildcardType) tm).getExtendsBound(); TypeMirror rct = resolveCapturedTypeInt(info, extendsBound != null ? extendsBound : ((WildcardType) tm).getSuperBound()); if (rct != null) { return rct.getKind() == TypeKind.WILDCARD ? rct : info.getTypes().getWildcardType(extendsBound != null ? rct : null, extendsBound == null ? rct : null); if (tm.getKind() == TypeKind.DECLARED) { DeclaredType dt = (DeclaredType) tm; TypeElement el = (TypeElement) dt.asElement(); if (((DeclaredType)el.asType()).getTypeArguments().size() != dt.getTypeArguments().size()) { return info.getTypes().getDeclaredType(el); final TypeMirror enclosingType = dt.getEnclosingType(); if (enclosingType.getKind() == TypeKind.DECLARED) { return info.getTypes().getDeclaredType((DeclaredType) enclosingType, el, typeArguments.toArray(new TypeMirror[0])); } else { return info.getTypes().getDeclaredType(el, typeArguments.toArray(new TypeMirror[0])); if (tm.getKind() == TypeKind.ARRAY) { ArrayType at = (ArrayType) tm; TypeMirror componentType = resolveCapturedTypeInt(info, at.getComponentType()); switch (componentType.getKind()) { case VOID: