Java Code Examples for javax.lang.model.type.DeclaredType

The following are top voted examples for showing how to use javax.lang.model.type.DeclaredType. These examples are extracted from open source projects. You can vote up the examples you like and your votes will be used in our system to generate more good examples.
Example 1
Project: incubator-netbeans   File: EncapsulateFieldRefactoringPlugin.java   View source code 6 votes vote down vote up
public static ExecutableElement findMethod(CompilationInfo javac, TypeElement clazz, String name, List<? extends VariableElement> params, boolean includeSupertypes) {
    if (name == null || name.length() == 0) {
        return null;
    }

    TypeElement c = clazz;
    while (true) {
        for (Element elm : c.getEnclosedElements()) {
            if (ElementKind.METHOD == elm.getKind()) {
                ExecutableElement m = (ExecutableElement) elm;
                if (name.contentEquals(m.getSimpleName())
                        && compareParams(javac, params, m.getParameters())
                        && isAccessible(javac, clazz, m)) {
                    return m;
                }
            }
        }

        TypeMirror superType = c.getSuperclass();
        if (!includeSupertypes || superType.getKind() == TypeKind.NONE) {
            return null;
        }
        c = (TypeElement) ((DeclaredType) superType).asElement();
    }
}
 
Example 2
Project: incubator-netbeans   File: GeneratorUtilitiesTest.java   View source code 6 votes vote down vote up
public void validate(CompilationInfo info) {
    TypeElement test = info.getElements().getTypeElement("test.Test");
    VariableElement var = ElementFilter.fieldsIn(test.getEnclosedElements()).get(0);

    List<? extends ExecutableElement> methods = ElementFilter.methodsIn(test.getEnclosedElements());
    assertEquals(1, methods.size());
    ExecutableElement method = methods.get(0);

    TypeMirror type = info.getTypes().asMemberOf((DeclaredType)test.asType(), var);
    if (getter) {
        assertTrue(info.getTypes().isSameType(type, method.getReturnType()));
        assertEquals(type.getKind() == TypeKind.BOOLEAN ? "isTest" : "getTest", method.getSimpleName().toString());
        assertEquals(0, method.getParameters().size());
    } else {
        assertTrue(info.getTypes().isSameType(info.getTypes().getNoType(TypeKind.VOID), method.getReturnType()));
        assertEquals("setTest", method.getSimpleName().toString());
        assertEquals(1, method.getParameters().size());
        assertTrue(info.getTypes().isSameType(type, method.getParameters().get(0).asType()));
    }
}
 
Example 3
Project: openjdk-jdk10   File: DependenciesTest.java   View source code 6 votes vote down vote up
@Override
public Void visitClass(ClassTree node, Void p) {
    TypeElement te = (TypeElement) trees.getElement(getCurrentPath());
    Set<PhaseDescription> expected = new HashSet<>();

    for (AnnotationMirror am : getTriggersCompleteAnnotation(te)) {
        TypeMirror of = (TypeMirror) findAttribute(am, "of").getValue();
        Name ofName = elements.getBinaryName((TypeElement) ((DeclaredType) of).asElement());
        Element at = (Element) findAttribute(am, "at").getValue();
        Phase phase = Phase.valueOf(at.getSimpleName().toString());
        expected.add(new PhaseDescription(ofName.toString(), phase));
    }

    if (!expected.isEmpty())
        topLevel2Expected.put(elements.getBinaryName(te).toString(), expected);

    return super.visitClass(node, p);
}
 
Example 4
Project: incubator-netbeans   File: MalformedFormatString.java   View source code 6 votes vote down vote up
/**
 * Unbox a wrapper type into a TypeKind. Some additional types are mapped to TypeKinds which cannot really appear in 
 * expressions (at least I hope)
 * 
 * @param tm
 * @return 
 */
private static TypeKind unboxBoxed(TypeMirror tm) {
    TypeElement te = (TypeElement)((DeclaredType)tm).asElement();
    String qn = te.getQualifiedName().toString();
    if (!qn.startsWith("java.lang.")) { // NO18N
        if (qn.equals("java.math.BigInteger")) { // NOI18N
            return TypeKind.WILDCARD;
        }
        return null;
    }
    switch (qn.substring(10)) {
        case "Short": return TypeKind.SHORT; // NOI18N
        case "Long": return TypeKind.LONG; // NOI18N
        case "Byte": return TypeKind.BYTE; // NOI18N
        case "Integer": return TypeKind.INT; // NOI18N
        case "Double": return TypeKind.DOUBLE; // NOI18N
        case "Float": return TypeKind.FLOAT; // NOI18N
        case "Character": return TypeKind.CHAR; // NOI18N
        case "String": return TypeKind.OTHER; // NOI18N
        case "Object": return TypeKind.PACKAGE; // NOI18N
    }
    return null;
}
 
Example 5
Project: incubator-netbeans   File: Utilities.java   View source code 6 votes vote down vote up
/**
 * Convert typemirror of an anonymous class to supertype/iface
 * 
 * @return typemirror of supertype/iface, initial tm if not anonymous
 */
public static TypeMirror convertIfAnonymous(TypeMirror tm) {
    //anonymous class?
    Set<ElementKind> fm = EnumSet.of(ElementKind.METHOD, ElementKind.FIELD);
    if (tm instanceof DeclaredType) {
        Element el = ((DeclaredType) tm).asElement();
        //XXX: the null check is needed for lambda type, not covered by test:
        if (el != null && (el.getSimpleName().length() == 0 || fm.contains(el.getEnclosingElement().getKind()))) {
            List<? extends TypeMirror> interfaces = ((TypeElement) el).getInterfaces();
            if (interfaces.isEmpty()) {
                tm = ((TypeElement) el).getSuperclass();
            } else {
                tm = interfaces.get(0);
            }
        }
    }
    return tm;
}
 
Example 6
Project: GitHub   File: EasyMVPProcessor.java   View source code 6 votes vote down vote up
private String findViewTypeOfPresenter(TypeElement presenterElement) {
    TypeElement currentClass = presenterElement;
    while (currentClass != null) {
        if (currentClass.getSuperclass() instanceof DeclaredType) {
            List<? extends TypeMirror> superClassParameters =
                    ((DeclaredType) currentClass.getSuperclass()).getTypeArguments();

            if (superClassParameters.size() == 1) {
                String type = superClassParameters.get(0).toString();
                if (!"V".equals(type)) return type;
            }
        }
        currentClass = getSuperClass(currentClass);
    }
    return "";
}
 
Example 7
Project: incubator-netbeans   File: SpringXMLConfigCompletionItem.java   View source code 6 votes vote down vote up
@Override
public StringBuilder visitDeclared(DeclaredType t, Boolean p) {
    Element e = t.asElement();
    if (e instanceof TypeElement) {
        TypeElement te = (TypeElement)e;
        DEFAULT_VALUE.append((p ? te.getQualifiedName() : te.getSimpleName()).toString());
        Iterator<? extends TypeMirror> it = t.getTypeArguments().iterator();
        if (it.hasNext()) {
            DEFAULT_VALUE.append("<"); //NOI18N
            while(it.hasNext()) {
                visit(it.next(), p);
                if (it.hasNext())
                    DEFAULT_VALUE.append(", "); //NOI18N
            }
            DEFAULT_VALUE.append(">"); //NOI18N
        }
        return DEFAULT_VALUE;
    } else {
        return DEFAULT_VALUE.append(UNKNOWN); //NOI18N
    }
}
 
Example 8
Project: incubator-netbeans   File: EnumValueCompleter.java   View source code 6 votes vote down vote up
@Override
public Completer createCompleter(CompletionContext ctx) {
    FxProperty p = ctx.getEnclosingProperty();
    if (p == null || p.getType() == null) {
        return null;
    }
    TypeMirror m = p.getType().resolve(ctx.getCompilationInfo());
    if (m.getKind() == TypeKind.BOOLEAN) {
        return new EnumValueCompleter(ctx);
    }
    if (m.getKind() != TypeKind.DECLARED) {
        return null;
    }
    DeclaredType t = (DeclaredType)m;
    TypeElement tel = (TypeElement)t.asElement();
    if (tel.getQualifiedName().contentEquals("java.lang.Boolean")) {
        return new EnumValueCompleter(ctx);
    }
    if (tel.getKind() == ElementKind.ENUM) {
        return new EnumValueCompleter(ctx, tel);
    } else {
        return null;
    }
}
 
Example 9
Project: GitHub   File: ValueType.java   View source code 6 votes vote down vote up
TypeHierarchyCollector createTypeHierarchyCollector(final Reporter reporter, final Element element) {
  return new TypeHierarchyCollector() {
    @Override
    protected String stringify(DeclaredType input, TypevarContext context) {
      TypeStringProvider provider = new TypeStringProvider(
          reporter,
          element,
          input,
          newTypeStringResolver(),
          context.parameters.toArray(new String[0]),
          context.arguments.toArray(new String[0]));
      provider.collectUnresolvedYetArgumentsTo(this.unresolvedYetArguments);
      provider.process();
      return provider.returnTypeName();
    }
  };
}
 
Example 10
Project: GitHub   File: AccessorAttributesCollector.java   View source code 6 votes vote down vote up
static TypeMirror resolveReturnType(
    ProcessingEnvironment processing,
    ExecutableElement method,
    TypeElement typeElement) {
  method = CachingElements.getDelegate(method);
  TypeMirror returnType = method.getReturnType();

  // We do not support parametrized accessor methods,
  // but we do support inheriting parametrized accessors, which
  // we supposedly parametrized with actual type parameters as
  // our target class could not define formal type parameters also.
  if (returnType.getKind() == TypeKind.TYPEVAR) {
    return asInheritedMemberReturnType(processing, typeElement, method);
  } else if (returnType.getKind() == TypeKind.DECLARED
      || returnType.getKind() == TypeKind.ERROR) {
    if (!((DeclaredType) returnType).getTypeArguments().isEmpty()) {
      return asInheritedMemberReturnType(processing, typeElement, method);
    }
  }
  return returnType;
}
 
Example 11
Project: GitHub   File: Proto.java   View source code 6 votes vote down vote up
@Value.Lazy
List<TypeElement> includedTypes() {
  Optional<IncludeMirror> includes = include();

  ImmutableList<TypeMirror> typeMirrors = includes.isPresent()
      ? ImmutableList.copyOf(includes.get().valueMirror())
      : ImmutableList.<TypeMirror>of();

  FluentIterable<TypeElement> typeElements = FluentIterable.from(typeMirrors)
      .filter(DeclaredType.class)
      .transform(DeclatedTypeToElement.FUNCTION);

  ImmutableSet<String> uniqueTypeNames = typeElements
      .filter(IsPublic.PREDICATE)
      .transform(ElementToName.FUNCTION)
      .toSet();

  if (uniqueTypeNames.size() != typeMirrors.size()) {
    report().annotationNamed(IncludeMirror.simpleName())
        .warning("Some types were ignored, non-supported for inclusion: duplicates,"
            + " non declared reference types, non-public");
  }

  return typeElements.toList();
}
 
Example 12
Project: domino   File: RequestFactorySourceWriter.java   View source code 6 votes vote down vote up
private MethodSpec makeOverrideMethod(ExecutableElement method) {
    TypeName requestTypeName = getRequestClassName(method);
    DeclaredType responseReturnType = (DeclaredType) method.getReturnType();
    TypeMirror responseBean = responseReturnType.getTypeArguments().get(0);


    MethodSpec.Builder request = MethodSpec.methodBuilder(method.getSimpleName().toString())
            .returns(ParameterizedTypeName.get(ClassName.get(Response.class), ClassName.get(responseBean)))
            .addModifiers(Modifier.PUBLIC)
            .addAnnotation(Override.class);

    String initializeStatement = "return new " + processorElement.simpleName() + "_" + method.getSimpleName();
    if (!method.getParameters().isEmpty()) {
        request.addParameter(requestTypeName, "request");
        request.addStatement(initializeStatement + "(request)");
    } else
        request.addStatement(initializeStatement + "($T.VOID_REQUEST)", RequestBean.class);


    return request.build();
}
 
Example 13
Project: GitHub   File: TypeStringProvider.java   View source code 6 votes vote down vote up
private void appendTypeArguments(TypeMirror type, DeclaredType declaredType) {
  List<? extends TypeMirror> arguments = declaredType.getTypeArguments();
  if (!arguments.isEmpty()) {
    buffer.append('<');
    boolean notFirst = false;
    for (TypeMirror argument : arguments) {
      typeAnnotationHandle(argument);
      if (notFirst) {
        buffer.append(',').append(' ');
      }
      notFirst = true;
      int mark = buffer.length();
      caseType(argument);
      cutTypeArgument(type, mark);
    }
    buffer.append('>');
  }
}
 
Example 14
Project: incubator-netbeans   File: ControllerGenerator.java   View source code 6 votes vote down vote up
@Override
public TypeMirror visitDeclared(DeclaredType t, CompilationInfo p) {
    if (t.getTypeArguments().isEmpty()) {
        return t;
    }
    List<TypeMirror> newArgs = new ArrayList<TypeMirror>(t.getTypeArguments().size());
    for (TypeMirror tm : t.getTypeArguments()) {
        newArgs.add(visit(tm, p));
    }
    
    TypeMirror enclosing = t.getEnclosingType();
    if (enclosing != null) {
        enclosing = visit(enclosing, p);
    }
    
    return p.getTypes().getDeclaredType(
        (DeclaredType)enclosing,
        (TypeElement)t.asElement(), 
        newArgs.toArray(new TypeMirror[newArgs.size()]));
}
 
Example 15
Project: incubator-netbeans   File: UseSuperTypeRefactoringPlugin.java   View source code 6 votes vote down vote up
private void replaceWithSuperType(TreePath path, VariableTree oldVarTree, VariableElement varElement, Element superTypeElement) {
    Types types = workingCopy.getTypes();
    TypeMirror supTypeErasure = types.erasure(superTypeElement.asType());
    DeclaredType varType = (DeclaredType) varElement.asType();
    TypeMirror theType = null;
    List<TypeMirror> supertypes = new LinkedList(types.directSupertypes(varType));
    while(!supertypes.isEmpty()) {
        TypeMirror supertype = supertypes.remove(0);
        if(types.isSameType(types.erasure(supertype), supTypeErasure)) {
            theType = supertype;
            break;
        }
        supertypes.addAll(types.directSupertypes(supertype));
    }
    
    if(theType == null) {
        theType = supTypeErasure;
    }
    Tree superTypeTree = make.Type(theType);
  
    ExpressionTree oldInitTree = oldVarTree.getInitializer();
    ModifiersTree oldModifiers = oldVarTree.getModifiers();
    Tree newTree = make.Variable(oldModifiers, oldVarTree.getName(), 
            superTypeTree, oldInitTree);
    rewrite(oldVarTree, newTree);
}
 
Example 16
Project: incap   File: NRelatedToOneAP.java   View source code 6 votes vote down vote up
private Map<String, Set<? extends Element>> processElements(Set<? extends Element> annotatedElements) {
  final Map<String, Set<? extends Element>> mapGeneratedFileNameToOrginatingElements = new HashMap<>();
  for (Element annotatedElement : annotatedElements) {
    String nameOfClassContainingElement = getEnclosingClassName(annotatedElement);
    TypeMirror superclass = ((TypeElement) annotatedElement).getSuperclass();
    if (superclass != null) {
      Element superClassAsElement = ((DeclaredType) superclass).asElement();
      if (superClassAsElement.getAnnotation(Annotation1.class) != null) {
        String nameOfSuperClassContainingElement = getEnclosingClassName(superClassAsElement);
        final String finalClassName = getClass().getSimpleName() //
            + "_" //
            + nameOfClassContainingElement //
            + "_" //
            + nameOfSuperClassContainingElement //
            + "Gen0";
        mapGeneratedFileNameToOrginatingElements.put(finalClassName, new HashSet<>(asList(annotatedElement, superClassAsElement)));
      }
    }
  }
  return mapGeneratedFileNameToOrginatingElements;
}
 
Example 17
Project: android-auto-mapper   File: MoreTypes.java   View source code 6 votes vote down vote up
/**
 * Returns the non-object superclass of the type with the proper type parameters.
 * An absent Optional is returned if there is no non-Object superclass.
 */
public static Optional<DeclaredType> nonObjectSuperclass(final Types types, Elements elements,
                                                         DeclaredType type) {
    checkNotNull(types);
    checkNotNull(elements);
    checkNotNull(type);

    final TypeMirror objectType =
            elements.getTypeElement(Object.class.getCanonicalName()).asType();
    // It's guaranteed there's only a single CLASS superclass because java doesn't have multiple
    // class inheritance.
    TypeMirror superclass = getOnlyElement(FluentIterable.from(types.directSupertypes(type))
            .filter(new Predicate<TypeMirror>() {
                @Override
                public boolean apply(TypeMirror input) {
                    return input.getKind().equals(TypeKind.DECLARED)
                            && (MoreElements.asType(
                            MoreTypes.asDeclared(input).asElement())).getKind().equals(ElementKind.CLASS)
                            && !types.isSameType(objectType, input);
                }
            }), null);
    return superclass != null
            ? Optional.of(MoreTypes.asDeclared(superclass))
            : Optional.<DeclaredType>absent();
}
 
Example 18
Project: openjdk-jdk10   File: SourceCodeAnalysisImpl.java   View source code 6 votes vote down vote up
private Predicate<Element> createAccessibilityFilter(AnalyzeTask at, TreePath tp) {
    Scope scope = at.trees().getScope(tp);
    return el -> {
        switch (el.getKind()) {
            case ANNOTATION_TYPE: case CLASS: case ENUM: case INTERFACE:
                return at.trees().isAccessible(scope, (TypeElement) el);
            case PACKAGE:
            case EXCEPTION_PARAMETER: case PARAMETER: case LOCAL_VARIABLE: case RESOURCE_VARIABLE:
                return true;
            default:
                TypeMirror type = el.getEnclosingElement().asType();
                if (type.getKind() == TypeKind.DECLARED)
                    return at.trees().isAccessible(scope, el, (DeclaredType) type);
                else
                    return true;
        }
    };
}
 
Example 19
Project: incubator-netbeans   File: JpaControllerUtil.java   View source code 6 votes vote down vote up
public static TypeMirror stripCollection(TypeMirror passedType, Types types) {
    if (TypeKind.DECLARED != passedType.getKind() || !(passedType instanceof DeclaredType)) {
        return passedType;
    }
    TypeElement passedTypeElement = (TypeElement) types.asElement(passedType);
    String passedTypeQualifiedName = passedTypeElement.getQualifiedName().toString();   //does not include type parameter info
    Class passedTypeClass = null;
    try {
        passedTypeClass = Class.forName(passedTypeQualifiedName);
    } catch (ClassNotFoundException e) {
        //just let passedTypeClass be null
    }
    if (passedTypeClass != null && Collection.class.isAssignableFrom(passedTypeClass)) {
        List<? extends TypeMirror> passedTypeArgs = ((DeclaredType)passedType).getTypeArguments();
        if (passedTypeArgs.isEmpty()) {
            return passedType;
        }
        return passedTypeArgs.get(0);
    }
    return passedType;
}
 
Example 20
Project: incubator-netbeans   File: ReplaceBufferByString.java   View source code 6 votes vote down vote up
@Override
public Boolean visitNewClass(NewClassTree node, Void p) {
    TypeMirror tm = ci.getTrees().getTypeMirror(getCurrentPath());
    if (tm == null || tm.getKind() != TypeKind.DECLARED) {
        return false;
    }
    TypeElement el = (TypeElement)((DeclaredType)tm).asElement();
    if (el == null) {
        return false;
    }
    Name n = el.getQualifiedName();
    boolean res = n.contentEquals("java.lang.StringBuilder") || n.contentEquals("java.lang.StringBuffer"); // NOI18N
    // check if there is some initial contents
    if (node.getArguments().size() == 1 && 
            Utilities.isJavaString(ci, ci.getTrees().getTypeMirror(new TreePath(getCurrentPath(), node.getArguments().get(0))))) {
        hasContents = true;
    }
    return res;
}
 
Example 21
Project: incubator-netbeans   File: EntityMappingsUtilities.java   View source code 6 votes vote down vote up
static TypeElement getFirstTypeArgument(TypeMirror type) {
    if (TypeKind.DECLARED != type.getKind()) {
        return null;
    }
    List<? extends TypeMirror> typeArgs = ((DeclaredType)type).getTypeArguments();
    if (typeArgs.size() != 1) {
        return null;
    }
    TypeMirror typeArg = typeArgs.iterator().next();
    if (TypeKind.DECLARED != typeArg.getKind()) {
        return null;
    }
    Element typeArgElement = ((DeclaredType)typeArg).asElement();
    if (ElementKind.CLASS != typeArgElement.getKind()) {
        return null;
    }
    return (TypeElement)typeArgElement;
}
 
Example 22
Project: incubator-netbeans   File: JavaSymbolProvider.java   View source code 6 votes vote down vote up
@Override
public StringBuilder visitWildcard(WildcardType t, Boolean p) {
    int len = DEFAULT_VALUE.length();
    DEFAULT_VALUE.append("?"); //NOI18N
    TypeMirror bound = t.getSuperBound();
    if (bound == null) {
        bound = t.getExtendsBound();
        if (bound != null) {
            DEFAULT_VALUE.append(" extends "); //NOI18N
            if (bound.getKind() == TypeKind.WILDCARD) {
                bound = ((WildcardType)bound).getSuperBound();
            }
            visit(bound, p);
        } else if (len == 0) {
            bound = SourceUtils.getBound(t);
            if (bound != null && (bound.getKind() != TypeKind.DECLARED || !((TypeElement)((DeclaredType)bound).asElement()).getQualifiedName().contentEquals("java.lang.Object"))) { //NOI18N
                DEFAULT_VALUE.append(" extends "); //NOI18N
                visit(bound, p);
            }
        }
    } else {
        DEFAULT_VALUE.append(" super "); //NOI18N
        visit(bound, p);
    }
    return DEFAULT_VALUE;
}
 
Example 23
Project: incubator-netbeans   File: ElementJavadoc.java   View source code 6 votes vote down vote up
private void appendAnnotation(StringBuilder sb, AnnotationMirror annotationDesc, boolean topLevel) {
    DeclaredType annotationType = annotationDesc.getAnnotationType();
    if (annotationType != null && (!topLevel || isDocumented(annotationType))) {
        appendType(sb, annotationType, false, false, true);
        Map<? extends ExecutableElement, ? extends AnnotationValue> values = annotationDesc.getElementValues();
        if (!values.isEmpty()) {
            sb.append('('); //NOI18N
            for (Iterator<? extends Map.Entry<? extends ExecutableElement, ? extends AnnotationValue>> it = values.entrySet().iterator(); it.hasNext();) {
                Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> value = it.next();
                createLink(sb, value.getKey(), value.getKey().getSimpleName());
                sb.append('='); //NOI18N
                appendAnnotationValue(sb, value.getValue());
                if (it.hasNext())
                    sb.append(","); //NOI18N
            }
            sb.append(')'); //NOI18N
        }
        if (topLevel)
            sb.append("<br>"); //NOI18N
    }
}
 
Example 24
Project: incubator-netbeans   File: JavadocCompletionItem.java   View source code 6 votes vote down vote up
/**
 * uses FQNs where possible since javadoc does not match imports for
 * parameter types
 */
private CharSequence resolveTypeName(TypeMirror asType, boolean isVarArgs) {
    CharSequence ptype;
    if (asType.getKind() == TypeKind.DECLARED) {
        // snip generics
        Element e = ((DeclaredType) asType).asElement();
        ptype = e.getKind().isClass() || e.getKind().isInterface()
                ? ((TypeElement) e).getQualifiedName()
                : e.getSimpleName();
    } else if (asType.getKind() == TypeKind.TYPEVAR) {
        do {
            // Type Erasure JLS 4.6
            asType = ((TypeVariable) asType).getUpperBound();
        } while (asType.getKind() == TypeKind.TYPEVAR);
        ptype = resolveTypeName(asType, isVarArgs);
    } else if (isVarArgs && asType.getKind() == TypeKind.ARRAY) {
        ptype = resolveTypeName(((ArrayType)asType).getComponentType(), false) + "..."; //NOI18N
    } else {
        ptype = asType.toString();
    }
    
    return ptype;
}
 
Example 25
Project: incubator-netbeans   File: AddJavaFXPropertyMaker.java   View source code 6 votes vote down vote up
private MethodTree createGetter(ModifiersTree mods, TypeMirror valueType) {
    StringBuilder getterName = GeneratorUtils.getCapitalizedName(config.getName());
    getterName.insert(0, valueType.getKind() == TypeKind.BOOLEAN ? "is" : "get");
    ReturnTree returnTree = make.Return(make.MethodInvocation(Collections.EMPTY_LIST, make.MemberSelect(make.Identifier(config.getName()), hasGet ? "get" : "getValue"), Collections.EMPTY_LIST));
    BlockTree getterBody = make.Block(Collections.singletonList(returnTree), false);
    Tree valueTree;
    if (valueType.getKind() == TypeKind.DECLARED) {
        valueTree = make.QualIdent(((DeclaredType) valueType).asElement());
    } else if (valueType.getKind().isPrimitive()) {
        valueTree = make.PrimitiveType(valueType.getKind());
    } else {
        valueTree = make.Identifier(valueType.toString());
    }
    MethodTree getter = make.Method(mods, getterName, valueTree, Collections.EMPTY_LIST, Collections.EMPTY_LIST, Collections.EMPTY_LIST, getterBody, null);
    return getter;
}
 
Example 26
Project: openjdk-jdk10   File: GeneratedPlugin.java   View source code 6 votes vote down vote up
static boolean hasUncheckedWarning(TypeMirror type) {
    switch (type.getKind()) {
        case DECLARED:
            DeclaredType declared = (DeclaredType) type;
            for (TypeMirror typeParam : declared.getTypeArguments()) {
                if (hasUncheckedWarning(typeParam)) {
                    return true;
                }
            }
            return false;
        case TYPEVAR:
            return true;
        case WILDCARD:
            return ((WildcardType) type).getExtendsBound() != null;
        case ARRAY:
            return hasUncheckedWarning(((ArrayType) type).getComponentType());
        default:
            return false;
    }
}
 
Example 27
Project: incubator-netbeans   File: TypeUtilities.java   View source code 6 votes vote down vote up
@Override
public StringBuilder visitDeclared(DeclaredType t, Boolean p) {
    Element e = t.asElement();
    if (e instanceof TypeElement) {
        TypeElement te = (TypeElement)e;
        DEFAULT_VALUE.append((p ? te.getQualifiedName() : te.getSimpleName()).toString());
        Iterator<? extends TypeMirror> it = t.getTypeArguments().iterator();
        if (it.hasNext()) {
            DEFAULT_VALUE.append("<"); //NOI18N
            while(it.hasNext()) {
                visit(it.next(), p);
                if (it.hasNext())
                    DEFAULT_VALUE.append(", "); //NOI18N
            }
            DEFAULT_VALUE.append(">"); //NOI18N
        }
        return DEFAULT_VALUE;
    } else {
        return DEFAULT_VALUE.append(UNKNOWN); //NOI18N
    }
}
 
Example 28
Project: incubator-netbeans   File: BeanClassFinder.java   View source code 5 votes vote down vote up
@Override
public void run(CompilationController controller) throws Exception {
    controller.toPhase(JavaSource.Phase.ELEMENTS_RESOLVED);
    if (implClass == null) {
        return;
    }
    TypeElement te = JavaUtils.findClassElementByBinaryName(implClass, controller);
    if (te == null) {
        return;
    }

    FactoryMethodFinder factoryMethodFinder = new FactoryMethodFinder(
            te, factoryMethodName, staticFlag, controller.getElementUtilities());
    List<ExecutableElement> methods = factoryMethodFinder.findMethods();
    if (methods.size() != 1) {
        return;
    }

    ExecutableElement method = methods.get(0);
    if (method.getReturnType().getKind() != TypeKind.DECLARED) {
        return;
    }

    wasClassResolved.set(true);
    DeclaredType dt = (DeclaredType) method.getReturnType();
    resolvedClass[0] = ElementUtilities.getBinaryName((TypeElement) dt.asElement());
}
 
Example 29
Project: incubator-netbeans   File: BeanModelBuilder.java   View source code 5 votes vote down vote up
private void addListProperty(ExecutableElement m, String propName) {
    FxProperty pi = new FxProperty(propName, FxDefinitionKind.LIST);
    pi.setSimple(false);
    pi.setAccessor(ElementHandle.create(m));
    
    // must extract type arguments; assume there's a DeclaredType
    DeclaredType t = ((DeclaredType)m.getReturnType());
    ExecutableType getterType = findListGetMethod(t);
    
    pi.setType(TypeMirrorHandle.create(getterType.getReturnType()));
    pi.setObservableAccessors(pi.getAccessor());
    
    registerProperty(pi);
}
 
Example 30
Project: javaide   File: JavacTrees.java   View source code 5 votes vote down vote up
public boolean isAccessible(Scope scope, Element member, DeclaredType type) {
    if (scope instanceof JavacScope
            && member instanceof Symbol
            && type instanceof com.sun.tools.javac.code.Type) {
        Env<AttrContext> env = ((JavacScope) scope).env;
        return resolve.isAccessible(env, (com.sun.tools.javac.code.Type)type, (Symbol)member, true);
    } else
        return false;
}
 
Example 31
Project: openjdk-jdk10   File: Utils.java   View source code 5 votes vote down vote up
/**
 * Finds the declaration of the enclosing's type parameter.
 *
 * @param values
 * @param enclosing a TypeElement whose type arguments  we desire
 * @param target the TypeMirror of the type as described by the enclosing
 * @return
 */
public TypeMirror getDeclaredType(Collection<TypeMirror> values,
        TypeElement enclosing, TypeMirror target) {
    TypeElement targetElement = asTypeElement(target);
    List<? extends TypeParameterElement> targetTypeArgs = targetElement.getTypeParameters();
    if (targetTypeArgs.isEmpty()) {
        return target;
    }

    List<? extends TypeParameterElement> enclosingTypeArgs = enclosing.getTypeParameters();
    List<TypeMirror> targetTypeArgTypes = new ArrayList<>(targetTypeArgs.size());

    if (enclosingTypeArgs.isEmpty()) {
        for (TypeMirror te : values) {
            List<? extends TypeMirror> typeArguments = ((DeclaredType)te).getTypeArguments();
            if (typeArguments.size() >= targetTypeArgs.size()) {
                for (int i = 0 ; i < targetTypeArgs.size(); i++) {
                    targetTypeArgTypes.add(typeArguments.get(i));
                }
                break;
            }
        }
        // we found no matches in the hierarchy
        if (targetTypeArgTypes.isEmpty()) {
            return target;
        }
    } else {
        if (targetTypeArgs.size() > enclosingTypeArgs.size()) {
            return target;
        }
        for (int i = 0; i < targetTypeArgs.size(); i++) {
            TypeParameterElement tpe = enclosingTypeArgs.get(i);
            targetTypeArgTypes.add(tpe.asType());
        }
    }
    TypeMirror dt = typeUtils.getDeclaredType(targetElement,
            targetTypeArgTypes.toArray(new TypeMirror[targetTypeArgTypes.size()]));
    return dt;
}
 
Example 32
Project: incubator-netbeans   File: IntroduceLocalExtensionTransformer.java   View source code 5 votes vote down vote up
private MethodTree createHashCodeMethod(WorkingCopy wc, DeclaredType type) {
    TreeMaker make = wc.getTreeMaker();
    Set<Modifier> mods = EnumSet.of(Modifier.PUBLIC);

    Integer number = refactoring.getContext().lookup(Integer.class); // Used in test code
    int startNumber;
    int multiplyNumber;
    if (number != null) {
        startNumber = number.intValue();
        multiplyNumber = number.intValue();
    } else {
        startNumber = generatePrimeNumber(2, 10);
        multiplyNumber = generatePrimeNumber(10, 100);
    }
    List<StatementTree> statements = new ArrayList<>();
    //int hash = <startNumber>;
    statements.add(make.Variable(make.Modifiers(EnumSet.noneOf(Modifier.class)), "hash", make.PrimitiveType(TypeKind.INT), make.Literal(startNumber))); //NOI18N

    TypeMirror tm = type;
    ExpressionTree variableRead = prepareExpression(wc, HASH_CODE_PATTERNS, tm, "delegate"); //NOI18N
    statements.add(make.ExpressionStatement(make.Assignment(make.Identifier("hash"), make.Binary(Tree.Kind.PLUS, make.Binary(Tree.Kind.MULTIPLY, make.Literal(multiplyNumber), make.Identifier("hash")), variableRead)))); //NOI18N

    statements.add(make.Return(make.Identifier("hash"))); //NOI18N
    BlockTree body = make.Block(statements, false);
    ModifiersTree modifiers = prepareModifiers(wc, mods, make, true);

    return make.Method(modifiers, "hashCode", make.PrimitiveType(TypeKind.INT), Collections.<TypeParameterTree>emptyList(), Collections.<VariableTree>emptyList(), Collections.<ExpressionTree>emptyList(), body, null); //NOI18N
}
 
Example 33
Project: GitHub   File: Util.java   View source code 5 votes vote down vote up
public static String getFullClassName(TypeMirror typeMirror) {
	if (!(typeMirror instanceof DeclaredType)) {
		return "";
	}

	TypeElement typeElement = (TypeElement) ((DeclaredType) typeMirror).asElement();
	return getFullClassName(typeElement);
}
 
Example 34
Project: incubator-netbeans   File: JavadocCompletionItem.java   View source code 5 votes vote down vote up
public static CompletionItem createTypeItem(CompilationInfo info, TypeElement elem,
        int startOffset, ReferencesCount referencesCount, boolean isDeprecated) {
    
    CompletionItem delegate = JavaCompletionItem.createTypeItem(
            info, elem, (DeclaredType) elem.asType(), startOffset,
            referencesCount, isDeprecated, false, false, false, false, false, null);
    return new JavadocTypeItem(delegate, startOffset);
}
 
Example 35
Project: OpenJSharp   File: ApNavigator.java   View source code 5 votes vote down vote up
public TypeMirror getTypeArgument(TypeMirror typeMirror, int i) {
    if (typeMirror != null && typeMirror.getKind().equals(TypeKind.DECLARED)) {
        DeclaredType declaredType = (DeclaredType) typeMirror;
        TypeMirror[] args = declaredType.getTypeArguments().toArray(new TypeMirror[declaredType.getTypeArguments().size()]);
        return args[i];
    } else throw new IllegalArgumentException();
}
 
Example 36
Project: GitHub   File: TypeHierarchyCollector.java   View source code 5 votes vote down vote up
private void collectHierarchyMirrors(TypeMirror typeMirror, String stringRepresentation) {
  if (typeMirror.getKind() != TypeKind.DECLARED
      || typeMirror.toString().equals(Object.class.getName())) {
    return;
  }

  DeclaredType declaredType = toDeclaredType(typeMirror);
  TypeElement e = toTypeElement(declaredType);
  TypevarContext context = new TypevarContext(e, stringRepresentation);

  collectInterfacesMirrors(declaredType, context);

  TypeMirror superclassMirror = e.getSuperclass();
  if (superclassMirror.getKind() != TypeKind.NONE) {
    DeclaredType superclass = toDeclaredType(superclassMirror);
    String stringified = stringify(superclass, context);

    if (!stringified.equals(Object.class.getName())) {
      extendedClasses.add(toTypeElement(superclass));
      extendedClassNames.add(stringified);
      collectHierarchyMirrors(superclass, stringified);
    }
  }

  for (TypeMirror m : e.getInterfaces()) {
    collectUnresolvedInterface(m, context);
    collectInterfacesMirrors(m, context);
  }
}
 
Example 37
Project: incubator-netbeans   File: AddJavaFXPropertyMaker.java   View source code 5 votes vote down vote up
private VariableTree createField(DeclaredType selectedType, ExpressionTree implementationType) {
    String initializer = config.getInitializer();
    NewClassTree newClass = make.NewClass(null,
            Collections.EMPTY_LIST,
            implementationType,
            Collections.singletonList(make.Identifier(initializer)), null);
    VariableTree property = make.Variable(
            make.Modifiers(EnumSet.of(Modifier.PRIVATE, Modifier.FINAL)),
            config.getName(),
            getTypeTree(selectedType),
            newClass);
    return property;
}
 
Example 38
Project: incubator-netbeans   File: AbstractTestGenerator.java   View source code 5 votes vote down vote up
private boolean shouldApplyErasure(TypeMirror argument) {
if (argument.getKind() == TypeKind.DECLARED) {
    if (((DeclaredType) argument).asElement().getModifiers().contains(Modifier.PRIVATE)) {
	return true;
    }
} else {
    return true;
}
return false;
   }
 
Example 39
Project: openjdk-jdk10   File: SourceCodeAnalysisImpl.java   View source code 5 votes vote down vote up
private Iterable<Pair<ExecutableElement, ExecutableType>> newClassCandidates(AnalyzeTask at, TreePath newClassPath) {
    NewClassTree nct = (NewClassTree) newClassPath.getLeaf();
    Element type = at.trees().getElement(new TreePath(newClassPath.getParentPath(), nct.getIdentifier()));
    TypeMirror targetType = at.trees().getTypeMirror(newClassPath);
    if (targetType == null || targetType.getKind() != TypeKind.DECLARED) {
        Iterable<TypeMirror> targetTypes = findTargetType(at, newClassPath);
        if (targetTypes == null)
            targetTypes = Collections.emptyList();
        targetType =
                StreamSupport.stream(targetTypes.spliterator(), false)
                             .filter(t -> at.getTypes().asElement(t) == type)
                             .findAny()
                             .orElse(at.getTypes().erasure(type.asType()));
    }
    List<Pair<ExecutableElement, ExecutableType>> candidateConstructors = new ArrayList<>();
    Predicate<Element> accessibility = createAccessibilityFilter(at, newClassPath);

    if (targetType != null &&
        targetType.getKind() == TypeKind.DECLARED &&
        type != null &&
        (type.getKind().isClass() || type.getKind().isInterface())) {
        for (ExecutableElement constr : ElementFilter.constructorsIn(type.getEnclosedElements())) {
            if (accessibility.test(constr)) {
                ExecutableType constrType =
                        (ExecutableType) at.getTypes().asMemberOf((DeclaredType) targetType, constr);
                candidateConstructors.add(Pair.of(constr, constrType));
            }
        }
    }

    return candidateConstructors;
}
 
Example 40
Project: incubator-netbeans   File: GoToSupport.java   View source code 5 votes vote down vote up
Void printExecutable(ExecutableElement e, DeclaredType dt, Boolean highlightName) {
    switch (e.getKind()) {
        case CONSTRUCTOR:
            modifier(e.getModifiers());
            dumpTypeArguments(e.getTypeParameters());
            result.append(' ');
            boldStartCheck(highlightName);
            result.append(e.getEnclosingElement().getSimpleName());
            boldStopCheck(highlightName);
            TypeMirror memberType = null;
            if (dt != null) {
                dumpRealTypeArguments(dt.getTypeArguments());
                try {
                    memberType = info.getTypes().asMemberOf(dt, e);
                } catch (IllegalStateException ise) {}
            }
            if (memberType instanceof ExecutableType) {
                dumpArguments(e.getParameters(), ((ExecutableType) memberType).getParameterTypes());
            } else {
                dumpArguments(e.getParameters(), null);
            }
            dumpThrows(e.getThrownTypes());
            break;
        case METHOD:
            modifier(e.getModifiers());
            dumpTypeArguments(e.getTypeParameters());
            result.append(getTypeName(info, e.getReturnType(), true));
            result.append(' ');
            boldStartCheck(highlightName);
            result.append(e.getSimpleName());
            boldStopCheck(highlightName);
            dumpArguments(e.getParameters(), null);
            dumpThrows(e.getThrownTypes());
            break;
        case INSTANCE_INIT:
        case STATIC_INIT:
            //these two cannot be referenced anyway...
    }
    return null;
}