org.eclipse.jdt.internal.compiler.ast.AllocationExpression.java Source code

Java tutorial

Introduction

Here is the source code for org.eclipse.jdt.internal.compiler.ast.AllocationExpression.java

Source

/*******************************************************************************
 * Copyright (c) 2000, 2019 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contributions for
 *                       bug 236385 - [compiler] Warn for potential programming problem if an object is created but not used
 *                       bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
 *                       bug 349326 - [1.7] new warning for missing try-with-resources
 *                      bug 186342 - [compiler][null] Using annotations for null checking
 *                     bug 358903 - Filter practically unimportant resource leak warnings
 *                     bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
 *                     bug 370639 - [compiler][resource] restore the default for resource leak warnings
 *                     bug 345305 - [compiler][null] Compiler misidentifies a case of "variable can only be null"
 *                     bug 388996 - [compiler][resource] Incorrect 'potential resource leak'
 *                     bug 403147 - [compiler][null] FUP of bug 400761: consolidate interaction between unboxing, NPE, and deferred checking
 *                     Bug 392238 - [1.8][compiler][null] Detect semantically invalid null type annotations
 *                     Bug 417295 - [1.8[[null] Massage type annotated null analysis to gel well with deep encoded type bindings.
 *                     Bug 400874 - [1.8][compiler] Inference infrastructure should evolve to meet JLS8 18.x (Part G of JSR335 spec)
 *                     Bug 424727 - [compiler][null] NullPointerException in nullAnnotationUnsupportedLocation(ProblemReporter.java:5708)
 *                     Bug 424710 - [1.8][compiler] CCE in SingleNameReference.localVariableBinding
 *                     Bug 425152 - [1.8] [compiler] Lambda Expression not resolved but flow analyzed leading to NPE.
 *                     Bug 424205 - [1.8] Cannot infer type for diamond type with lambda on method invocation
 *                     Bug 424415 - [1.8][compiler] Eventual resolution of ReferenceExpression is not seen to be happening.
 *                     Bug 426366 - [1.8][compiler] Type inference doesn't handle multiple candidate target types in outer overload context
 *                     Bug 426290 - [1.8][compiler] Inference + overloading => wrong method resolution ?
 *                     Bug 426764 - [1.8] Presence of conditional expression as method argument confuses compiler
 *                     Bug 424930 - [1.8][compiler] Regression: "Cannot infer type arguments" error from compiler.
 *                     Bug 427483 - [Java 8] Variables in lambdas sometimes can't be resolved
 *                     Bug 427438 - [1.8][compiler] NPE at org.eclipse.jdt.internal.compiler.ast.ConditionalExpression.generateCode(ConditionalExpression.java:280)
 *                     Bug 426996 - [1.8][inference] try to avoid method Expression.unresolve()? 
 *                     Bug 428352 - [1.8][compiler] Resolution errors don't always surface
 *                     Bug 429203 - [1.8][compiler] NPE in AllocationExpression.binding
 *                     Bug 429430 - [1.8] Lambdas and method reference infer wrong exception type with generics (RuntimeException instead of IOException)
 *                     Bug 434297 - [1.8] NPE in LamdaExpression.analyseCode with lamda expression nested in a conditional expression
 *                     Bug 452788 - [1.8][compiler] Type not correctly inferred in lambda expression
 *                     Bug 448709 - [1.8][null] ensure we don't infer types that violate null constraints on a type parameter's bound
 *     Jesper S Moller <jesper@selskabet.org> - Contributions for
 *                     bug 378674 - "The method can be declared as static" is wrong
 *     Andy Clement (GoPivotal, Inc) aclement@gopivotal.com - Contributions for
 *                          Bug 383624 - [1.8][compiler] Revive code generation support for type annotations (from Olivier's work)
 *                          Bug 409245 - [1.8][compiler] Type annotations dropped when call is routed through a synthetic bridge method
 *     Till Brychcy - Contributions for
 *                       bug 413460 - NonNullByDefault is not inherited to Constructors when accessed via Class File
 *     Lars Vogel <Lars.Vogel@vogella.com> - Contributions for
 *                       Bug 473178
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;

import static org.eclipse.jdt.internal.compiler.ast.ExpressionContext.*;

import java.util.HashMap;

import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.*;
import org.eclipse.jdt.internal.compiler.flow.*;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.*;
import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;

public class AllocationExpression extends Expression implements IPolyExpression, Invocation {

    public TypeReference type;
    public Expression[] arguments;
    public MethodBinding binding; // exact binding resulting from lookup
    MethodBinding syntheticAccessor; // synthetic accessor for inner-emulation
    public TypeReference[] typeArguments;
    public TypeBinding[] genericTypeArguments;
    public FieldDeclaration enumConstant; // for enum constant initializations
    protected TypeBinding typeExpected; // for <> inference
    public boolean inferredReturnType;

    public FakedTrackingVariable closeTracker; // when allocation a Closeable store a pre-liminary tracking variable here
    public ExpressionContext expressionContext = VANILLA_CONTEXT;

    // hold on to this context from invocation applicability inference until invocation type inference (per method candidate):
    private SimpleLookupTable/*<PMB,IC18>*/ inferenceContexts;
    public HashMap<TypeBinding, MethodBinding> solutionsPerTargetType;
    private InferenceContext18 outerInferenceContext; // resolving within the context of an outer (lambda) inference?
    public boolean argsContainCast;
    public TypeBinding[] argumentTypes = Binding.NO_PARAMETERS;
    public boolean argumentsHaveErrors = false;

    @Override
    public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
        // check captured variables are initialized in current context (26134)
        checkCapturedLocalInitializationIfNecessary((ReferenceBinding) this.binding.declaringClass.erasure(),
                currentScope, flowInfo);

        // process arguments
        if (this.arguments != null) {
            boolean analyseResources = currentScope.compilerOptions().analyseResourceLeaks;
            boolean hasResourceWrapperType = analyseResources && this.resolvedType instanceof ReferenceBinding
                    && ((ReferenceBinding) this.resolvedType).hasTypeBit(TypeIds.BitWrapperCloseable);
            for (int i = 0, count = this.arguments.length; i < count; i++) {
                flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
                // if argument is an AutoCloseable insert info that it *may* be closed (by the target method, i.e.)
                if (analyseResources && !hasResourceWrapperType) { // allocation of wrapped closeables is analyzed specially
                    flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo,
                            flowContext, false);
                }
                this.arguments[i].checkNPEbyUnboxing(currentScope, flowContext, flowInfo);
            }
            analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);
        }

        // record some dependency information for exception types
        ReferenceBinding[] thrownExceptions;
        if (((thrownExceptions = this.binding.thrownExceptions).length) != 0) {
            if ((this.bits & ASTNode.Unchecked) != 0 && this.genericTypeArguments == null) {
                // https://bugs.eclipse.org/bugs/show_bug.cgi?id=277643, align with javac on JLS 15.12.2.6
                thrownExceptions = currentScope.environment().convertToRawTypes(this.binding.thrownExceptions, true,
                        true);
            }
            // check exception handling
            flowContext.checkExceptionHandlers(thrownExceptions, this, flowInfo.unconditionalCopy(), currentScope);
        }

        // after having analysed exceptions above start tracking newly allocated resource:
        if (currentScope.compilerOptions().analyseResourceLeaks
                && FakedTrackingVariable.isAnyCloseable(this.resolvedType))
            FakedTrackingVariable.analyseCloseableAllocation(currentScope, flowInfo, this);

        ReferenceBinding declaringClass = this.binding.declaringClass;
        MethodScope methodScope = currentScope.methodScope();
        if ((declaringClass.isMemberType() && !declaringClass.isStatic())
                || (declaringClass.isLocalType() && !methodScope.isStatic && methodScope.isLambdaScope())) {
            // allocating a non-static member type without an enclosing instance of parent type
            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=335845
            currentScope.tagAsAccessingEnclosingInstanceStateOf(this.binding.declaringClass.enclosingType(),
                    false /* type variable access */);
            // Reviewed for https://bugs.eclipse.org/bugs/show_bug.cgi?id=378674 :
            // The corresponding problem (when called from static) is not produced until during code generation
        }
        manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
        manageSyntheticAccessIfNecessary(currentScope, flowInfo);

        // account for possible exceptions thrown by the constructor
        flowContext.recordAbruptExit(); // TODO whitelist of ctors that cannot throw any exc.??

        return flowInfo;
    }

    public void checkCapturedLocalInitializationIfNecessary(ReferenceBinding checkedType, BlockScope currentScope,
            FlowInfo flowInfo) {
        if (((checkedType.tagBits & (TagBits.AnonymousTypeMask | TagBits.LocalTypeMask)) == TagBits.LocalTypeMask)
                && !currentScope.isDefinedInType(checkedType)) { // only check external allocations
            NestedTypeBinding nestedType = (NestedTypeBinding) checkedType;
            SyntheticArgumentBinding[] syntheticArguments = nestedType.syntheticOuterLocalVariables();
            if (syntheticArguments != null)
                for (int i = 0, count = syntheticArguments.length; i < count; i++) {
                    SyntheticArgumentBinding syntheticArgument = syntheticArguments[i];
                    LocalVariableBinding targetLocal;
                    if ((targetLocal = syntheticArgument.actualOuterLocalVariable) == null)
                        continue;
                    if (targetLocal.declaration != null && !flowInfo.isDefinitelyAssigned(targetLocal)) {
                        currentScope.problemReporter().uninitializedLocalVariable(targetLocal, this, currentScope);
                    }
                }
        }
    }

    public Expression enclosingInstance() {
        return null;
    }

    @Override
    public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
        cleanUpInferenceContexts();
        if (!valueRequired)
            currentScope.problemReporter().unusedObjectAllocation(this);

        int pc = codeStream.position;
        MethodBinding codegenBinding = this.binding.original();
        ReferenceBinding allocatedType = codegenBinding.declaringClass;

        codeStream.new_(this.type, allocatedType);
        boolean isUnboxing = (this.implicitConversion & TypeIds.UNBOXING) != 0;
        if (valueRequired || isUnboxing) {
            codeStream.dup();
        }
        // better highlight for allocation: display the type individually
        if (this.type != null) { // null for enum constant body
            codeStream.recordPositionsFrom(pc, this.type.sourceStart);
        } else {
            // push enum constant name and ordinal
            codeStream.ldc(String.valueOf(this.enumConstant.name));
            codeStream.generateInlinedValue(this.enumConstant.binding.id);
        }

        // handling innerclass instance allocation - enclosing instance arguments
        if (allocatedType.isNestedType()) {
            codeStream.generateSyntheticEnclosingInstanceValues(currentScope, allocatedType, enclosingInstance(),
                    this);
        }
        // generate the arguments for constructor
        generateArguments(this.binding, this.arguments, currentScope, codeStream);
        // handling innerclass instance allocation - outer local arguments
        if (allocatedType.isNestedType()) {
            codeStream.generateSyntheticOuterArgumentValues(currentScope, allocatedType, this);
        }
        // invoke constructor
        if (this.syntheticAccessor == null) {
            codeStream.invoke(Opcodes.OPC_invokespecial, codegenBinding, null /* default declaringClass */,
                    this.typeArguments);
        } else {
            // synthetic accessor got some extra arguments appended to its signature, which need values
            for (int i = 0, max = this.syntheticAccessor.parameters.length
                    - codegenBinding.parameters.length; i < max; i++) {
                codeStream.aconst_null();
            }
            codeStream.invoke(Opcodes.OPC_invokespecial, this.syntheticAccessor, null /* default declaringClass */,
                    this.typeArguments);
        }
        if (valueRequired) {
            codeStream.generateImplicitConversion(this.implicitConversion);
        } else if (isUnboxing) {
            // conversion only generated if unboxing
            codeStream.generateImplicitConversion(this.implicitConversion);
            switch (postConversionType(currentScope).id) {
            case T_long:
            case T_double:
                codeStream.pop2();
                break;
            default:
                codeStream.pop();
            }
        }
        codeStream.recordPositionsFrom(pc, this.sourceStart);
    }

    /**
     * @see org.eclipse.jdt.internal.compiler.lookup.InvocationSite#genericTypeArguments()
     */
    @Override
    public TypeBinding[] genericTypeArguments() {
        return this.genericTypeArguments;
    }

    @Override
    public boolean isSuperAccess() {
        return false;
    }

    @Override
    public boolean isTypeAccess() {
        return true;
    }

    /* Inner emulation consists in either recording a dependency
     * link only, or performing one level of propagation.
     *
     * Dependency mechanism is used whenever dealing with source target
     * types, since by the time we reach them, we might not yet know their
     * exact need.
     */
    public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
        if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) != 0)
            return;
        ReferenceBinding allocatedTypeErasure = (ReferenceBinding) this.binding.declaringClass.erasure();

        // perform some emulation work in case there is some and we are inside a local type only
        if (allocatedTypeErasure.isNestedType()
                && (currentScope.enclosingSourceType().isLocalType() || currentScope.isLambdaSubscope())) {

            if (allocatedTypeErasure.isLocalType()) {
                ((LocalTypeBinding) allocatedTypeErasure).addInnerEmulationDependent(currentScope, false);
                // request cascade of accesses
            } else {
                // locally propagate, since we already now the desired shape for sure
                currentScope.propagateInnerEmulation(allocatedTypeErasure, false);
                // request cascade of accesses
            }
        }
    }

    public void manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
        if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) != 0)
            return;
        // if constructor from parameterized type got found, use the original constructor at codegen time
        MethodBinding codegenBinding = this.binding.original();

        ReferenceBinding declaringClass;
        if (codegenBinding.isPrivate()
                && !currentScope.enclosingSourceType().isNestmateOf(this.binding.declaringClass)
                && TypeBinding.notEquals(currentScope.enclosingSourceType(),
                        (declaringClass = codegenBinding.declaringClass))) {

            // from 1.4 on, local type constructor can lose their private flag to ease emulation
            if ((declaringClass.tagBits & TagBits.IsLocalType) != 0
                    && currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4) {
                // constructor will not be dumped as private, no emulation required thus
                codegenBinding.tagBits |= TagBits.ClearPrivateModifier;
            } else {
                this.syntheticAccessor = ((SourceTypeBinding) declaringClass).addSyntheticMethod(codegenBinding,
                        isSuperAccess());
                currentScope.problemReporter().needToEmulateMethodAccess(codegenBinding, this);
            }
        }
    }

    @Override
    public StringBuffer printExpression(int indent, StringBuffer output) {
        if (this.type != null) { // type null for enum constant initializations
            output.append("new "); //$NON-NLS-1$
        }
        if (this.typeArguments != null) {
            output.append('<');
            int max = this.typeArguments.length - 1;
            for (int j = 0; j < max; j++) {
                this.typeArguments[j].print(0, output);
                output.append(", ");//$NON-NLS-1$
            }
            this.typeArguments[max].print(0, output);
            output.append('>');
        }
        if (this.type != null) { // type null for enum constant initializations
            this.type.printExpression(0, output);
        }
        output.append('(');
        if (this.arguments != null) {
            for (int i = 0; i < this.arguments.length; i++) {
                if (i > 0)
                    output.append(", "); //$NON-NLS-1$
                this.arguments[i].printExpression(0, output);
            }
        }
        return output.append(')');
    }

    @Override
    public TypeBinding resolveType(BlockScope scope) {
        // Propagate the type checking to the arguments, and check if the constructor is defined.
        final boolean isDiamond = this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0;
        final CompilerOptions compilerOptions = scope.compilerOptions();
        long sourceLevel = compilerOptions.sourceLevel;
        if (this.constant != Constant.NotAConstant) {
            this.constant = Constant.NotAConstant;
            if (this.type == null) {
                // initialization of an enum constant
                this.resolvedType = scope.enclosingReceiverType();
            } else {
                this.resolvedType = this.type.resolveType(scope, true /* check bounds*/);
            }
            if (this.type != null) {
                checkIllegalNullAnnotation(scope, this.resolvedType);
                checkParameterizedAllocation: {
                    if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
                        ReferenceBinding currentType = (ReferenceBinding) this.resolvedType;
                        if (currentType == null)
                            return currentType;
                        do {
                            // isStatic() is answering true for toplevel types
                            if ((currentType.modifiers & ClassFileConstants.AccStatic) != 0)
                                break checkParameterizedAllocation;
                            if (currentType.isRawType())
                                break checkParameterizedAllocation;
                        } while ((currentType = currentType.enclosingType()) != null);
                        ParameterizedQualifiedTypeReference qRef = (ParameterizedQualifiedTypeReference) this.type;
                        for (int i = qRef.typeArguments.length - 2; i >= 0; i--) {
                            if (qRef.typeArguments[i] != null) {
                                scope.problemReporter().illegalQualifiedParameterizedTypeAllocation(this.type,
                                        this.resolvedType);
                                break;
                            }
                        }
                    }
                }
            }
            // will check for null after args are resolved

            // resolve type arguments (for generic constructor call)
            if (this.typeArguments != null) {
                int length = this.typeArguments.length;
                this.argumentsHaveErrors = sourceLevel < ClassFileConstants.JDK1_5;
                this.genericTypeArguments = new TypeBinding[length];
                for (int i = 0; i < length; i++) {
                    TypeReference typeReference = this.typeArguments[i];
                    if ((this.genericTypeArguments[i] = typeReference.resolveType(scope,
                            true /* check bounds*/)) == null) {
                        this.argumentsHaveErrors = true;
                    }
                    if (this.argumentsHaveErrors && typeReference instanceof Wildcard) {
                        scope.problemReporter().illegalUsageOfWildcard(typeReference);
                    }
                }
                if (isDiamond) {
                    scope.problemReporter().diamondNotWithExplicitTypeArguments(this.typeArguments);
                    return null;
                }
                if (this.argumentsHaveErrors) {
                    if (this.arguments != null) { // still attempt to resolve arguments
                        for (int i = 0, max = this.arguments.length; i < max; i++) {
                            this.arguments[i].resolveType(scope);
                        }
                    }
                    return null;
                }
            }

            // buffering the arguments' types
            if (this.arguments != null) {
                this.argumentsHaveErrors = false;
                int length = this.arguments.length;
                this.argumentTypes = new TypeBinding[length];
                for (int i = 0; i < length; i++) {
                    Expression argument = this.arguments[i];
                    if (argument instanceof CastExpression) {
                        argument.bits |= DisableUnnecessaryCastCheck; // will check later on
                        this.argsContainCast = true;
                    }
                    argument.setExpressionContext(INVOCATION_CONTEXT);
                    if (this.arguments[i].resolvedType != null)
                        scope.problemReporter().genericInferenceError("Argument was unexpectedly found resolved", //$NON-NLS-1$
                                this);
                    if ((this.argumentTypes[i] = argument.resolveType(scope)) == null) {
                        this.argumentsHaveErrors = true;
                    }
                }
                if (this.argumentsHaveErrors) {
                    /* https://bugs.eclipse.org/bugs/show_bug.cgi?id=345359, if arguments have errors, completely bail out in the <> case.
                    No meaningful type resolution is possible since inference of the elided types is fully tied to argument types. Do
                    not return the partially resolved type.
                     */
                    if (isDiamond) {
                        return null; // not the partially cooked this.resolvedType
                    }
                    if (this.resolvedType instanceof ReferenceBinding) {
                        // record a best guess, for clients who need hint about possible constructor match
                        TypeBinding[] pseudoArgs = new TypeBinding[length];
                        for (int i = length; --i >= 0;) {
                            pseudoArgs[i] = this.argumentTypes[i] == null ? TypeBinding.NULL
                                    : this.argumentTypes[i]; // replace args with errors with null type
                        }
                        this.binding = scope.findMethod((ReferenceBinding) this.resolvedType, TypeConstants.INIT,
                                pseudoArgs, this, false);
                        if (this.binding != null && !this.binding.isValidBinding()) {
                            MethodBinding closestMatch = ((ProblemMethodBinding) this.binding).closestMatch;
                            // record the closest match, for clients who may still need hint about possible method match
                            if (closestMatch != null) {
                                if (closestMatch.original().typeVariables != Binding.NO_TYPE_VARIABLES) { // generic method
                                    // shouldn't return generic method outside its context, rather convert it to raw method (175409)
                                    closestMatch = scope.environment().createParameterizedGenericMethod(
                                            closestMatch.original(), (RawTypeBinding) null);
                                }
                                this.binding = closestMatch;
                                MethodBinding closestMatchOriginal = closestMatch.original();
                                if (closestMatchOriginal.isOrEnclosedByPrivateType()
                                        && !scope.isDefinedInMethod(closestMatchOriginal)) {
                                    // ignore cases where method is used from within inside itself (e.g. direct recursions)
                                    closestMatchOriginal.modifiers |= ExtraCompilerModifiers.AccLocallyUsed;
                                }
                            }
                        }
                    }
                    return this.resolvedType;
                }
            }
            if (this.resolvedType == null || !this.resolvedType.isValidBinding()) {
                return null;
            }

            // null type denotes fake allocation for enum constant inits
            if (this.type != null && !this.resolvedType.canBeInstantiated()) {
                scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);
                return this.resolvedType;
            }
        }
        if (isDiamond) {
            this.binding = inferConstructorOfElidedParameterizedType(scope);
            if (this.binding == null || !this.binding.isValidBinding()) {
                scope.problemReporter().cannotInferElidedTypes(this);
                return this.resolvedType = null;
            }
            if (this.typeExpected == null && compilerOptions.sourceLevel >= ClassFileConstants.JDK1_8
                    && this.expressionContext.definesTargetType()) {
                return new PolyTypeBinding(this);
            }
            this.resolvedType = this.type.resolvedType = this.binding.declaringClass;
            // 15.9.3 - If the compile-time declaration is applicable by variable arity invocation...
            if (this.binding.isVarargs()) {
                TypeBinding lastArg = this.binding.parameters[this.binding.parameters.length - 1]
                        .leafComponentType();
                if (!lastArg.erasure().canBeSeenBy(scope)) {
                    scope.problemReporter().invalidType(this,
                            new ProblemReferenceBinding(new char[][] { lastArg.readableName() },
                                    (ReferenceBinding) lastArg, ProblemReasons.NotVisible));
                    return this.resolvedType = null;
                }
            }
            this.binding = resolvePolyExpressionArguments(this, this.binding, this.argumentTypes, scope);
        } else {
            this.binding = findConstructorBinding(scope, this, (ReferenceBinding) this.resolvedType,
                    this.argumentTypes);
        }
        if (!this.binding.isValidBinding()) {
            if (this.binding.declaringClass == null) {
                this.binding.declaringClass = (ReferenceBinding) this.resolvedType;
            }
            if (this.type != null && !this.type.resolvedType.isValidBinding()) {
                return null;
            }
            scope.problemReporter().invalidConstructor(this, this.binding);
            return this.resolvedType;
        }
        if ((this.binding.tagBits & TagBits.HasMissingType) != 0) {
            scope.problemReporter().missingTypeInConstructor(this, this.binding);
        }
        if (isMethodUseDeprecated(this.binding, scope, true, this)) {
            scope.problemReporter().deprecatedMethod(this.binding, this);
        }
        if (checkInvocationArguments(scope, null, this.resolvedType, this.binding, this.arguments,
                this.argumentTypes, this.argsContainCast, this)) {
            this.bits |= ASTNode.Unchecked;
        }
        if (this.typeArguments != null && this.binding.original().typeVariables == Binding.NO_TYPE_VARIABLES) {
            scope.problemReporter().unnecessaryTypeArgumentsForMethodInvocation(this.binding,
                    this.genericTypeArguments, this.typeArguments);
        }
        if (!isDiamond && this.resolvedType.isParameterizedTypeWithActualArguments()) {
            checkTypeArgumentRedundancy((ParameterizedTypeBinding) this.resolvedType, scope);
        }
        if (compilerOptions.isAnnotationBasedNullAnalysisEnabled) {
            ImplicitNullAnnotationVerifier.ensureNullnessIsKnown(this.binding, scope);
            if (compilerOptions.sourceLevel >= ClassFileConstants.JDK1_8) {
                if (this.binding instanceof ParameterizedGenericMethodBinding && this.typeArguments != null) {
                    TypeVariableBinding[] typeVariables = this.binding.original().typeVariables();
                    for (int i = 0; i < this.typeArguments.length; i++)
                        this.typeArguments[i].checkNullConstraints(scope,
                                (ParameterizedGenericMethodBinding) this.binding, typeVariables, i);
                }
            }
        }
        if (compilerOptions.sourceLevel >= ClassFileConstants.JDK1_8
                && this.binding.getTypeAnnotations() != Binding.NO_ANNOTATIONS) {
            this.resolvedType = scope.environment().createAnnotatedType(this.resolvedType,
                    this.binding.getTypeAnnotations());
        }
        return this.resolvedType;
    }

    /**
     * Check if 'allocationType' illegally has a top-level null annotation.
     */
    void checkIllegalNullAnnotation(BlockScope scope, TypeBinding allocationType) {
        if (allocationType != null) {
            // only check top-level null annotation (annots on details are OK):
            long nullTagBits = allocationType.tagBits & TagBits.AnnotationNullMASK;
            if (nullTagBits != 0) {
                Annotation annotation = this.type.findAnnotation(nullTagBits);
                if (annotation != null)
                    scope.problemReporter().nullAnnotationUnsupportedLocation(annotation);
            }
        }
    }

    // For allocation expressions, boxing compatibility is same as vanilla compatibility, since java.lang's wrapper types are not generic.
    @Override
    public boolean isBoxingCompatibleWith(TypeBinding targetType, Scope scope) {
        return isPolyExpression() ? false : isCompatibleWith(scope.boxing(targetType), scope);
    }

    @Override
    public boolean isCompatibleWith(TypeBinding targetType, final Scope scope) {
        if (this.argumentsHaveErrors || this.binding == null || !this.binding.isValidBinding() || targetType == null
                || scope == null)
            return false;
        TypeBinding allocationType = this.resolvedType;
        if (isPolyExpression()) {
            TypeBinding originalExpectedType = this.typeExpected;
            try {
                MethodBinding method = this.solutionsPerTargetType != null
                        ? this.solutionsPerTargetType.get(targetType)
                        : null;
                if (method == null) {
                    this.typeExpected = targetType;
                    method = inferConstructorOfElidedParameterizedType(scope); // caches result already.
                    if (method == null || !method.isValidBinding())
                        return false;
                }
                allocationType = method.declaringClass;
            } finally {
                this.typeExpected = originalExpectedType;
            }
        }
        return allocationType != null && allocationType.isCompatibleWith(targetType, scope);
    }

    public MethodBinding inferConstructorOfElidedParameterizedType(final Scope scope) {
        if (this.typeExpected != null && this.binding != null) {
            MethodBinding cached = this.solutionsPerTargetType != null
                    ? this.solutionsPerTargetType.get(this.typeExpected)
                    : null;
            if (cached != null)
                return cached;
        }
        boolean[] inferredReturnTypeOut = new boolean[1];
        MethodBinding constructor = inferDiamondConstructor(scope, this, this.resolvedType, this.argumentTypes,
                inferredReturnTypeOut);
        if (constructor != null) {
            this.inferredReturnType = inferredReturnTypeOut[0];
            if (constructor instanceof ParameterizedGenericMethodBinding
                    && scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_8) {
                // force an inference context to be established for nested poly allocations (to be able to transfer b2), but avoid tunneling through overload resolution. We know this is the MSMB.
                if (this.expressionContext == INVOCATION_CONTEXT && this.typeExpected == null)
                    constructor = ParameterizedGenericMethodBinding.computeCompatibleMethod18(
                            constructor.shallowOriginal(), this.argumentTypes, scope, this);
            }
            if (this.typeExpected != null && this.typeExpected.isProperType(true))
                registerResult(this.typeExpected, constructor);
        }
        return constructor;
    }

    public static MethodBinding inferDiamondConstructor(Scope scope, InvocationSite site, TypeBinding type,
            TypeBinding[] argumentTypes, boolean[] inferredReturnTypeOut) {
        ReferenceBinding genericType = ((ParameterizedTypeBinding) type).genericType();
        ReferenceBinding enclosingType = type.enclosingType();
        ParameterizedTypeBinding allocationType = scope.environment().createParameterizedType(genericType,
                genericType.typeVariables(), enclosingType);

        // Given the allocation type and the arguments to the constructor, see if we can infer the constructor of the elided parameterized type.
        MethodBinding factory = scope.getStaticFactory(allocationType, enclosingType, argumentTypes, site);
        if (factory instanceof ParameterizedGenericMethodBinding && factory.isValidBinding()) {
            ParameterizedGenericMethodBinding genericFactory = (ParameterizedGenericMethodBinding) factory;
            inferredReturnTypeOut[0] = genericFactory.inferredReturnType;
            SyntheticFactoryMethodBinding sfmb = (SyntheticFactoryMethodBinding) factory.original();
            TypeVariableBinding[] constructorTypeVariables = sfmb.getConstructor().typeVariables();
            TypeBinding[] constructorTypeArguments = constructorTypeVariables != null
                    ? new TypeBinding[constructorTypeVariables.length]
                    : Binding.NO_TYPES;
            if (constructorTypeArguments.length > 0)
                System.arraycopy(((ParameterizedGenericMethodBinding) factory).typeArguments,
                        sfmb.typeVariables().length - constructorTypeArguments.length, constructorTypeArguments, 0,
                        constructorTypeArguments.length);
            if (allocationType.isInterface()) {
                ParameterizedTypeBinding parameterizedType = (ParameterizedTypeBinding) factory.returnType;
                return new ParameterizedMethodBinding(parameterizedType, sfmb.getConstructor());
            }
            return sfmb.applyTypeArgumentsOnConstructor(((ParameterizedTypeBinding) factory.returnType).arguments,
                    constructorTypeArguments, genericFactory.inferredWithUncheckedConversion,
                    site.invocationTargetType());
        }
        return null;
    }

    public TypeBinding[] inferElidedTypes(final Scope scope) {
        return inferElidedTypes((ParameterizedTypeBinding) this.resolvedType, scope);
    }

    public TypeBinding[] inferElidedTypes(ParameterizedTypeBinding parameterizedType, final Scope scope) {

        ReferenceBinding genericType = parameterizedType.genericType();
        ReferenceBinding enclosingType = parameterizedType.enclosingType();
        ParameterizedTypeBinding allocationType = scope.environment().createParameterizedType(genericType,
                genericType.typeVariables(), enclosingType);

        /* Given the allocation type and the arguments to the constructor, see if we can synthesize a generic static factory
           method that would, given the argument types and the invocation site, manufacture a parameterized object of type allocationType.
           If we are successful then by design and construction, the parameterization of the return type of the factory method is identical
           to the types elided in the <>.
        */
        MethodBinding factory = scope.getStaticFactory(allocationType, enclosingType, this.argumentTypes, this);
        if (factory instanceof ParameterizedGenericMethodBinding && factory.isValidBinding()) {
            ParameterizedGenericMethodBinding genericFactory = (ParameterizedGenericMethodBinding) factory;
            this.inferredReturnType = genericFactory.inferredReturnType;
            return ((ParameterizedTypeBinding) factory.returnType).arguments;
        }
        return null;
    }

    public void checkTypeArgumentRedundancy(ParameterizedTypeBinding allocationType, final BlockScope scope) {
        if ((scope.problemReporter()
                .computeSeverity(IProblem.RedundantSpecificationOfTypeArguments) == ProblemSeverities.Ignore)
                || scope.compilerOptions().sourceLevel < ClassFileConstants.JDK1_7)
            return;
        if (allocationType.arguments == null)
            return; // raw binding
        if (this.genericTypeArguments != null)
            return; // diamond can't occur with explicit type args for constructor
        if (this.type == null)
            return;
        if (this.argumentTypes == Binding.NO_PARAMETERS && this.typeExpected instanceof ParameterizedTypeBinding) {
            ParameterizedTypeBinding expected = (ParameterizedTypeBinding) this.typeExpected;
            if (expected.arguments != null && allocationType.arguments.length == expected.arguments.length) {
                // check the case when no ctor takes no params and inference uses the expected type directly
                // eg. X<String> x = new X<String>()
                int i;
                for (i = 0; i < allocationType.arguments.length; i++) {
                    if (TypeBinding.notEquals(allocationType.arguments[i], expected.arguments[i]))
                        break;
                }
                if (i == allocationType.arguments.length) {
                    scope.problemReporter().redundantSpecificationOfTypeArguments(this.type,
                            allocationType.arguments);
                    return;
                }
            }
        }
        TypeBinding[] inferredTypes;
        int previousBits = this.type.bits;
        try {
            // checking for redundant type parameters must fake a diamond, 
            // so we infer the same results as we would get with a diamond in source code:
            this.type.bits |= IsDiamond;
            inferredTypes = inferElidedTypes(allocationType, scope);
        } finally {
            // reset effects of inference
            this.type.bits = previousBits;
        }
        if (inferredTypes == null) {
            return;
        }
        for (int i = 0; i < inferredTypes.length; i++) {
            if (TypeBinding.notEquals(inferredTypes[i], allocationType.arguments[i]))
                return;
        }
        scope.problemReporter().redundantSpecificationOfTypeArguments(this.type, allocationType.arguments);
    }

    @Override
    public void setActualReceiverType(ReferenceBinding receiverType) {
        // ignored
    }

    @Override
    public void setDepth(int i) {
        // ignored
    }

    @Override
    public void setFieldIndex(int i) {
        // ignored
    }

    @Override
    public void traverse(ASTVisitor visitor, BlockScope scope) {
        if (visitor.visit(this, scope)) {
            if (this.typeArguments != null) {
                for (int i = 0, typeArgumentsLength = this.typeArguments.length; i < typeArgumentsLength; i++) {
                    this.typeArguments[i].traverse(visitor, scope);
                }
            }
            if (this.type != null) { // enum constant scenario
                this.type.traverse(visitor, scope);
            }
            if (this.arguments != null) {
                for (int i = 0, argumentsLength = this.arguments.length; i < argumentsLength; i++)
                    this.arguments[i].traverse(visitor, scope);
            }
        }
        visitor.endVisit(this, scope);
    }

    /**
     * @see org.eclipse.jdt.internal.compiler.ast.Expression#setExpectedType(org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
     */
    @Override
    public void setExpectedType(TypeBinding expectedType) {
        this.typeExpected = expectedType;
    }

    @Override
    public void setExpressionContext(ExpressionContext context) {
        this.expressionContext = context;
    }

    @Override
    public boolean isPolyExpression() {
        return isPolyExpression(this.binding);
    }

    @Override
    public boolean isPolyExpression(MethodBinding method) {
        return (this.expressionContext == ASSIGNMENT_CONTEXT || this.expressionContext == INVOCATION_CONTEXT)
                && this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0;
    }

    /**
     * @see org.eclipse.jdt.internal.compiler.lookup.InvocationSite#invocationTargetType()
     */
    @Override
    public TypeBinding invocationTargetType() {
        return this.typeExpected;
    }

    @Override
    public boolean statementExpression() {
        return ((this.bits & ASTNode.ParenthesizedMASK) == 0);
    }

    //-- interface Invocation: --
    @Override
    public MethodBinding binding() {
        return this.binding;
    }

    @Override
    public Expression[] arguments() {
        return this.arguments;
    }

    @Override
    public void registerInferenceContext(ParameterizedGenericMethodBinding method, InferenceContext18 infCtx18) {
        if (this.inferenceContexts == null)
            this.inferenceContexts = new SimpleLookupTable();
        this.inferenceContexts.put(method, infCtx18);
    }

    @Override
    public void registerResult(TypeBinding targetType, MethodBinding method) {
        if (method != null && method.isConstructor()) { // ignore the factory.
            if (this.solutionsPerTargetType == null)
                this.solutionsPerTargetType = new HashMap<>();
            this.solutionsPerTargetType.put(targetType, method);
        }
    }

    @Override
    public InferenceContext18 getInferenceContext(ParameterizedMethodBinding method) {
        if (this.inferenceContexts == null)
            return null;
        return (InferenceContext18) this.inferenceContexts.get(method);
    }

    @Override
    public void cleanUpInferenceContexts() {
        if (this.inferenceContexts == null)
            return;
        for (Object value : this.inferenceContexts.valueTable)
            if (value != null)
                ((InferenceContext18) value).cleanUp();
        this.inferenceContexts = null;
        this.outerInferenceContext = null;
        this.solutionsPerTargetType = null;
    }

    //-- interface InvocationSite: --
    @Override
    public ExpressionContext getExpressionContext() {
        return this.expressionContext;
    }

    @Override
    public InferenceContext18 freshInferenceContext(Scope scope) {
        return new InferenceContext18(scope, this.arguments, this, this.outerInferenceContext);
    }

    @Override
    public int nameSourceStart() {
        if (this.enumConstant != null)
            return this.enumConstant.sourceStart;
        else
            return this.type.sourceStart;
    }

    @Override
    public int nameSourceEnd() {
        if (this.enumConstant != null)
            return this.enumConstant.sourceEnd;
        else
            return this.type.sourceEnd;
    }
}