Example usage for org.eclipse.jdt.internal.compiler.lookup TypeIds T_boolean

List of usage examples for org.eclipse.jdt.internal.compiler.lookup TypeIds T_boolean

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.internal.compiler.lookup.*
  5. TypeIds
  6. T_boolean

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.lookup TypeIds T_boolean.

Prototype

int T_boolean

To view the source code for org.eclipse.jdt.internal.compiler.lookup TypeIds T_boolean.

Click Source Link

Usage

From source file:com.codenvy.ide.ext.java.server.internal.core.Member.java

License:Open Source License

/**
 * Converts a field constant from the compiler's representation
 * to the Java Model constant representation (Number or String).
 *//*w w  w.j  a  v a  2  s .com*/
protected static Object convertConstant(Constant constant) {
    if (constant == null)
        return null;
    if (constant == Constant.NotAConstant) {
        return null;
    }
    switch (constant.typeID()) {
    case TypeIds.T_boolean:
        return constant.booleanValue() ? Boolean.TRUE : Boolean.FALSE;
    case TypeIds.T_byte:
        return new Byte(constant.byteValue());
    case TypeIds.T_char:
        return new Character(constant.charValue());
    case TypeIds.T_double:
        return new Double(constant.doubleValue());
    case TypeIds.T_float:
        return new Float(constant.floatValue());
    case TypeIds.T_int:
        return new Integer(constant.intValue());
    case TypeIds.T_long:
        return new Long(constant.longValue());
    case TypeIds.T_short:
        return new Short(constant.shortValue());
    case TypeIds.T_JavaLangString:
        return constant.stringValue();
    default:
        return null;
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.util.Util.java

License:Open Source License

public static Object getAnnotationMemberValue(MemberValuePair memberValuePair, Constant constant) {
    if (constant == null) {
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }//  w w w  . j  a  v  a2  s. co m
    switch (constant.typeID()) {
    case TypeIds.T_int:
        memberValuePair.valueKind = IMemberValuePair.K_INT;
        return new Integer(constant.intValue());
    case TypeIds.T_byte:
        memberValuePair.valueKind = IMemberValuePair.K_BYTE;
        return new Byte(constant.byteValue());
    case TypeIds.T_short:
        memberValuePair.valueKind = IMemberValuePair.K_SHORT;
        return new Short(constant.shortValue());
    case TypeIds.T_char:
        memberValuePair.valueKind = IMemberValuePair.K_CHAR;
        return new Character(constant.charValue());
    case TypeIds.T_float:
        memberValuePair.valueKind = IMemberValuePair.K_FLOAT;
        return new Float(constant.floatValue());
    case TypeIds.T_double:
        memberValuePair.valueKind = IMemberValuePair.K_DOUBLE;
        return new Double(constant.doubleValue());
    case TypeIds.T_boolean:
        memberValuePair.valueKind = IMemberValuePair.K_BOOLEAN;
        return Boolean.valueOf(constant.booleanValue());
    case TypeIds.T_long:
        memberValuePair.valueKind = IMemberValuePair.K_LONG;
        return new Long(constant.longValue());
    case TypeIds.T_JavaLangString:
        memberValuePair.valueKind = IMemberValuePair.K_STRING;
        return constant.stringValue();
    default:
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }
}

From source file:com.google.gwt.dev.jjs.impl.TypeMap.java

License:Apache License

private JNode internalGet(Binding binding, boolean failOnNull) {
    JNode cached = crossRefMap.get(binding);
    if (cached != null) {
        return cached;
    } else if (binding instanceof BaseTypeBinding) {
        BaseTypeBinding baseTypeBinding = (BaseTypeBinding) binding;
        // see org.eclipse.jdt.internal.compiler.lookup.TypeIds constants
        switch (baseTypeBinding.id) {
        case TypeIds.T_JavaLangObject:
            // here for consistency, should already be cached
            return program.getTypeJavaLangObject();
        case TypeIds.T_char:
            return program.getTypePrimitiveChar();
        case TypeIds.T_byte:
            return program.getTypePrimitiveByte();
        case TypeIds.T_short:
            return program.getTypePrimitiveShort();
        case TypeIds.T_boolean:
            return program.getTypePrimitiveBoolean();
        case TypeIds.T_void:
            return program.getTypeVoid();
        case TypeIds.T_long:
            return program.getTypePrimitiveLong();
        case TypeIds.T_double:
            return program.getTypePrimitiveDouble();
        case TypeIds.T_float:
            return program.getTypePrimitiveFloat();
        case TypeIds.T_int:
            return program.getTypePrimitiveInt();
        case TypeIds.T_JavaLangString:
            // here for consistency, should already be cached
            return program.getTypeJavaLangString();
        case TypeIds.T_null:
            return program.getTypeNull();
        case TypeIds.T_undefined:
        default://from   ww w  .j a v  a  2  s  .c om
            return null;
        }
    } else if (binding instanceof ArrayBinding) {
        ArrayBinding arrayBinding = (ArrayBinding) binding;
        JType elementType = (JType) get(arrayBinding.elementsType(), failOnNull);
        if (elementType == null) {
            return null;
        }
        return program.getTypeArray(elementType);
    } else if (binding instanceof BinaryTypeBinding) {
        BinaryTypeBinding binaryBinding = (BinaryTypeBinding) binding;
        String name = BuildTypeMap.dotify(binaryBinding.compoundName);

        // There may be many BinaryTypeBindings for a single binary type
        JDeclaredType type = externalTypesByName.get(name);
        if (type != null) {
            put(binding, type);
        }
        return type;
    } else if (binding instanceof MethodBinding) {
        MethodBinding b = (MethodBinding) binding;
        JMethod cachedMethod = (JMethod) crossRefMap.get(b);
        if (cachedMethod == null) {
            JDeclaredType type = (JDeclaredType) get(b.declaringClass, failOnNull);
            if (type == null) {
                return type;
            }
            cachedMethod = getMethodForBinding(type, b);
            if (cachedMethod != null) {
                put(b, cachedMethod);
            }
        } else {
            // Happens sometimes when looking up the type to resolve the binding
            // causes us to also resolve the binding.
        }

        return cachedMethod;
    } else if (binding instanceof FieldBinding) {
        FieldBinding b = (FieldBinding) binding;
        JField cachedField = (JField) crossRefMap.get(b);

        if (cachedField == null) {
            JDeclaredType type = (JDeclaredType) get(b.declaringClass, failOnNull);
            if (type == null) {
                return null;
            }
            cachedField = getFieldForBinding(type, b);
            if (cachedField != null) {
                put(b, cachedField);
            }
        } else {
            // Happens sometimes when looking up the type to resolve the binding
            // causes us to also resolve the binding.
        }

        return cachedField;
    }

    return null;
}

From source file:com.redhat.ceylon.eclipse.core.model.loader.JDTType.java

License:Open Source License

private TypeKind findKind() {
    if (type instanceof ArrayBinding)
        return TypeKind.ARRAY;
    if (type instanceof TypeVariableBinding)
        return TypeKind.TYPEVAR;
    if (type instanceof WildcardBinding)
        return TypeKind.WILDCARD;
    if (type instanceof BaseTypeBinding) {
        switch (type.id) {
        case TypeIds.T_boolean:
            return TypeKind.BOOLEAN;
        case TypeIds.T_byte:
            return TypeKind.BYTE;
        case TypeIds.T_char:
            return TypeKind.CHAR;
        case TypeIds.T_short:
            return TypeKind.SHORT;
        case TypeIds.T_int:
            return TypeKind.INT;
        case TypeIds.T_long:
            return TypeKind.LONG;
        case TypeIds.T_float:
            return TypeKind.FLOAT;
        case TypeIds.T_double:
            return TypeKind.DOUBLE;
        case TypeIds.T_void:
            return TypeKind.VOID;
        }/*from  w  w w  .j a va 2 s  .com*/
    }
    if (type instanceof ReferenceBinding)
        return TypeKind.DECLARED;
    throw new RuntimeException("Unknown type: " + type);
}

From source file:com.redhat.ceylon.eclipse.core.model.mirror.UnknownTypeMirror.java

License:Open Source License

private TypeKind findKind(TypeBinding type) {
    if (type instanceof ArrayBinding)
        return TypeKind.ARRAY;
    if (type instanceof TypeVariableBinding)
        return TypeKind.TYPEVAR;
    if (type instanceof WildcardBinding)
        return TypeKind.WILDCARD;
    if (type instanceof BaseTypeBinding) {
        switch (type.id) {
        case TypeIds.T_boolean:
            return TypeKind.BOOLEAN;
        case TypeIds.T_byte:
            return TypeKind.BYTE;
        case TypeIds.T_char:
            return TypeKind.CHAR;
        case TypeIds.T_short:
            return TypeKind.SHORT;
        case TypeIds.T_int:
            return TypeKind.INT;
        case TypeIds.T_long:
            return TypeKind.LONG;
        case TypeIds.T_float:
            return TypeKind.FLOAT;
        case TypeIds.T_double:
            return TypeKind.DOUBLE;
        case TypeIds.T_void:
            return TypeKind.VOID;
        case TypeIds.T_null:
            return TypeKind.NULL;
        }//from  www .j  ava2 s  .  co  m
    }
    if (type instanceof ReferenceBinding)
        return TypeKind.DECLARED;
    throw new RuntimeException("Unknown type: " + type);
}

From source file:io.takari.maven.plugins.compile.jdt.ClassfileDigester.java

License:Open Source License

private void updateConstant(Constant constant) {
    updateInt(constant.typeID());/*from  w  ww .j  a v a 2s  . c o m*/
    updateString(constant.getClass().getName());
    switch (constant.typeID()) {
    case TypeIds.T_int:
        updateInt(constant.intValue());
        break;
    case TypeIds.T_byte:
        updateByte(constant.byteValue());
        break;
    case TypeIds.T_short:
        updateShort(constant.shortValue());
        break;
    case TypeIds.T_char:
        updateChar(constant.charValue());
        break;
    case TypeIds.T_long:
        updateLong(constant.longValue());
        break;
    case TypeIds.T_float:
        updateFloat(constant.floatValue());
        break;
    case TypeIds.T_double:
        updateDouble(constant.doubleValue());
        break;
    case TypeIds.T_boolean:
        updateBoolean(constant.booleanValue());
        break;
    case TypeIds.T_JavaLangString:
        updateString(constant.stringValue());
        break;
    default:
        throw new IllegalArgumentException("Unexpected constant typeID=" + constant.typeID());
    }
}

From source file:lombok.eclipse.Eclipse.java

License:Open Source License

/**
 * Returns the actual value of the given Literal or Literal-like node.
 *//*  w  ww  .ja  v a 2  s.  c  o m*/
public static Object calculateValue(Expression e) {
    if (e instanceof Literal) {
        ((Literal) e).computeConstant();
        switch (e.constant.typeID()) {
        case TypeIds.T_int:
            return e.constant.intValue();
        case TypeIds.T_byte:
            return e.constant.byteValue();
        case TypeIds.T_short:
            return e.constant.shortValue();
        case TypeIds.T_char:
            return e.constant.charValue();
        case TypeIds.T_float:
            return e.constant.floatValue();
        case TypeIds.T_double:
            return e.constant.doubleValue();
        case TypeIds.T_boolean:
            return e.constant.booleanValue();
        case TypeIds.T_long:
            return e.constant.longValue();
        case TypeIds.T_JavaLangString:
            return e.constant.stringValue();
        default:
            return null;
        }
    } else if (e instanceof ClassLiteralAccess) {
        return Eclipse.toQualifiedName(((ClassLiteralAccess) e).type.getTypeName());
    } else if (e instanceof SingleNameReference) {
        return new String(((SingleNameReference) e).token);
    } else if (e instanceof QualifiedNameReference) {
        String qName = Eclipse.toQualifiedName(((QualifiedNameReference) e).tokens);
        int idx = qName.lastIndexOf('.');
        return idx == -1 ? qName : qName.substring(idx + 1);
    }

    return null;
}

From source file:lombok.eclipse.handlers.EclipseHandlerUtil.java

License:Open Source License

public static TypeReference makeType(TypeBinding binding, ASTNode pos, boolean allowCompound) {
    int dims = binding.dimensions();
    binding = binding.leafComponentType();

    // Primitives

    char[] base = null;

    switch (binding.id) {
    case TypeIds.T_int:
        base = TypeConstants.INT;/*from w ww .j  ava2 s . c  om*/
        break;
    case TypeIds.T_long:
        base = TypeConstants.LONG;
        break;
    case TypeIds.T_short:
        base = TypeConstants.SHORT;
        break;
    case TypeIds.T_byte:
        base = TypeConstants.BYTE;
        break;
    case TypeIds.T_double:
        base = TypeConstants.DOUBLE;
        break;
    case TypeIds.T_float:
        base = TypeConstants.FLOAT;
        break;
    case TypeIds.T_boolean:
        base = TypeConstants.BOOLEAN;
        break;
    case TypeIds.T_char:
        base = TypeConstants.CHAR;
        break;
    case TypeIds.T_void:
        base = TypeConstants.VOID;
        break;
    case TypeIds.T_null:
        return null;
    }

    if (base != null) {
        if (dims > 0) {
            TypeReference result = new ArrayTypeReference(base, dims, pos(pos));
            setGeneratedBy(result, pos);
            return result;
        }
        TypeReference result = new SingleTypeReference(base, pos(pos));
        setGeneratedBy(result, pos);
        return result;
    }

    if (binding.isAnonymousType()) {
        ReferenceBinding ref = (ReferenceBinding) binding;
        ReferenceBinding[] supers = ref.superInterfaces();
        if (supers == null || supers.length == 0)
            supers = new ReferenceBinding[] { ref.superclass() };
        if (supers[0] == null) {
            TypeReference result = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
            setGeneratedBy(result, pos);
            return result;
        }
        return makeType(supers[0], pos, false);
    }

    if (binding instanceof CaptureBinding) {
        return makeType(((CaptureBinding) binding).wildcard, pos, allowCompound);
    }

    if (binding.isUnboundWildcard()) {
        if (!allowCompound) {
            TypeReference result = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
            setGeneratedBy(result, pos);
            return result;
        } else {
            Wildcard out = new Wildcard(Wildcard.UNBOUND);
            setGeneratedBy(out, pos);
            out.sourceStart = pos.sourceStart;
            out.sourceEnd = pos.sourceEnd;
            return out;
        }
    }

    if (binding.isWildcard()) {
        WildcardBinding wildcard = (WildcardBinding) binding;
        if (wildcard.boundKind == Wildcard.EXTENDS) {
            if (!allowCompound) {
                return makeType(wildcard.bound, pos, false);
            } else {
                Wildcard out = new Wildcard(Wildcard.EXTENDS);
                setGeneratedBy(out, pos);
                out.bound = makeType(wildcard.bound, pos, false);
                out.sourceStart = pos.sourceStart;
                out.sourceEnd = pos.sourceEnd;
                return out;
            }
        } else if (allowCompound && wildcard.boundKind == Wildcard.SUPER) {
            Wildcard out = new Wildcard(Wildcard.SUPER);
            setGeneratedBy(out, pos);
            out.bound = makeType(wildcard.bound, pos, false);
            out.sourceStart = pos.sourceStart;
            out.sourceEnd = pos.sourceEnd;
            return out;
        } else {
            TypeReference result = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
            setGeneratedBy(result, pos);
            return result;
        }
    }

    // Keep moving up via 'binding.enclosingType()' and gather generics from each binding. We stop after a local type, or a static type, or a top-level type.
    // Finally, add however many nullTypeArgument[] arrays as that are missing, inverse the list, toArray it, and use that as PTR's typeArgument argument.

    List<TypeReference[]> params = new ArrayList<TypeReference[]>();
    /* Calculate generics */ {
        TypeBinding b = binding;
        while (true) {
            boolean isFinalStop = b.isLocalType() || !b.isMemberType() || b.enclosingType() == null;

            TypeReference[] tyParams = null;
            if (b instanceof ParameterizedTypeBinding) {
                ParameterizedTypeBinding paramized = (ParameterizedTypeBinding) b;
                if (paramized.arguments != null) {
                    tyParams = new TypeReference[paramized.arguments.length];
                    for (int i = 0; i < tyParams.length; i++) {
                        tyParams[i] = makeType(paramized.arguments[i], pos, true);
                    }
                }
            }

            params.add(tyParams);
            if (isFinalStop)
                break;
            b = b.enclosingType();
        }
    }

    char[][] parts;

    if (binding.isTypeVariable()) {
        parts = new char[][] { binding.shortReadableName() };
    } else if (binding.isLocalType()) {
        parts = new char[][] { binding.sourceName() };
    } else {
        String[] pkg = new String(binding.qualifiedPackageName()).split("\\.");
        String[] name = new String(binding.qualifiedSourceName()).split("\\.");
        if (pkg.length == 1 && pkg[0].isEmpty())
            pkg = new String[0];
        parts = new char[pkg.length + name.length][];
        int ptr;
        for (ptr = 0; ptr < pkg.length; ptr++)
            parts[ptr] = pkg[ptr].toCharArray();
        for (; ptr < pkg.length + name.length; ptr++)
            parts[ptr] = name[ptr - pkg.length].toCharArray();
    }

    while (params.size() < parts.length)
        params.add(null);
    Collections.reverse(params);

    boolean isParamized = false;

    for (TypeReference[] tyParams : params) {
        if (tyParams != null) {
            isParamized = true;
            break;
        }
    }
    if (isParamized) {
        if (parts.length > 1) {
            TypeReference[][] typeArguments = params.toArray(new TypeReference[0][]);
            TypeReference result = new ParameterizedQualifiedTypeReference(parts, typeArguments, dims,
                    poss(pos, parts.length));
            setGeneratedBy(result, pos);
            return result;
        }
        TypeReference result = new ParameterizedSingleTypeReference(parts[0], params.get(0), dims, pos(pos));
        setGeneratedBy(result, pos);
        return result;
    }

    if (dims > 0) {
        if (parts.length > 1) {
            TypeReference result = new ArrayQualifiedTypeReference(parts, dims, poss(pos, parts.length));
            setGeneratedBy(result, pos);
            return result;
        }
        TypeReference result = new ArrayTypeReference(parts[0], dims, pos(pos));
        setGeneratedBy(result, pos);
        return result;
    }

    if (parts.length > 1) {
        TypeReference result = new QualifiedTypeReference(parts, poss(pos, parts.length));
        setGeneratedBy(result, pos);
        return result;
    }
    TypeReference result = new SingleTypeReference(parts[0], pos(pos));
    setGeneratedBy(result, pos);
    return result;
}

From source file:lombok.eclipse.handlers.HandleActionFunctionAndPredicate.java

License:Open Source License

private boolean matchesReturnType(final MethodBinding method, final String forcedReturnType) {
    if (forcedReturnType == null)
        return true;
    if ("void".equals(forcedReturnType))
        return method.returnType.id == TypeIds.T_void;
    if ("boolean".equals(forcedReturnType))
        return method.returnType.id == TypeIds.T_boolean;
    return false;
}

From source file:lombok.eclipse.handlers.HandleBuilder.java

License:Open Source License

@Override
public void handle(AnnotationValues<Builder> annotation, Annotation ast, EclipseNode annotationNode) {
    long p = (long) ast.sourceStart << 32 | ast.sourceEnd;

    Builder builderInstance = annotation.getInstance();

    // These exist just to support the 'old' lombok.experimental.Builder, which had these properties. lombok.Builder no longer has them.
    boolean fluent = toBoolean(annotation.getActualExpression("fluent"), true);
    boolean chain = toBoolean(annotation.getActualExpression("chain"), true);

    String builderMethodName = builderInstance.builderMethodName();
    String buildMethodName = builderInstance.buildMethodName();
    String builderClassName = builderInstance.builderClassName();
    String toBuilderMethodName = "toBuilder";
    boolean toBuilder = builderInstance.toBuilder();
    List<char[]> typeArgsForToBuilder = null;

    if (builderMethodName == null)
        builderMethodName = "builder";
    if (buildMethodName == null)
        builderMethodName = "build";
    if (builderClassName == null)
        builderClassName = "";

    if (!checkName("builderMethodName", builderMethodName, annotationNode))
        return;// ww w.  j av a2 s.  c  o m
    if (!checkName("buildMethodName", buildMethodName, annotationNode))
        return;
    if (!builderClassName.isEmpty()) {
        if (!checkName("builderClassName", builderClassName, annotationNode))
            return;
    }

    EclipseNode parent = annotationNode.up();

    List<BuilderFieldData> builderFields = new ArrayList<BuilderFieldData>();
    TypeReference returnType;
    TypeParameter[] typeParams;
    TypeReference[] thrownExceptions;
    char[] nameOfStaticBuilderMethod;
    EclipseNode tdParent;

    EclipseNode fillParametersFrom = parent.get() instanceof AbstractMethodDeclaration ? parent : null;
    boolean addCleaning = false;

    if (parent.get() instanceof TypeDeclaration) {
        tdParent = parent;
        TypeDeclaration td = (TypeDeclaration) tdParent.get();

        List<EclipseNode> allFields = new ArrayList<EclipseNode>();
        @SuppressWarnings("deprecation")
        boolean valuePresent = (hasAnnotation(lombok.Value.class, parent)
                || hasAnnotation(lombok.experimental.Value.class, parent));
        for (EclipseNode fieldNode : HandleConstructor.findAllFields(tdParent)) {
            FieldDeclaration fd = (FieldDeclaration) fieldNode.get();
            // final fields with an initializer cannot be written to, so they can't be 'builderized'. Unfortunately presence of @Value makes
            // non-final fields final, but @Value's handler hasn't done this yet, so we have to do this math ourselves.
            // Value will only skip making a field final if it has an explicit @NonFinal annotation, so we check for that.
            if (fd.initialization != null && valuePresent && !hasAnnotation(NonFinal.class, fieldNode))
                continue;
            BuilderFieldData bfd = new BuilderFieldData();
            bfd.rawName = fieldNode.getName().toCharArray();
            bfd.name = removePrefixFromField(fieldNode);
            bfd.type = fd.type;
            bfd.singularData = getSingularData(fieldNode, ast);
            addObtainVia(bfd, fieldNode);
            builderFields.add(bfd);
            allFields.add(fieldNode);
        }

        new HandleConstructor().generateConstructor(tdParent, AccessLevel.PACKAGE, allFields, false, null,
                SkipIfConstructorExists.I_AM_BUILDER, null, Collections.<Annotation>emptyList(),
                annotationNode);

        returnType = namePlusTypeParamsToTypeReference(td.name, td.typeParameters, p);
        typeParams = td.typeParameters;
        thrownExceptions = null;
        nameOfStaticBuilderMethod = null;
        if (builderClassName.isEmpty())
            builderClassName = new String(td.name) + "Builder";
    } else if (parent.get() instanceof ConstructorDeclaration) {
        ConstructorDeclaration cd = (ConstructorDeclaration) parent.get();
        if (cd.typeParameters != null && cd.typeParameters.length > 0) {
            annotationNode
                    .addError("@Builder is not supported on constructors with constructor type parameters.");
            return;
        }

        tdParent = parent.up();
        TypeDeclaration td = (TypeDeclaration) tdParent.get();
        returnType = namePlusTypeParamsToTypeReference(td.name, td.typeParameters, p);
        typeParams = td.typeParameters;
        thrownExceptions = cd.thrownExceptions;
        nameOfStaticBuilderMethod = null;
        if (builderClassName.isEmpty())
            builderClassName = new String(cd.selector) + "Builder";
    } else if (parent.get() instanceof MethodDeclaration) {
        MethodDeclaration md = (MethodDeclaration) parent.get();
        tdParent = parent.up();
        if (!md.isStatic()) {
            annotationNode.addError("@Builder is only supported on types, constructors, and static methods.");
            return;
        }

        if (toBuilder) {
            final String TO_BUILDER_NOT_SUPPORTED = "@Builder(toBuilder=true) is only supported if you return your own type.";
            char[] token;
            char[][] pkg = null;
            if (md.returnType.dimensions() > 0) {
                annotationNode.addError(TO_BUILDER_NOT_SUPPORTED);
                return;
            }

            if (md.returnType instanceof SingleTypeReference) {
                token = ((SingleTypeReference) md.returnType).token;
            } else if (md.returnType instanceof QualifiedTypeReference) {
                pkg = ((QualifiedTypeReference) md.returnType).tokens;
                token = pkg[pkg.length];
                char[][] pkg_ = new char[pkg.length - 1][];
                System.arraycopy(pkg, 0, pkg_, 0, pkg_.length);
                pkg = pkg_;
            } else {
                annotationNode.addError(TO_BUILDER_NOT_SUPPORTED);
                return;
            }

            if (pkg != null && !equals(parent.getPackageDeclaration(), pkg)) {
                annotationNode.addError(TO_BUILDER_NOT_SUPPORTED);
                return;
            }

            if (tdParent == null || !equals(tdParent.getName(), token)) {
                annotationNode.addError(TO_BUILDER_NOT_SUPPORTED);
                return;
            }

            TypeParameter[] tpOnType = ((TypeDeclaration) tdParent.get()).typeParameters;
            TypeParameter[] tpOnMethod = md.typeParameters;
            TypeReference[][] tpOnRet_ = null;
            if (md.returnType instanceof ParameterizedSingleTypeReference) {
                tpOnRet_ = new TypeReference[1][];
                tpOnRet_[0] = ((ParameterizedSingleTypeReference) md.returnType).typeArguments;
            } else if (md.returnType instanceof ParameterizedQualifiedTypeReference) {
                tpOnRet_ = ((ParameterizedQualifiedTypeReference) md.returnType).typeArguments;
            }

            if (tpOnRet_ != null)
                for (int i = 0; i < tpOnRet_.length - 1; i++) {
                    if (tpOnRet_[i] != null && tpOnRet_[i].length > 0) {
                        annotationNode.addError(
                                "@Builder(toBuilder=true) is not supported if returning a type with generics applied to an intermediate.");
                        return;
                    }
                }
            TypeReference[] tpOnRet = tpOnRet_ == null ? null : tpOnRet_[tpOnRet_.length - 1];
            typeArgsForToBuilder = new ArrayList<char[]>();

            // Every typearg on this method needs to be found in the return type, but the reverse is not true.
            // We also need to 'map' them.

            if (tpOnMethod != null)
                for (TypeParameter onMethod : tpOnMethod) {
                    int pos = -1;
                    if (tpOnRet != null)
                        for (int i = 0; i < tpOnRet.length; i++) {
                            if (tpOnRet[i].getClass() != SingleTypeReference.class)
                                continue;
                            if (!Arrays.equals(((SingleTypeReference) tpOnRet[i]).token, onMethod.name))
                                continue;
                            pos = i;
                        }
                    if (pos == -1 || tpOnType == null || tpOnType.length <= pos) {
                        annotationNode.addError(
                                "@Builder(toBuilder=true) requires that each type parameter on the static method is part of the typeargs of the return value. Type parameter "
                                        + new String(onMethod.name) + " is not part of the return type.");
                        return;
                    }

                    typeArgsForToBuilder.add(tpOnType[pos].name);
                }
        }

        returnType = copyType(md.returnType, ast);
        typeParams = md.typeParameters;
        thrownExceptions = md.thrownExceptions;
        nameOfStaticBuilderMethod = md.selector;
        if (builderClassName.isEmpty()) {
            char[] token;
            if (md.returnType instanceof QualifiedTypeReference) {
                char[][] tokens = ((QualifiedTypeReference) md.returnType).tokens;
                token = tokens[tokens.length - 1];
            } else if (md.returnType instanceof SingleTypeReference) {
                token = ((SingleTypeReference) md.returnType).token;
                if (!(md.returnType instanceof ParameterizedSingleTypeReference) && typeParams != null) {
                    for (TypeParameter tp : typeParams) {
                        if (Arrays.equals(tp.name, token)) {
                            annotationNode.addError(
                                    "@Builder requires specifying 'builderClassName' if used on methods with a type parameter as return type.");
                            return;
                        }
                    }
                }
            } else {
                annotationNode.addError(
                        "Unexpected kind of return type on annotated method. Specify 'builderClassName' to solve this problem.");
                return;
            }

            if (Character.isLowerCase(token[0])) {
                char[] newToken = new char[token.length];
                System.arraycopy(token, 1, newToken, 1, token.length - 1);
                newToken[0] = Character.toTitleCase(token[0]);
                token = newToken;
            }

            builderClassName = new String(token) + "Builder";
        }
    } else {
        annotationNode.addError("@Builder is only supported on types, constructors, and static methods.");
        return;
    }

    if (fillParametersFrom != null) {
        for (EclipseNode param : fillParametersFrom.down()) {
            if (param.getKind() != Kind.ARGUMENT)
                continue;
            BuilderFieldData bfd = new BuilderFieldData();
            Argument arg = (Argument) param.get();
            bfd.rawName = arg.name;
            bfd.name = arg.name;
            bfd.type = arg.type;
            bfd.singularData = getSingularData(param, ast);
            addObtainVia(bfd, param);
            builderFields.add(bfd);
        }
    }

    EclipseNode builderType = findInnerClass(tdParent, builderClassName);
    if (builderType == null) {
        builderType = makeBuilderClass(tdParent, builderClassName, typeParams, ast);
    } else {
        sanityCheckForMethodGeneratingAnnotationsOnBuilderClass(builderType, annotationNode);
        /* generate errors for @Singular BFDs that have one already defined node. */ {
            for (BuilderFieldData bfd : builderFields) {
                SingularData sd = bfd.singularData;
                if (sd == null)
                    continue;
                EclipseSingularizer singularizer = sd.getSingularizer();
                if (singularizer == null)
                    continue;
                if (singularizer.checkForAlreadyExistingNodesAndGenerateError(builderType, sd)) {
                    bfd.singularData = null;
                }
            }
        }
    }

    for (BuilderFieldData bfd : builderFields) {
        if (bfd.singularData != null && bfd.singularData.getSingularizer() != null) {
            if (bfd.singularData.getSingularizer().requiresCleaning()) {
                addCleaning = true;
                break;
            }
        }
        if (bfd.obtainVia != null) {
            if (bfd.obtainVia.field().isEmpty() == bfd.obtainVia.method().isEmpty()) {
                bfd.obtainViaNode.addError(
                        "The syntax is either @ObtainVia(field = \"fieldName\") or @ObtainVia(method = \"methodName\").");
                return;
            }
            if (bfd.obtainVia.method().isEmpty() && bfd.obtainVia.isStatic()) {
                bfd.obtainViaNode
                        .addError("@ObtainVia(isStatic = true) is not valid unless 'method' has been set.");
                return;
            }
        }
    }

    generateBuilderFields(builderType, builderFields, ast);
    if (addCleaning) {
        FieldDeclaration cleanDecl = new FieldDeclaration(CLEAN_FIELD_NAME, 0, -1);
        cleanDecl.declarationSourceEnd = -1;
        cleanDecl.modifiers = ClassFileConstants.AccPrivate;
        cleanDecl.type = TypeReference.baseTypeReference(TypeIds.T_boolean, 0);
        injectFieldAndMarkGenerated(builderType, cleanDecl);
    }

    if (constructorExists(builderType) == MemberExistsResult.NOT_EXISTS) {
        ConstructorDeclaration cd = HandleConstructor.createConstructor(AccessLevel.PACKAGE, builderType,
                Collections.<EclipseNode>emptyList(), false, null, annotationNode,
                Collections.<Annotation>emptyList());
        if (cd != null)
            injectMethod(builderType, cd);
    }

    for (BuilderFieldData bfd : builderFields) {
        makeSetterMethodsForBuilder(builderType, bfd, annotationNode, fluent, chain);
    }

    if (methodExists(buildMethodName, builderType, -1) == MemberExistsResult.NOT_EXISTS) {
        MethodDeclaration md = generateBuildMethod(buildMethodName, nameOfStaticBuilderMethod, returnType,
                builderFields, builderType, thrownExceptions, addCleaning, ast);
        if (md != null)
            injectMethod(builderType, md);
    }

    if (methodExists("toString", builderType, 0) == MemberExistsResult.NOT_EXISTS) {
        List<EclipseNode> fieldNodes = new ArrayList<EclipseNode>();
        for (BuilderFieldData bfd : builderFields) {
            fieldNodes.addAll(bfd.createdFields);
        }
        MethodDeclaration md = HandleToString.createToString(builderType, fieldNodes, true, false, ast,
                FieldAccess.ALWAYS_FIELD);
        if (md != null)
            injectMethod(builderType, md);
    }

    if (addCleaning) {
        MethodDeclaration cleanMethod = generateCleanMethod(builderFields, builderType, ast);
        if (cleanMethod != null)
            injectMethod(builderType, cleanMethod);
    }

    if (methodExists(builderMethodName, tdParent, -1) == MemberExistsResult.NOT_EXISTS) {
        MethodDeclaration md = generateBuilderMethod(builderMethodName, builderClassName, tdParent, typeParams,
                ast);
        if (md != null)
            injectMethod(tdParent, md);
    }

    if (toBuilder)
        switch (methodExists(toBuilderMethodName, tdParent, 0)) {
        case EXISTS_BY_USER:
            annotationNode.addWarning("Not generating toBuilder() as it already exists.");
            break;
        case NOT_EXISTS:
            TypeParameter[] tps = typeParams;
            if (typeArgsForToBuilder != null) {
                tps = new TypeParameter[typeArgsForToBuilder.size()];
                for (int i = 0; i < tps.length; i++) {
                    tps[i] = new TypeParameter();
                    tps[i].name = typeArgsForToBuilder.get(i);
                }
            }
            MethodDeclaration md = generateToBuilderMethod(toBuilderMethodName, builderClassName, tdParent, tps,
                    builderFields, fluent, ast);

            if (md != null)
                injectMethod(tdParent, md);
        }
}