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

Introduction

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

Prototype

int T_null

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

Click Source Link

Usage

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  w ww  .j a  va2 s.com*/
            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.mirror.UnknownTypeMirror.java

License:Open Source License

public JDTType(TypeBinding type, IdentityHashMap<TypeBinding, JDTType> originatingTypes) {
    originatingTypes.put(type, this);

    // type params are not qualified
    if (type instanceof TypeVariableBinding)
        qualifiedName = new String(type.qualifiedSourceName());
    else//from w  w w.ja  v  a 2  s . c o m
        qualifiedName = JDTUtils.getFullyQualifiedName(type);

    typeKind = findKind(type);

    isPrimitive = type.isBaseType() && type.id != TypeIds.T_void && type.id != TypeIds.T_null;

    isRaw = type.isRawType();

    if (type instanceof ParameterizedTypeBinding && !(type instanceof RawTypeBinding)) {
        TypeBinding[] javaTypeArguments = ((ParameterizedTypeBinding) type).arguments;
        if (javaTypeArguments == null) {
            javaTypeArguments = new TypeBinding[0];
        }
        typeArguments = new ArrayList<TypeMirror>(javaTypeArguments.length);
        for (TypeBinding typeArgument : javaTypeArguments)
            typeArguments.add(toTypeMirror(typeArgument, type, this, originatingTypes));
    } else {
        typeArguments = Collections.emptyList();
    }

    if (type instanceof ArrayBinding) {
        TypeBinding jdtComponentType = ((ArrayBinding) type).elementsType();
        componentType = toTypeMirror(jdtComponentType, type, this, originatingTypes);
    } else {
        componentType = null;
    }

    if (type.isWildcard()) {
        WildcardBinding wildcardBinding = (WildcardBinding) type;
        if (wildcardBinding.boundKind == Wildcard.EXTENDS) {
            TypeBinding upperBoundBinding = wildcardBinding.bound;
            if (upperBoundBinding != null) {
                upperBound = toTypeMirror(upperBoundBinding, type, this, originatingTypes);
            }
        }
    } else if (type.isTypeVariable()) {
        TypeVariableBinding typeVariableBinding = (TypeVariableBinding) type;
        TypeBinding boundBinding = typeVariableBinding.firstBound; // TODO : we should confirm this
        if (boundBinding != null) {
            upperBound = toTypeMirror(boundBinding, type, this, originatingTypes);
        }
    } else {
        upperBound = null;
    }

    if (type.isWildcard()) {
        WildcardBinding wildcardBinding = (WildcardBinding) type;
        if (wildcardBinding.boundKind == Wildcard.SUPER) {
            TypeBinding lowerBoundBinding = wildcardBinding.bound;
            if (lowerBoundBinding != null) {
                lowerBound = toTypeMirror(lowerBoundBinding, type, this, originatingTypes);
            }
        }
    }

    if (type instanceof ParameterizedTypeBinding || type instanceof SourceTypeBinding
            || type instanceof BinaryTypeBinding) {
        ReferenceBinding refBinding = (ReferenceBinding) type;
        declaredClass = new JDTClass(refBinding, JDTModelLoader.toType(refBinding));
    }

    if (type instanceof TypeVariableBinding) {
        typeParameter = new JDTTypeParameter((TypeVariableBinding) type, this, originatingTypes);
    }
}

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   w w  w.  jav  a 2s  . c o  m
    }
    if (type instanceof ReferenceBinding)
        return TypeKind.DECLARED;
    throw new RuntimeException("Unknown type: " + type);
}

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  w  w  . j a v a  2  s  .  c o  m*/
        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;
}

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

Introduction

Prototype

Usage