Examples with ParameterizedQualifiedTypeReference org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference used on opensource projects

Example 6 with ParameterizedQualifiedTypeReference

use of org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference in project lombok by rzwitserloot.

the class HandleBuilder method getSingularData.

/**
 * Returns the explicitly requested singular annotation on this node (field
 * or parameter), or null if there's no {@code @Singular} annotation on it.
 *
 * @param node The node (field or method param) to inspect for its name and potential {@code @Singular} annotation.
 */
private SingularData getSingularData(EclipseNode node, ASTNode source) {
    for (EclipseNode child : node.down()) {
        if (!annotationTypeMatches(Singular.class, child))
            continue;
        char[] pluralName = node.getKind() == Kind.FIELD ? removePrefixFromField(node) : ((AbstractVariableDeclaration) node.get()).name;
        AnnotationValues<Singular> ann = createAnnotation(Singular.class, child);
        String explicitSingular = ann.getInstance().value();
        if (explicitSingular.isEmpty()) {
            if (Boolean.FALSE.equals(node.getAst().readConfiguration(ConfigurationKeys.SINGULAR_AUTO))) {
                node.addError("The singular must be specified explicitly (e.g. @Singular(\"task\")) because auto singularization is disabled.");
                explicitSingular = new String(pluralName);
            } else {
                explicitSingular = autoSingularize(new String(pluralName));
                if (explicitSingular == null) {
                    node.addError("Can't singularize this name; please specify the singular explicitly (i.e. @Singular(\"sheep\"))");
                    explicitSingular = new String(pluralName);
                }
            }
        }
        char[] singularName = explicitSingular.toCharArray();
        TypeReference type = ((AbstractVariableDeclaration) node.get()).type;
        TypeReference[] typeArgs = null;
        String typeName;
        if (type instanceof ParameterizedSingleTypeReference) {
            typeArgs = ((ParameterizedSingleTypeReference) type).typeArguments;
            typeName = new String(((ParameterizedSingleTypeReference) type).token);
        } else if (type instanceof ParameterizedQualifiedTypeReference) {
            TypeReference[][] tr = ((ParameterizedQualifiedTypeReference) type).typeArguments;
            if (tr != null)
                typeArgs = tr[tr.length - 1];
            char[][] tokens = ((ParameterizedQualifiedTypeReference) type).tokens;
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < tokens.length; i++) {
                if (i > 0)
                    sb.append(".");
                sb.append(tokens[i]);
            }
            typeName = sb.toString();
        } else {
            typeName = type.toString();
        }
        String targetFqn = EclipseSingularsRecipes.get().toQualified(typeName);
        EclipseSingularizer singularizer = EclipseSingularsRecipes.get().getSingularizer(targetFqn);
        if (singularizer == null) {
            node.addError("Lombok does not know how to create the singular-form builder methods for type '" + typeName + "'; they won't be generated.");
            return null;
        }
        return new SingularData(child, singularName, pluralName, typeArgs == null ? Collections.<TypeReference>emptyList() : Arrays.asList(typeArgs), targetFqn, singularizer, source);
    }
    return null;
}

Example 7 with ParameterizedQualifiedTypeReference

use of org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference in project lombok by rzwitserloot.

the class HandleEqualsAndHashCode method createTypeReference.

/**
 * @param type Type to 'copy' into a typeref
 * @param p position
 * @param addWildcards If false, all generics are cut off. If true, replaces all genericparams with a ?.
 * @return
 */
public TypeReference createTypeReference(EclipseNode type, long p, ASTNode source, boolean addWildcards) {
    int pS = source.sourceStart;
    int pE = source.sourceEnd;
    List<String> list = new ArrayList<String>();
    List<Integer> genericsCount = addWildcards ? new ArrayList<Integer>() : null;
    list.add(type.getName());
    if (addWildcards)
        genericsCount.add(arraySizeOf(((TypeDeclaration) type.get()).typeParameters));
    boolean staticContext = (((TypeDeclaration) type.get()).modifiers & Modifier.STATIC) != 0;
    EclipseNode tNode = type.up();
    while (tNode != null && tNode.getKind() == Kind.TYPE) {
        list.add(tNode.getName());
        if (addWildcards)
            genericsCount.add(staticContext ? 0 : arraySizeOf(((TypeDeclaration) tNode.get()).typeParameters));
        if (!staticContext)
            staticContext = (((TypeDeclaration) tNode.get()).modifiers & Modifier.STATIC) != 0;
        tNode = tNode.up();
    }
    Collections.reverse(list);
    if (addWildcards)
        Collections.reverse(genericsCount);
    if (list.size() == 1) {
        if (!addWildcards || genericsCount.get(0) == 0) {
            return new SingleTypeReference(list.get(0).toCharArray(), p);
        } else {
            return new ParameterizedSingleTypeReference(list.get(0).toCharArray(), wildcardify(pS, pE, source, genericsCount.get(0)), 0, p);
        }
    }
    if (addWildcards) {
        addWildcards = false;
        for (int i : genericsCount) if (i > 0)
            addWildcards = true;
    }
    long[] ps = new long[list.size()];
    char[][] tokens = new char[list.size()][];
    for (int i = 0; i < list.size(); i++) {
        ps[i] = p;
        tokens[i] = list.get(i).toCharArray();
    }
    if (!addWildcards)
        return new QualifiedTypeReference(tokens, ps);
    TypeReference[][] typeArgs2 = new TypeReference[tokens.length][];
    for (int i = 0; i < tokens.length; i++) typeArgs2[i] = wildcardify(pS, pE, source, genericsCount.get(i));
    return new ParameterizedQualifiedTypeReference(tokens, typeArgs2, 0, ps);
}