Example usage for org.eclipse.jdt.internal.compiler.lookup TypeConstants JAVA_LANG_STRING

Introduction

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

Prototype

null JAVA_LANG_STRING

To view the source code for org.eclipse.jdt.internal.compiler.lookup TypeConstants JAVA_LANG_STRING.

Click Source Link

Usage

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

License:Open Source License

private void createInnerTypeFieldNameConstants(EclipseNode typeNode, EclipseNode errorNode, ASTNode source,
        AccessLevel level, List<EclipseNode> fields, boolean asEnum, String innerTypeName) {
    if (fields.isEmpty())
        return;// w  w w .  j a  v a  2 s.co  m

    ASTVisitor generatedByVisitor = new SetGeneratedByVisitor(source);
    TypeDeclaration parent = (TypeDeclaration) typeNode.get();
    EclipseNode fieldsType = findInnerClass(typeNode, innerTypeName);
    boolean genConstr = false, genClinit = false;
    char[] name = innerTypeName.toCharArray();
    TypeDeclaration generatedInnerType = null;
    if (fieldsType == null) {
        generatedInnerType = new TypeDeclaration(parent.compilationResult);
        generatedInnerType.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
        generatedInnerType.modifiers = toEclipseModifier(level) | (asEnum ? ClassFileConstants.AccEnum
                : (ClassFileConstants.AccStatic | ClassFileConstants.AccFinal));
        generatedInnerType.name = name;
        fieldsType = injectType(typeNode, generatedInnerType);
        genConstr = true;
        genClinit = asEnum;
        generatedInnerType.traverse(generatedByVisitor, ((TypeDeclaration) typeNode.get()).scope);
    } else {
        TypeDeclaration builderTypeDeclaration = (TypeDeclaration) fieldsType.get();
        if (asEnum && (builderTypeDeclaration.modifiers & ClassFileConstants.AccEnum) == 0) {
            errorNode.addError("Existing " + innerTypeName + " must be declared as an 'enum'.");
            return;
        }
        if (!asEnum && (builderTypeDeclaration.modifiers & ClassFileConstants.AccStatic) == 0) {
            errorNode.addError("Existing " + innerTypeName + " must be declared as a 'static class'.");
            return;
        }
        genConstr = constructorExists(fieldsType) == MemberExistsResult.NOT_EXISTS;
    }

    if (genConstr) {
        ConstructorDeclaration constructor = new ConstructorDeclaration(parent.compilationResult);
        constructor.selector = name;
        constructor.modifiers = ClassFileConstants.AccPrivate;
        ExplicitConstructorCall superCall = new ExplicitConstructorCall(0);
        superCall.sourceStart = source.sourceStart;
        superCall.sourceEnd = source.sourceEnd;
        superCall.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
        constructor.constructorCall = superCall;
        if (!asEnum)
            constructor.statements = new Statement[0];
        injectMethod(fieldsType, constructor);
    }

    if (genClinit) {
        Clinit cli = new Clinit(parent.compilationResult);
        injectMethod(fieldsType, cli);
        cli.traverse(generatedByVisitor, ((TypeDeclaration) fieldsType.get()).scope);
    }

    for (EclipseNode fieldNode : fields) {
        FieldDeclaration field = (FieldDeclaration) fieldNode.get();
        char[] fName = field.name;
        if (fieldExists(new String(fName), fieldsType) != MemberExistsResult.NOT_EXISTS)
            continue;
        int pS = source.sourceStart, pE = source.sourceEnd;
        long p = (long) pS << 32 | pE;
        FieldDeclaration constantField = new FieldDeclaration(fName, pS, pE);
        constantField.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
        if (asEnum) {
            AllocationExpression ac = new AllocationExpression();
            ac.enumConstant = constantField;
            ac.sourceStart = source.sourceStart;
            ac.sourceEnd = source.sourceEnd;
            constantField.initialization = ac;
            constantField.modifiers = 0;
        } else {
            constantField.type = new QualifiedTypeReference(TypeConstants.JAVA_LANG_STRING,
                    new long[] { p, p, p });
            constantField.initialization = new StringLiteral(field.name, pS, pE, 0);
            constantField.modifiers = ClassFileConstants.AccPublic | ClassFileConstants.AccStatic
                    | ClassFileConstants.AccFinal;
        }
        injectField(fieldsType, constantField);
        constantField.traverse(generatedByVisitor, ((TypeDeclaration) fieldsType.get()).initializerScope);
    }
}

---

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

License:Open Source License

public static MethodDeclaration createToString(EclipseNode type, Collection<EclipseNode> fields,
        boolean includeFieldNames, boolean callSuper, ASTNode source, FieldAccess fieldAccess) {
    String typeName = getTypeName(type);
    char[] suffix = ")".toCharArray();
    String infixS = ", ";
    char[] infix = infixS.toCharArray();
    int pS = source.sourceStart, pE = source.sourceEnd;
    long p = (long) pS << 32 | pE;
    final int PLUS = OperatorIds.PLUS;

    char[] prefix;

    if (callSuper) {
        prefix = (typeName + "(super=").toCharArray();
    } else if (fields.isEmpty()) {
        prefix = (typeName + "()").toCharArray();
    } else if (includeFieldNames) {
        prefix = (typeName + "(" + new String(((FieldDeclaration) fields.iterator().next().get()).name) + "=")
                .toCharArray();//  ww w.j ava2  s . c  o  m
    } else {
        prefix = (typeName + "(").toCharArray();
    }

    boolean first = true;
    Expression current = new StringLiteral(prefix, pS, pE, 0);
    setGeneratedBy(current, source);

    if (callSuper) {
        MessageSend callToSuper = new MessageSend();
        callToSuper.sourceStart = pS;
        callToSuper.sourceEnd = pE;
        setGeneratedBy(callToSuper, source);
        callToSuper.receiver = new SuperReference(pS, pE);
        setGeneratedBy(callToSuper, source);
        callToSuper.selector = "toString".toCharArray();
        current = new BinaryExpression(current, callToSuper, PLUS);
        setGeneratedBy(current, source);
        first = false;
    }

    for (EclipseNode field : fields) {
        TypeReference fieldType = getFieldType(field, fieldAccess);
        Expression fieldAccessor = createFieldAccessor(field, fieldAccess, source);

        // The distinction between primitive and object will be useful if we ever add a 'hideNulls' option.
        boolean fieldBaseTypeIsPrimitive = BUILT_IN_TYPES.contains(new String(fieldType.getLastToken()));
        boolean fieldIsPrimitive = fieldType.dimensions() == 0 && fieldBaseTypeIsPrimitive;
        boolean fieldIsPrimitiveArray = fieldType.dimensions() == 1 && fieldBaseTypeIsPrimitive;
        boolean fieldIsObjectArray = fieldType.dimensions() > 0 && !fieldIsPrimitiveArray;
        @SuppressWarnings("unused")
        boolean fieldIsObject = !fieldIsPrimitive && !fieldIsPrimitiveArray && !fieldIsObjectArray;

        Expression ex;
        if (fieldIsPrimitiveArray || fieldIsObjectArray) {
            MessageSend arrayToString = new MessageSend();
            arrayToString.sourceStart = pS;
            arrayToString.sourceEnd = pE;
            arrayToString.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA, TypeConstants.UTIL,
                    "Arrays".toCharArray());
            arrayToString.arguments = new Expression[] { fieldAccessor };
            setGeneratedBy(arrayToString.arguments[0], source);
            arrayToString.selector = (fieldIsObjectArray ? "deepToString" : "toString").toCharArray();
            ex = arrayToString;
        } else {
            ex = fieldAccessor;
        }
        setGeneratedBy(ex, source);

        if (first) {
            current = new BinaryExpression(current, ex, PLUS);
            current.sourceStart = pS;
            current.sourceEnd = pE;
            setGeneratedBy(current, source);
            first = false;
            continue;
        }

        StringLiteral fieldNameLiteral;
        if (includeFieldNames) {
            char[] namePlusEqualsSign = (infixS + field.getName() + "=").toCharArray();
            fieldNameLiteral = new StringLiteral(namePlusEqualsSign, pS, pE, 0);
        } else {
            fieldNameLiteral = new StringLiteral(infix, pS, pE, 0);
        }
        setGeneratedBy(fieldNameLiteral, source);
        current = new BinaryExpression(current, fieldNameLiteral, PLUS);
        setGeneratedBy(current, source);
        current = new BinaryExpression(current, ex, PLUS);
        setGeneratedBy(current, source);
    }
    if (!first) {
        StringLiteral suffixLiteral = new StringLiteral(suffix, pS, pE, 0);
        setGeneratedBy(suffixLiteral, source);
        current = new BinaryExpression(current, suffixLiteral, PLUS);
        setGeneratedBy(current, source);
    }

    ReturnStatement returnStatement = new ReturnStatement(current, pS, pE);
    setGeneratedBy(returnStatement, source);

    MethodDeclaration method = new MethodDeclaration(
            ((CompilationUnitDeclaration) type.top().get()).compilationResult);
    setGeneratedBy(method, source);
    method.modifiers = toEclipseModifier(AccessLevel.PUBLIC);
    method.returnType = new QualifiedTypeReference(TypeConstants.JAVA_LANG_STRING, new long[] { p, p, p });
    setGeneratedBy(method.returnType, source);
    method.annotations = new Annotation[] { makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, source) };
    method.arguments = null;
    method.selector = "toString".toCharArray();
    method.thrownExceptions = null;
    method.typeParameters = null;
    method.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
    method.bodyStart = method.declarationSourceStart = method.sourceStart = source.sourceStart;
    method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = source.sourceEnd;
    method.statements = new Statement[] { returnStatement };
    return method;
}

---

From source file:org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding.java

License:Open Source License

public void computeId() {
    // try to avoid multiple checks against a package/type name
    switch (this.compoundName.length) {

    case 3:// w w  w  . j  av  a  2  s .c  o  m
        if (!CharOperation.equals(TypeConstants.JAVA, this.compoundName[0]))
            return;

        char[] packageName = this.compoundName[1];
        if (packageName.length == 0)
            return; // just to be safe
        char[] typeName = this.compoundName[2];
        if (typeName.length == 0)
            return; // just to be safe
        // remaining types MUST be in java.*.*
        if (!CharOperation.equals(TypeConstants.LANG, this.compoundName[1])) {
            switch (packageName[0]) {
            case 'i':
                if (CharOperation.equals(packageName, TypeConstants.IO)) {
                    switch (typeName[0]) {
                    case 'E':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_EXTERNALIZABLE[2]))
                            this.id = TypeIds.T_JavaIoExternalizable;
                        return;
                    case 'I':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_IOEXCEPTION[2]))
                            this.id = TypeIds.T_JavaIoException;
                        return;
                    case 'O':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_OBJECTSTREAMEXCEPTION[2]))
                            this.id = TypeIds.T_JavaIoObjectStreamException;
                        return;
                    case 'P':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_PRINTSTREAM[2]))
                            this.id = TypeIds.T_JavaIoPrintStream;
                        return;
                    case 'S':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_SERIALIZABLE[2]))
                            this.id = TypeIds.T_JavaIoSerializable;
                        return;
                    }
                }
                return;
            case 'u':
                if (CharOperation.equals(packageName, TypeConstants.UTIL)) {
                    switch (typeName[0]) {
                    case 'C':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_UTIL_COLLECTION[2]))
                            this.id = TypeIds.T_JavaUtilCollection;
                        return;
                    case 'I':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_UTIL_ITERATOR[2]))
                            this.id = TypeIds.T_JavaUtilIterator;
                        return;
                    }
                }
                return;
            }
            return;
        }

        // remaining types MUST be in java.lang.*
        switch (typeName[0]) {
        case 'A':
            switch (typeName.length) {
            case 13:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2]))
                    this.id = TypeIds.T_JavaLangAutoCloseable;
                return;
            case 14:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))
                    this.id = TypeIds.T_JavaLangAssertionError;
                return;
            }
            return;
        case 'B':
            switch (typeName.length) {
            case 4:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_BYTE[2]))
                    this.id = TypeIds.T_JavaLangByte;
                return;
            case 7:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_BOOLEAN[2]))
                    this.id = TypeIds.T_JavaLangBoolean;
                return;
            }
            return;
        case 'C':
            switch (typeName.length) {
            case 5:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CLASS[2]))
                    this.id = TypeIds.T_JavaLangClass;
                return;
            case 9:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CHARACTER[2]))
                    this.id = TypeIds.T_JavaLangCharacter;
                else if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CLONEABLE[2]))
                    this.id = TypeIds.T_JavaLangCloneable;
                return;
            case 22:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CLASSNOTFOUNDEXCEPTION[2]))
                    this.id = TypeIds.T_JavaLangClassNotFoundException;
                return;
            }
            return;
        case 'D':
            switch (typeName.length) {
            case 6:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_DOUBLE[2]))
                    this.id = TypeIds.T_JavaLangDouble;
                return;
            case 10:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_DEPRECATED[2]))
                    this.id = TypeIds.T_JavaLangDeprecated;
                return;
            }
            return;
        case 'E':
            switch (typeName.length) {
            case 4:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ENUM[2]))
                    this.id = TypeIds.T_JavaLangEnum;
                return;
            case 5:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ERROR[2]))
                    this.id = TypeIds.T_JavaLangError;
                return;
            case 9:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_EXCEPTION[2]))
                    this.id = TypeIds.T_JavaLangException;
                return;
            }
            return;
        case 'F':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_FLOAT[2]))
                this.id = TypeIds.T_JavaLangFloat;
            return;
        case 'I':
            switch (typeName.length) {
            case 7:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_INTEGER[2]))
                    this.id = TypeIds.T_JavaLangInteger;
                return;
            case 8:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ITERABLE[2]))
                    this.id = TypeIds.T_JavaLangIterable;
                return;
            case 24:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ILLEGALARGUMENTEXCEPTION[2]))
                    this.id = TypeIds.T_JavaLangIllegalArgumentException;
                return;
            }
            return;
        case 'L':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_LONG[2]))
                this.id = TypeIds.T_JavaLangLong;
            return;
        case 'N':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_NOCLASSDEFERROR[2]))
                this.id = TypeIds.T_JavaLangNoClassDefError;
            return;
        case 'O':
            switch (typeName.length) {
            case 6:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_OBJECT[2]))
                    this.id = TypeIds.T_JavaLangObject;
                return;
            case 8:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_OVERRIDE[2]))
                    this.id = TypeIds.T_JavaLangOverride;
                return;
            }
            return;
        case 'R':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_RUNTIMEEXCEPTION[2]))
                this.id = TypeIds.T_JavaLangRuntimeException;
            break;
        case 'S':
            switch (typeName.length) {
            case 5:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SHORT[2]))
                    this.id = TypeIds.T_JavaLangShort;
                return;
            case 6:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_STRING[2]))
                    this.id = TypeIds.T_JavaLangString;
                else if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SYSTEM[2]))
                    this.id = TypeIds.T_JavaLangSystem;
                return;
            case 11:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SAFEVARARGS[2]))
                    this.id = TypeIds.T_JavaLangSafeVarargs;
                return;
            case 12:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_STRINGBUFFER[2]))
                    this.id = TypeIds.T_JavaLangStringBuffer;
                return;
            case 13:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_STRINGBUILDER[2]))
                    this.id = TypeIds.T_JavaLangStringBuilder;
                return;
            case 16:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SUPPRESSWARNINGS[2]))
                    this.id = TypeIds.T_JavaLangSuppressWarnings;
                return;
            }
            return;
        case 'T':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_THROWABLE[2]))
                this.id = TypeIds.T_JavaLangThrowable;
            return;
        case 'V':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_VOID[2]))
                this.id = TypeIds.T_JavaLangVoid;
            return;
        }
        break;

    case 4:
        if (!CharOperation.equals(TypeConstants.JAVA, this.compoundName[0]))
            return;
        packageName = this.compoundName[1];
        if (packageName.length == 0)
            return; // just to be safe

        packageName = this.compoundName[2];
        if (packageName.length == 0)
            return; // just to be safe
        typeName = this.compoundName[3];
        if (typeName.length == 0)
            return; // just to be safe
        switch (packageName[0]) {
        case 'a':
            if (CharOperation.equals(packageName, TypeConstants.ANNOTATION)) {
                switch (typeName[0]) {
                case 'A':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_ANNOTATION[3]))
                        this.id = TypeIds.T_JavaLangAnnotationAnnotation;
                    return;
                case 'D':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_DOCUMENTED[3]))
                        this.id = TypeIds.T_JavaLangAnnotationDocumented;
                    return;
                case 'E':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_ELEMENTTYPE[3]))
                        this.id = TypeIds.T_JavaLangAnnotationElementType;
                    return;
                case 'I':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_INHERITED[3]))
                        this.id = TypeIds.T_JavaLangAnnotationInherited;
                    return;
                case 'R':
                    switch (typeName.length) {
                    case 9:
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_RETENTION[3]))
                            this.id = TypeIds.T_JavaLangAnnotationRetention;
                        return;
                    case 15:
                        if (CharOperation.equals(typeName,
                                TypeConstants.JAVA_LANG_ANNOTATION_RETENTIONPOLICY[3]))
                            this.id = TypeIds.T_JavaLangAnnotationRetentionPolicy;
                        return;
                    }
                    return;
                case 'T':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_TARGET[3]))
                        this.id = TypeIds.T_JavaLangAnnotationTarget;
                    return;
                }
            }
            return;
        case 'i':
            if (CharOperation.equals(packageName, TypeConstants.INVOKE)) {
                if (typeName.length == 0)
                    return; // just to be safe
                switch (typeName[0]) {
                case 'M':
                    if (CharOperation.equals(typeName,
                            TypeConstants.JAVA_LANG_INVOKE_METHODHANDLE_$_POLYMORPHICSIGNATURE[3]))
                        this.id = TypeIds.T_JavaLangInvokeMethodHandlePolymorphicSignature;
                    return;
                }
            }
            return;
        case 'r':
            if (CharOperation.equals(packageName, TypeConstants.REFLECT)) {
                switch (typeName[0]) {
                case 'C':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_REFLECT_CONSTRUCTOR[2]))
                        this.id = TypeIds.T_JavaLangReflectConstructor;
                    return;
                case 'F':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_REFLECT_FIELD[2]))
                        this.id = TypeIds.T_JavaLangReflectField;
                    return;
                case 'M':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_REFLECT_METHOD[2]))
                        this.id = TypeIds.T_JavaLangReflectMethod;
                    return;
                }
            }
            return;
        }
        break;
    case 5:
        if (!CharOperation.equals(TypeConstants.JAVA, this.compoundName[0]))
            return;
        packageName = this.compoundName[1];
        if (packageName.length == 0)
            return; // just to be safe

        if (CharOperation.equals(TypeConstants.LANG, packageName)) {
            packageName = this.compoundName[2];
            if (packageName.length == 0)
                return; // just to be safe
            switch (packageName[0]) {
            case 'i':
                if (CharOperation.equals(packageName, TypeConstants.INVOKE)) {
                    typeName = this.compoundName[3];
                    if (typeName.length == 0)
                        return; // just to be safe
                    switch (typeName[0]) {
                    case 'M':
                        char[] memberTypeName = this.compoundName[4];
                        if (memberTypeName.length == 0)
                            return; // just to be safe
                        if (CharOperation.equals(typeName,
                                TypeConstants.JAVA_LANG_INVOKE_METHODHANDLE_POLYMORPHICSIGNATURE[3])
                                && CharOperation.equals(memberTypeName,
                                        TypeConstants.JAVA_LANG_INVOKE_METHODHANDLE_POLYMORPHICSIGNATURE[4]))
                            this.id = TypeIds.T_JavaLangInvokeMethodHandlePolymorphicSignature;
                        return;
                    }
                }
                return;
            }
            return;
        }
    }
}

---

From source file:org.eclipse.jdt.internal.compiler.lookup.Scope.java

License:Open Source License

public final ReferenceBinding getJavaLangString() {
    CompilationUnitScope unitScope = compilationUnitScope();
    unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_STRING);
    return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_STRING, this);
}

---