Example usage for org.eclipse.jdt.internal.compiler.lookup UnresolvedReferenceBinding resolve

Introduction

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

Prototype

ReferenceBinding resolve(LookupEnvironment environment, boolean convertGenericToRawType) 

Source Link

Usage

From source file:org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.AbstractAttribute.java

License:Open Source License

ReferenceBinding resolveReferenceType(LookupEnvironment environment, UnresolvedReferenceBinding type) {
    return type.resolve(environment, false);
}

---

From source file:org.eclipse.objectteams.otdt.internal.core.compiler.util.RoleTypeCreator.java

License:Open Source License

public static TypeBinding maybeWrapUnqualifiedRoleType(final Scope scope, final ReferenceBinding site,
        TypeBinding typeToWrap, final ASTNode typedNode, ProblemReporter problemReporter) {
    assert (!(site == null));
    if (typeToWrap == null)
        return null;
    if (!typeToWrap.isValidBinding())
        return typeToWrap; // don't tamper with already broken type

    if (TSuperHelper.isMarkerInterface(typeToWrap))
        return typeToWrap;

    final TypeBinding originalType = typeToWrap;

    // consider arrays:
    int dimensions = typeToWrap.dimensions();
    typeToWrap = typeToWrap.leafComponentType();

    // consider parameterized:
    TypeBinding[] arguments = null;//from  w  ww.  j  a  va 2  s  .  co m
    if (typeToWrap.isParameterizedType())
        arguments = ((ParameterizedTypeBinding) typeToWrap).arguments;

    // easy problems first:
    if (!(typeToWrap instanceof ReferenceBinding) || typeToWrap.isEnum())
        return originalType;

    if (typeToWrap instanceof UnresolvedReferenceBinding) {
        // defer wrapping until resolve():
        final UnresolvedReferenceBinding rawUnresolved = (UnresolvedReferenceBinding) typeToWrap;
        final ProblemReporter originalReporter = problemReporter;
        return new UnresolvedReferenceBinding(rawUnresolved.compoundName, rawUnresolved.getPackage()) {
            @Override
            public ReferenceBinding resolve(LookupEnvironment environment, boolean convertGenericToRawType) {
                ReferenceBinding type = rawUnresolved.resolve(environment, convertGenericToRawType);
                return (ReferenceBinding) maybeWrapUnqualifiedRoleType(scope, site, type, typedNode,
                        originalReporter);
            }

            @Override
            public boolean hasTypeAnnotations() {
                return rawUnresolved.hasTypeAnnotations();
            }

            @Override
            public boolean hasNullTypeAnnotations() {
                return rawUnresolved.hasNullTypeAnnotations();
            }

            @Override
            public AnnotationBinding[] getAnnotations() {
                return rawUnresolved.getAnnotations();
            }

            {
                this.tagBits = rawUnresolved.tagBits;
            }
        };
    }
    if (typeToWrap instanceof IntersectionTypeBinding18) { // FIXME (recurse?)
        return originalType;
    }
    ReferenceBinding refBinding = (ReferenceBinding) typeToWrap;
    if (!refBinding.isDirectRole()) {
        final ProblemReporter reporter = problemReporter;
        return originalType.maybeWrapRoleType(typedNode, new TypeArgumentUpdater() {
            public TypeBinding updateArg(ReferenceBinding arg) {
                return maybeWrapUnqualifiedRoleType(scope, site, arg, typedNode, reporter);
            }
        });
    }

    // already wrapped:
    if (typeToWrap instanceof RoleTypeBinding) {
        RoleTypeBinding roleType = (RoleTypeBinding) typeToWrap;
        if (!(roleType._teamAnchor instanceof TThisBinding)) {
            return originalType; // cannot improve
        } else {
            // do handle tthis RoleTypeBindings, too, because we might need to
            // set a new anchor
            // (but don't report errors, if this type is already acceptable).
            if (TeamModel.findEnclosingTeamContainingRole(site, roleType) != null)
                problemReporter = null;
        }
    }

    VariableBinding variableBinding = null;
    ReferenceBinding teamBinding = TeamModel.findEnclosingTeamContainingRole(site, refBinding);
    if (teamBinding != null)
        variableBinding = TThisBinding.getTThisForRole(refBinding, teamBinding);
    if (variableBinding == null)
        variableBinding = cannotWrapType(refBinding, problemReporter, typedNode);

    // handle problems (reported ones and yet unreported ones):
    assert (variableBinding != null);
    if (variableBinding == RoleTypeBinding.NoAnchor) {
        return originalType;
    } else if (!variableBinding.isFinal()) {
        if (problemReporter != null)
            problemReporter.anchorPathNotFinal(null, variableBinding, refBinding.sourceName()); // TODO
        return null;
    } else if (!(variableBinding instanceof TThisBinding) && !refBinding.isPublic()) {
        if (problemReporter != null)
            problemReporter.externalizingNonPublicRole(typedNode, refBinding);
        return null;
    }

    // delegate to the principal function:
    return getAnchoredType(scope, typedNode, variableBinding, refBinding, arguments, dimensions);
}

---