Example usage for org.eclipse.jdt.internal.compiler.lookup TypeBinding getPackage

Introduction

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

Prototype

public abstract PackageBinding getPackage();

Source Link

Usage

From source file:com.codenvy.ide.ext.java.server.internal.core.search.matching.TypeDeclarationLocator.java

License:Open Source License

/**
 * Returns whether the given type binding matches the given simple name pattern
 * qualification pattern and enclosing type name pattern.
 *//*from  w  w w .  j a  va  2  s  .c o  m*/
protected int resolveLevelForType(char[] simpleNamePattern, char[] qualificationPattern,
        char[] enclosingNamePattern, TypeBinding type) {
    if (enclosingNamePattern == null)
        return resolveLevelForType(simpleNamePattern, qualificationPattern, type);
    if (qualificationPattern == null)
        return resolveLevelForType(simpleNamePattern, enclosingNamePattern, type);

    // case of an import reference while searching for ALL_OCCURENCES of a type (see bug 37166)
    if (type instanceof ProblemReferenceBinding)
        return IMPOSSIBLE_MATCH;

    // pattern was created from a Java element: qualification is the package name.
    char[] fullQualificationPattern = CharOperation.concat(qualificationPattern, enclosingNamePattern, '.');
    if (CharOperation.equals(this.pattern.pkg, CharOperation.concatWith(type.getPackage().compoundName, '.')))
        return resolveLevelForType(simpleNamePattern, fullQualificationPattern, type);
    return IMPOSSIBLE_MATCH;
}

---

From source file:spoon.support.compiler.jdt.ReferenceBuilder.java

License:Open Source License

/**
 * @param resolveGeneric if true then it never returns CtTypeParameterReference, but it's superClass instead
 *//*from   w  w  w . j  a v a2s  .  co  m*/
<T> CtTypeReference<T> getTypeReference(TypeBinding binding, boolean resolveGeneric) {
    if (binding == null) {
        return null;
    }

    CtTypeReference<?> ref;

    if (binding instanceof RawTypeBinding) {
        ref = getTypeReference(((ParameterizedTypeBinding) binding).genericType());
    } else if (binding instanceof ParameterizedTypeBinding) {
        if (binding.actualType() != null && binding.actualType() instanceof LocalTypeBinding) {
            // When we define a nested class in a method and when the enclosing class of this method
            // is a parameterized type binding, JDT give a ParameterizedTypeBinding for the nested class
            // and hide the real class in actualType().
            ref = getTypeReference(binding.actualType());
        } else {
            ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
            this.exploringParameterizedBindings.put(binding, ref);
            if (binding.isAnonymousType()) {
                ref.setSimpleName("");
            } else {
                ref.setSimpleName(String.valueOf(binding.sourceName()));
                if (binding.enclosingType() != null) {
                    ref.setDeclaringType(getTypeReference(binding.enclosingType()));
                } else {
                    ref.setPackage(getPackageReference(binding.getPackage()));
                }
            }
        }
        if (binding.actualType() instanceof MissingTypeBinding) {
            ref = getTypeReference(binding.actualType());
        }

        if (((ParameterizedTypeBinding) binding).arguments != null) {
            for (TypeBinding b : ((ParameterizedTypeBinding) binding).arguments) {
                if (bindingCache.containsKey(b)) {
                    ref.addActualTypeArgument(getCtCircularTypeReference(b));
                } else {
                    if (!this.exploringParameterizedBindings.containsKey(b)) {
                        this.exploringParameterizedBindings.put(b, null);
                        CtTypeReference typeRefB = getTypeReference(b);
                        this.exploringParameterizedBindings.put(b, typeRefB);
                        ref.addActualTypeArgument(typeRefB);
                    } else {
                        CtTypeReference typeRefB = this.exploringParameterizedBindings.get(b);
                        if (typeRefB != null) {
                            ref.addActualTypeArgument(typeRefB.clone());
                        }
                    }
                }
            }
        }
    } else if (binding instanceof MissingTypeBinding) {
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        ref.setSimpleName(new String(binding.sourceName()));
        ref.setPackage(getPackageReference(binding.getPackage()));
        if (!this.jdtTreeBuilder.getContextBuilder().ignoreComputeImports) {
            final CtReference declaring = this.getDeclaringReferenceFromImports(binding.sourceName());
            if (declaring instanceof CtPackageReference) {
                ref.setPackage((CtPackageReference) declaring);
            } else if (declaring instanceof CtTypeReference) {
                ref.setDeclaringType((CtTypeReference) declaring);
            }
        }
    } else if (binding instanceof BinaryTypeBinding) {
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        if (binding.enclosingType() != null) {
            ref.setDeclaringType(getTypeReference(binding.enclosingType()));
        } else {
            ref.setPackage(getPackageReference(binding.getPackage()));
        }
        ref.setSimpleName(new String(binding.sourceName()));
    } else if (binding instanceof TypeVariableBinding) {
        boolean oldBounds = bounds;

        if (binding instanceof CaptureBinding) {
            ref = this.jdtTreeBuilder.getFactory().Core().createWildcardReference();
            bounds = true;
        } else {
            TypeVariableBinding typeParamBinding = (TypeVariableBinding) binding;
            if (resolveGeneric) {
                //it is called e.g. by ExecutableReference, which must not use CtParameterTypeReference
                //but it needs it's bounding type instead
                ReferenceBinding superClass = typeParamBinding.superclass;
                ReferenceBinding[] superInterfaces = typeParamBinding.superInterfaces();

                CtTypeReference refSuperClass = null;

                // if the type parameter has a super class other than java.lang.Object, we get it
                // superClass.superclass() is null if it's java.lang.Object
                if (superClass != null && !(superClass.superclass() == null)) {

                    // this case could happen with Enum<E extends Enum<E>> for example:
                    // in that case we only want to have E -> Enum -> E
                    // to conserve the same behavior as JavaReflectionTreeBuilder
                    if (!(superClass instanceof ParameterizedTypeBinding)
                            || !this.exploringParameterizedBindings.containsKey(superClass)) {
                        refSuperClass = this.getTypeReference(superClass, resolveGeneric);
                    }

                    // if the type parameter has a super interface, then we'll get it too, as a superclass
                    // type parameter can only extends an interface or a class, so we don't make the distinction
                    // in Spoon. Moreover we can only have one extends in a type parameter.
                } else if (superInterfaces != null && superInterfaces.length == 1) {
                    refSuperClass = this.getTypeReference(superInterfaces[0], resolveGeneric);
                }
                if (refSuperClass == null) {
                    refSuperClass = this.jdtTreeBuilder.getFactory().Type().getDefaultBoundingType();
                }
                ref = refSuperClass.clone();
            } else {
                ref = this.jdtTreeBuilder.getFactory().Core().createTypeParameterReference();
                ref.setSimpleName(new String(binding.sourceName()));
            }
        }
        TypeVariableBinding b = (TypeVariableBinding) binding;
        if (bounds) {
            if (b instanceof CaptureBinding && ((CaptureBinding) b).wildcard != null) {
                bounds = oldBounds;
                return getTypeReference(((CaptureBinding) b).wildcard, resolveGeneric);
            } else if (b.superclass != null && b.firstBound == b.superclass) {
                bounds = false;
                bindingCache.put(binding, ref);
                if (ref instanceof CtWildcardReference) {
                    ((CtWildcardReference) ref).setBoundingType(getTypeReference(b.superclass, resolveGeneric));
                }
                bounds = oldBounds;
            }
        }
        if (bounds && b.superInterfaces != null && b.superInterfaces != Binding.NO_SUPERINTERFACES) {
            bindingCache.put(binding, ref);
            List<CtTypeReference<?>> bounds = new ArrayList<>();
            CtTypeParameterReference typeParameterReference = (CtTypeParameterReference) ref;
            if (!(typeParameterReference.isDefaultBoundingType())) { // if it's object we can ignore it
                bounds.add(typeParameterReference.getBoundingType());
            }
            for (ReferenceBinding superInterface : b.superInterfaces) {
                bounds.add(getTypeReference(superInterface, resolveGeneric));
            }
            if (ref instanceof CtWildcardReference) {
                ((CtWildcardReference) ref).setBoundingType(this.jdtTreeBuilder.getFactory().Type()
                        .createIntersectionTypeReferenceWithBounds(bounds));
            }
        }
        if (binding instanceof CaptureBinding) {
            bounds = false;
        }
    } else if (binding instanceof BaseTypeBinding) {
        String name = new String(binding.sourceName());
        //always create new TypeReference, because clonning from a cache clones invalid SourcePosition
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        ref.setSimpleName(name);
    } else if (binding instanceof WildcardBinding) {
        WildcardBinding wildcardBinding = (WildcardBinding) binding;
        CtWildcardReference wref = this.jdtTreeBuilder.getFactory().Core().createWildcardReference();
        ref = wref;

        if (wildcardBinding.boundKind == Wildcard.SUPER) {
            wref.setUpper(false);
        }

        if (wildcardBinding.bound != null) {
            if (bindingCache.containsKey(wildcardBinding.bound)) {
                wref.setBoundingType(getCtCircularTypeReference(wildcardBinding.bound));
            } else {
                wref.setBoundingType(getTypeReference(((WildcardBinding) binding).bound));
            }
        }
    } else if (binding instanceof LocalTypeBinding) {
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        if (binding.isAnonymousType()) {
            ref.setSimpleName(JDTTreeBuilderHelper
                    .computeAnonymousName(((SourceTypeBinding) binding).constantPoolName()));
            ref.setDeclaringType(getTypeReference(binding.enclosingType()));
        } else {
            ref.setSimpleName(new String(binding.sourceName()));
            if (((LocalTypeBinding) binding).enclosingMethod == null && binding.enclosingType() != null
                    && binding.enclosingType() instanceof LocalTypeBinding) {
                ref.setDeclaringType(getTypeReference(binding.enclosingType()));
            } else if (binding.enclosingMethod() != null) {
                ref.setSimpleName(JDTTreeBuilderHelper
                        .computeAnonymousName(((SourceTypeBinding) binding).constantPoolName()));
                ref.setDeclaringType(getTypeReference(binding.enclosingType()));
            }
        }
    } else if (binding instanceof SourceTypeBinding) {
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        if (binding.isAnonymousType()) {
            ref.setSimpleName(JDTTreeBuilderHelper
                    .computeAnonymousName(((SourceTypeBinding) binding).constantPoolName()));
            ref.setDeclaringType(getTypeReference(binding.enclosingType()));
        } else {
            ref.setSimpleName(new String(binding.sourceName()));
            if (binding.enclosingType() != null) {
                ref.setDeclaringType(getTypeReference(binding.enclosingType()));
            } else {
                ref.setPackage(getPackageReference(binding.getPackage()));
            }
        }
    } else if (binding instanceof ArrayBinding) {
        CtArrayTypeReference<Object> arrayref;
        arrayref = this.jdtTreeBuilder.getFactory().Core().createArrayTypeReference();
        ref = arrayref;
        for (int i = 1; i < binding.dimensions(); i++) {
            CtArrayTypeReference<Object> tmp = this.jdtTreeBuilder.getFactory().Core()
                    .createArrayTypeReference();
            arrayref.setComponentType(tmp);
            arrayref = tmp;
        }
        arrayref.setComponentType(getTypeReference(binding.leafComponentType(), resolveGeneric));
    } else if (binding instanceof PolyTypeBinding) {
        // JDT can't resolve the type of this binding and we only have a string.
        // In this case, we return a type Object because we can't know more about it.
        ref = this.jdtTreeBuilder.getFactory().Type().objectType();
    } else if (binding instanceof ProblemReferenceBinding) {
        // Spoon is able to analyze also without the classpath
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        char[] readableName = binding.readableName();
        StringBuilder sb = new StringBuilder();
        for (int i = readableName.length - 1; i >= 0; i--) {
            char c = readableName[i];
            if (c == '.') {
                break;
            }
            sb.append(c);
        }
        sb.reverse();
        ref.setSimpleName(sb.toString());
        final CtReference declaring = this.getDeclaringReferenceFromImports(binding.sourceName());
        setPackageOrDeclaringType(ref, declaring);
    } else if (binding instanceof JDTTreeBuilder.SpoonReferenceBinding) {
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        ref.setSimpleName(new String(binding.sourceName()));
        ref.setDeclaringType(getTypeReference(binding.enclosingType()));
    } else if (binding instanceof IntersectionTypeBinding18) {
        List<CtTypeReference<?>> bounds = new ArrayList<>();
        for (ReferenceBinding superInterface : binding.getIntersectingTypes()) {
            bounds.add(getTypeReference(superInterface));
        }
        ref = this.jdtTreeBuilder.getFactory().Type().createIntersectionTypeReferenceWithBounds(bounds);
    } else {
        throw new RuntimeException("Unknown TypeBinding: " + binding.getClass() + " " + binding);
    }
    bindingCache.remove(binding);
    this.exploringParameterizedBindings.remove(binding);
    return (CtTypeReference<T>) ref;
}

---

From source file:spoon.test.prettyprinter.testclasses.ComplexClass.java

License:Open Source License

@SuppressWarnings("unchecked")
<T> CtTypeReference<T> getTypeReference(TypeBinding binding) {
    if (binding == null) {
        return null;
    }/*from  w w  w.  ja va 2  s .c o  m*/

    CtTypeReference<?> ref = null;

    if (binding instanceof RawTypeBinding) {
        ref = getTypeReference(((ParameterizedTypeBinding) binding).genericType());
    } else if (binding instanceof ParameterizedTypeBinding) {
        if (binding.actualType() != null && binding.actualType() instanceof LocalTypeBinding) {
            // When we define a nested class in a method and when the enclosing class of this method
            // is a parameterized type binding, JDT give a ParameterizedTypeBinding for the nested class
            // and hide the real class in actualType().
            ref = getTypeReference(binding.actualType());
        } else {
            ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
            this.exploringParameterizedBindings.put(binding, ref);
            if (binding.isAnonymousType()) {
                ref.setSimpleName("");
            } else {
                ref.setSimpleName(String.valueOf(binding.sourceName()));
                if (binding.enclosingType() != null) {
                    ref.setDeclaringType(getTypeReference(binding.enclosingType()));
                } else {
                    ref.setPackage(getPackageReference(binding.getPackage()));
                }
            }
        }
        if (binding.actualType() instanceof MissingTypeBinding) {
            ref = getTypeReference(binding.actualType());
        }

        if (((ParameterizedTypeBinding) binding).arguments != null) {
            for (TypeBinding b : ((ParameterizedTypeBinding) binding).arguments) {
                if (bindingCache.containsKey(b)) {
                    ref.addActualTypeArgument(getCtCircularTypeReference(b));
                } else {
                    if (!this.exploringParameterizedBindings.containsKey(b)) {
                        this.exploringParameterizedBindings.put(b, null);
                        CtTypeReference typeRefB = getTypeReference(b);
                        this.exploringParameterizedBindings.put(b, typeRefB);
                        ref.addActualTypeArgument(typeRefB);
                    } else {
                        CtTypeReference typeRefB = this.exploringParameterizedBindings.get(b);
                        if (typeRefB != null) {
                            ref.addActualTypeArgument(typeRefB.clone());
                        }
                    }
                }
            }
        }
    } else if (binding instanceof MissingTypeBinding) {
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        ref.setSimpleName(new String(binding.sourceName()));
        ref.setPackage(getPackageReference(binding.getPackage()));
        if (!this.jdtTreeBuilder.getContextBuilder().ignoreComputeImports) {
            final CtReference declaring = this.getDeclaringReferenceFromImports(binding.sourceName());
            if (declaring instanceof CtPackageReference) {
                ref.setPackage((CtPackageReference) declaring);
            } else if (declaring instanceof CtTypeReference) {
                ref.setDeclaringType((CtTypeReference) declaring);
            }
        }
    } else if (binding instanceof BinaryTypeBinding) {
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        if (binding.enclosingType() != null) {
            ref.setDeclaringType(getTypeReference(binding.enclosingType()));
        } else {
            ref.setPackage(getPackageReference(binding.getPackage()));
        }
        ref.setSimpleName(new String(binding.sourceName()));
    } else if (binding instanceof TypeVariableBinding) {
        boolean oldBounds = bounds;

        if (binding instanceof CaptureBinding) {
            ref = this.jdtTreeBuilder.getFactory().Core().createWildcardReference();
            bounds = true;
        } else {
            TypeVariableBinding typeParamBinding = (TypeVariableBinding) binding;
            ReferenceBinding superClass = typeParamBinding.superclass;
            ReferenceBinding[] superInterfaces = typeParamBinding.superInterfaces();

            CtTypeReference refSuperClass = null;

            // if the type parameter has a super class other than java.lang.Object, we get it
            // superClass.superclass() is null if it's java.lang.Object
            if (superClass != null && !(superClass.superclass() == null)) {

                // this case could happen with Enum<E extends Enum<E>> for example:
                // in that case we only want to have E -> Enum -> E
                // to conserve the same behavior as JavaReflectionTreeBuilder
                if (!(superClass instanceof ParameterizedTypeBinding)
                        || !this.exploringParameterizedBindings.containsKey(superClass)) {
                    refSuperClass = this.getTypeReference(superClass);
                }

                // if the type parameter has a super interface, then we'll get it too, as a superclass
                // type parameter can only extends an interface or a class, so we don't make the distinction
                // in Spoon. Moreover we can only have one extends in a type parameter.
            } else if (superInterfaces != null && superInterfaces.length == 1) {
                refSuperClass = this.getTypeReference(superInterfaces[0]);
            }

            ref = this.jdtTreeBuilder.getFactory().Core().createTypeParameterReference();
            ref.setSimpleName(new String(binding.sourceName()));

            if (refSuperClass != null) {
                ((CtTypeParameterReference) ref).addBound(refSuperClass);
            }
        }
        TypeVariableBinding b = (TypeVariableBinding) binding;
        if (bounds) {
            if (b instanceof CaptureBinding && ((CaptureBinding) b).wildcard != null) {
                bounds = oldBounds;
                return getTypeReference(((CaptureBinding) b).wildcard);
            } else if (b.superclass != null && b.firstBound == b.superclass) {
                bounds = false;
                bindingCache.put(binding, ref);
                ((CtTypeParameterReference) ref).setBoundingType(getTypeReference(b.superclass));
                bounds = oldBounds;
            }
        }
        if (bounds && b.superInterfaces != null && b.superInterfaces != Binding.NO_SUPERINTERFACES) {
            bounds = false;
            bindingCache.put(binding, ref);
            List<CtTypeReference<?>> bounds = new ArrayList<>();
            CtTypeParameterReference typeParameterReference = (CtTypeParameterReference) ref;
            if (!(typeParameterReference.isDefaultBoundingType())) { // if it's object we can ignore it
                bounds.add(typeParameterReference.getBoundingType());
            }
            for (ReferenceBinding superInterface : b.superInterfaces) {
                bounds.add(getTypeReference(superInterface));
            }
            ((CtTypeParameterReference) ref).setBoundingType(
                    this.jdtTreeBuilder.getFactory().Type().createIntersectionTypeReferenceWithBounds(bounds));
        }
        if (binding instanceof CaptureBinding) {
            bounds = false;
        }
    } else if (binding instanceof BaseTypeBinding) {
        String name = new String(binding.sourceName());
        //always create new TypeReference, because clonning from a cache clones invalid SourcePosition
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        ref.setSimpleName(name);
    } else if (binding instanceof WildcardBinding) {
        WildcardBinding wildcardBinding = (WildcardBinding) binding;
        ref = this.jdtTreeBuilder.getFactory().Core().createWildcardReference();

        if (wildcardBinding.boundKind == Wildcard.SUPER && ref instanceof CtTypeParameterReference) {
            ((CtTypeParameterReference) ref).setUpper(false);
        }

        if (wildcardBinding.bound != null && ref instanceof CtTypeParameterReference) {
            if (bindingCache.containsKey(wildcardBinding.bound)) {
                ((CtTypeParameterReference) ref)
                        .setBoundingType(getCtCircularTypeReference(wildcardBinding.bound));
            } else {

                ((CtTypeParameterReference) ref)
                        .setBoundingType(getTypeReference(((WildcardBinding) binding).bound));
            }
        }
    } else if (binding instanceof LocalTypeBinding) {
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        if (binding.isAnonymousType()) {
            ref.setSimpleName(JDTTreeBuilderHelper
                    .computeAnonymousName(((SourceTypeBinding) binding).constantPoolName()));
            ref.setDeclaringType(getTypeReference((binding.enclosingType())));
        } else {
            ref.setSimpleName(new String(binding.sourceName()));
            if (((LocalTypeBinding) binding).enclosingMethod == null && binding.enclosingType() != null
                    && binding.enclosingType() instanceof LocalTypeBinding) {
                ref.setDeclaringType(getTypeReference(binding.enclosingType()));
            } else if (binding.enclosingMethod() != null) {
                ref.setSimpleName(JDTTreeBuilderHelper
                        .computeAnonymousName(((SourceTypeBinding) binding).constantPoolName()));
                ref.setDeclaringType(getTypeReference(binding.enclosingType()));
            }
        }
    } else if (binding instanceof SourceTypeBinding) {
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        if (binding.isAnonymousType()) {
            ref.setSimpleName(JDTTreeBuilderHelper
                    .computeAnonymousName(((SourceTypeBinding) binding).constantPoolName()));
            ref.setDeclaringType(getTypeReference((binding.enclosingType())));
        } else {
            ref.setSimpleName(new String(binding.sourceName()));
            if (binding.enclosingType() != null) {
                ref.setDeclaringType(getTypeReference(binding.enclosingType()));
            } else {
                ref.setPackage(getPackageReference(binding.getPackage()));
            }
            // if(((SourceTypeBinding) binding).typeVariables!=null &&
            // ((SourceTypeBinding) binding).typeVariables.length>0){
            // for (TypeBinding b : ((SourceTypeBinding)
            // binding).typeVariables) {
            // ref.getActualTypeArguments().add(getTypeReference(b));
            // }
            // }
        }
    } else if (binding instanceof ArrayBinding) {
        CtArrayTypeReference<Object> arrayref;
        arrayref = this.jdtTreeBuilder.getFactory().Core().createArrayTypeReference();
        ref = arrayref;
        for (int i = 1; i < binding.dimensions(); i++) {
            CtArrayTypeReference<Object> tmp = this.jdtTreeBuilder.getFactory().Core()
                    .createArrayTypeReference();
            arrayref.setComponentType(tmp);
            arrayref = tmp;
        }
        arrayref.setComponentType(getTypeReference(binding.leafComponentType()));
    } else if (binding instanceof PolyTypeBinding) {
        // JDT can't resolve the type of this binding and we only have a string.
        // In this case, we return a type Object because we can't know more about it.
        ref = this.jdtTreeBuilder.getFactory().Type().objectType();
    } else if (binding instanceof ProblemReferenceBinding) {
        // Spoon is able to analyze also without the classpath
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        ref.setSimpleName(new String(binding.readableName()));
        final CtReference declaring = this.getDeclaringReferenceFromImports(binding.sourceName());
        setPackageOrDeclaringType(ref, declaring);
    } else if (binding instanceof JDTTreeBuilder.SpoonReferenceBinding) {
        ref = this.jdtTreeBuilder.getFactory().Core().createTypeReference();
        ref.setSimpleName(new String(binding.sourceName()));
        ref.setDeclaringType(getTypeReference(binding.enclosingType()));
    } else if (binding instanceof IntersectionTypeBinding18) {
        List<CtTypeReference<?>> bounds = new ArrayList<>();
        for (ReferenceBinding superInterface : binding.getIntersectingTypes()) {
            bounds.add(getTypeReference(superInterface));
        }
        ref = this.jdtTreeBuilder.getFactory().Type().createIntersectionTypeReferenceWithBounds(bounds);
    } else {
        throw new RuntimeException("Unknown TypeBinding: " + binding.getClass() + " " + binding);
    }
    bindingCache.remove(binding);
    this.exploringParameterizedBindings.remove(binding);
    return (CtTypeReference<T>) ref;
}

---