| /******************************************************************************* |
| * 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 |
| * Stephen Herrmann <stephan@cs.tu-berlin.de> - Contributions for |
| * bug 133125 - [compiler][null] need to report the null status of expressions and analyze them simultaneously |
| * bug 292478 - Report potentially null across variable assignment |
| * bug 324178 - [null] ConditionalExpression.nullStatus(..) doesn't take into account the analysis of condition itself |
| * bug 354554 - [null] conditional with redundant condition yields weak error message |
| * bug 349326 - [1.7] new warning for missing try-with-resources |
| * bug 345305 - [compiler][null] Compiler misidentifies a case of "variable can only be null" |
| * bug 383368 - [compiler][null] syntactic null analysis for field references |
| * bug 400761 - [compiler][null] null may be return as boolean without a diagnostic |
| * Bug 392099 - [1.8][compiler][null] Apply null annotation on types for null analysis |
| * Bug 415043 - [1.8][null] Follow-up re null type annotations after bug 392099 |
| * 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 426078 - [1.8] VerifyError when conditional expression passed as an argument |
| * Bug 427438 - [1.8][compiler] NPE at org.eclipse.jdt.internal.compiler.ast.ConditionalExpression.generateCode(ConditionalExpression.java:280) |
| * Bug 418537 - [1.8][null] Fix null type annotation analysis for poly conditional expressions |
| * Bug 428352 - [1.8][compiler] Resolution errors don't always surface |
| * Bug 407414 - [compiler][null] Incorrect warning on a primitive type being null |
| *******************************************************************************/ |
| package org.eclipse.jdt.internal.compiler.ast; |
| |
| import static org.eclipse.jdt.internal.compiler.ast.ExpressionContext.*; |
| |
| import org.eclipse.jdt.internal.compiler.ASTVisitor; |
| import org.eclipse.jdt.internal.compiler.impl.*; |
| 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.lookup.*; |
| |
| public class ConditionalExpression extends OperatorExpression implements IPolyExpression { |
| |
| public Expression condition, valueIfTrue, valueIfFalse; |
| public Constant optimizedBooleanConstant; |
| public Constant optimizedIfTrueConstant; |
| public Constant optimizedIfFalseConstant; |
| |
| // for local variables table attributes |
| int trueInitStateIndex = -1; |
| int falseInitStateIndex = -1; |
| int mergedInitStateIndex = -1; |
| |
| // we compute and store the null status during analyseCode (https://bugs.eclipse.org/324178): |
| private int nullStatus = FlowInfo.UNKNOWN; |
| int ifFalseNullStatus; |
| int ifTrueNullStatus; |
| private TypeBinding expectedType; |
| private ExpressionContext expressionContext = VANILLA_CONTEXT; |
| private boolean isPolyExpression = false; |
| private TypeBinding originalValueIfTrueType; |
| private TypeBinding originalValueIfFalseType; |
| private boolean use18specifics; |
| |
| public ConditionalExpression(Expression condition, Expression valueIfTrue, Expression valueIfFalse) { |
| this.condition = condition; |
| this.valueIfTrue = valueIfTrue; |
| this.valueIfFalse = valueIfFalse; |
| this.sourceStart = condition.sourceStart; |
| this.sourceEnd = valueIfFalse.sourceEnd; |
| } |
| |
| @Override |
| public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, |
| FlowInfo flowInfo) { |
| int initialComplaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED; |
| Constant cst = this.condition.optimizedBooleanConstant(); |
| boolean isConditionOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true; |
| boolean isConditionOptimizedFalse = cst != Constant.NotAConstant && cst.booleanValue() == false; |
| |
| int mode = flowInfo.reachMode(); |
| flowInfo = this.condition.analyseCode(currentScope, flowContext, flowInfo, cst == Constant.NotAConstant); |
| |
| flowContext.conditionalLevel++; |
| |
| // process the if-true part |
| FlowInfo trueFlowInfo = flowInfo.initsWhenTrue().copy(); |
| final CompilerOptions compilerOptions = currentScope.compilerOptions(); |
| if (isConditionOptimizedFalse) { |
| if ((mode & FlowInfo.UNREACHABLE) == 0) { |
| trueFlowInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD); |
| } |
| if (!isKnowDeadCodePattern(this.condition) || compilerOptions.reportDeadCodeInTrivialIfStatement) { |
| this.valueIfTrue.complainIfUnreachable(trueFlowInfo, currentScope, initialComplaintLevel, false); |
| } |
| } |
| this.trueInitStateIndex = currentScope.methodScope().recordInitializationStates(trueFlowInfo); |
| trueFlowInfo = this.valueIfTrue.analyseCode(currentScope, flowContext, trueFlowInfo); |
| this.valueIfTrue.checkNPEbyUnboxing(currentScope, flowContext, trueFlowInfo); |
| |
| // may need to fetch this null status before expireNullCheckedFieldInfo(): |
| this.ifTrueNullStatus = -1; |
| if (compilerOptions.enableSyntacticNullAnalysisForFields) { |
| this.ifTrueNullStatus = this.valueIfTrue.nullStatus(trueFlowInfo, flowContext); |
| // wipe information that was meant only for valueIfTrue: |
| flowContext.expireNullCheckedFieldInfo(); |
| } |
| |
| // process the if-false part |
| FlowInfo falseFlowInfo = flowInfo.initsWhenFalse().copy(); |
| if (isConditionOptimizedTrue) { |
| if ((mode & FlowInfo.UNREACHABLE) == 0) { |
| falseFlowInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD); |
| } |
| if (!isKnowDeadCodePattern(this.condition) || compilerOptions.reportDeadCodeInTrivialIfStatement) { |
| this.valueIfFalse.complainIfUnreachable(falseFlowInfo, currentScope, initialComplaintLevel, true); |
| } |
| } |
| this.falseInitStateIndex = currentScope.methodScope().recordInitializationStates(falseFlowInfo); |
| falseFlowInfo = this.valueIfFalse.analyseCode(currentScope, flowContext, falseFlowInfo); |
| this.valueIfFalse.checkNPEbyUnboxing(currentScope, flowContext, falseFlowInfo); |
| |
| flowContext.conditionalLevel--; |
| |
| // merge if-true & if-false initializations |
| FlowInfo mergedInfo; |
| if (isConditionOptimizedTrue){ |
| mergedInfo = trueFlowInfo.addPotentialInitializationsFrom(falseFlowInfo); |
| if (this.ifTrueNullStatus != -1) { |
| this.nullStatus = this.ifTrueNullStatus; |
| } else { |
| this.nullStatus = this.valueIfTrue.nullStatus(trueFlowInfo, flowContext); |
| } |
| } else if (isConditionOptimizedFalse) { |
| mergedInfo = falseFlowInfo.addPotentialInitializationsFrom(trueFlowInfo); |
| this.nullStatus = this.valueIfFalse.nullStatus(falseFlowInfo, flowContext); |
| } else { |
| // this block must meet two conflicting requirements (see https://bugs.eclipse.org/324178): |
| // (1) For null analysis of "Object o2 = (o1 != null) ? o1 : new Object();" we need to distinguish |
| // the paths *originating* from the evaluation of the condition to true/false respectively. |
| // This is used to determine the possible null status of the entire conditional expression. |
| // (2) For definite assignment analysis (JLS 16.1.5) of boolean conditional expressions of the form |
| // "if (c1 ? expr1 : expr2) use(v);" we need to check whether any variable v will be definitely |
| // assigned whenever the entire conditional expression evaluates to true (to reach the then branch). |
| // I.e., we need to collect flowInfo *towards* the overall outcome true/false |
| // (regardless of the evaluation of the condition). |
| |
| // to support (1) use the infos of both branches originating from the condition for computing the nullStatus: |
| computeNullStatus(trueFlowInfo, falseFlowInfo, flowContext); |
| |
| // to support (2) we split the true/false branches according to their inner structure. Consider this: |
| // if (b ? false : (true && (v = false))) return v; -- ok |
| // - expr1 ("false") has no path towards true (mark as unreachable) |
| // - expr2 ("(true && (v = false))") has a branch towards true on which v is assigned. |
| // -> merging these two branches yields: v is assigned |
| // - the paths towards false are irrelevant since the enclosing if has no else. |
| cst = this.optimizedIfTrueConstant; |
| boolean isValueIfTrueOptimizedTrue = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == true; |
| boolean isValueIfTrueOptimizedFalse = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == false; |
| |
| cst = this.optimizedIfFalseConstant; |
| boolean isValueIfFalseOptimizedTrue = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == true; |
| boolean isValueIfFalseOptimizedFalse = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == false; |
| |
| UnconditionalFlowInfo trueFlowTowardsTrue = trueFlowInfo.initsWhenTrue().unconditionalCopy(); |
| UnconditionalFlowInfo falseFlowTowardsTrue = falseFlowInfo.initsWhenTrue().unconditionalCopy(); |
| UnconditionalFlowInfo trueFlowTowardsFalse = trueFlowInfo.initsWhenFalse().unconditionalInits(); |
| UnconditionalFlowInfo falseFlowTowardsFalse = falseFlowInfo.initsWhenFalse().unconditionalInits(); |
| if (isValueIfTrueOptimizedFalse) { |
| trueFlowTowardsTrue.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD); |
| } |
| if (isValueIfFalseOptimizedFalse) { |
| falseFlowTowardsTrue.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD); |
| } |
| if (isValueIfTrueOptimizedTrue) { |
| trueFlowTowardsFalse.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD); |
| } |
| if (isValueIfFalseOptimizedTrue) { |
| falseFlowTowardsFalse.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD); |
| } |
| mergedInfo = |
| FlowInfo.conditional( |
| trueFlowTowardsTrue.mergedWith(falseFlowTowardsTrue), |
| trueFlowTowardsFalse.mergedWith(falseFlowTowardsFalse)); |
| } |
| this.mergedInitStateIndex = |
| currentScope.methodScope().recordInitializationStates(mergedInfo); |
| mergedInfo.setReachMode(mode); |
| |
| return mergedInfo; |
| } |
| |
| @Override |
| public boolean checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, int ttlForFieldCheck) { |
| if ((this.nullStatus & FlowInfo.NULL) != 0) |
| scope.problemReporter().expressionNullReference(this); |
| else if ((this.nullStatus & FlowInfo.POTENTIALLY_NULL) != 0) |
| scope.problemReporter().expressionPotentialNullReference(this); |
| return true; // all checking done |
| } |
| |
| private void computeNullStatus(FlowInfo trueBranchInfo, FlowInfo falseBranchInfo, FlowContext flowContext) { |
| // given that the condition cannot be optimized to a constant |
| // we now merge the nullStatus from both branches: |
| if (this.ifTrueNullStatus == -1) { // has this status been pre-computed? |
| this.ifTrueNullStatus = this.valueIfTrue.nullStatus(trueBranchInfo, flowContext); |
| } |
| this.ifFalseNullStatus = this.valueIfFalse.nullStatus(falseBranchInfo, flowContext); |
| |
| if (this.ifTrueNullStatus == this.ifFalseNullStatus) { |
| this.nullStatus = this.ifTrueNullStatus; |
| return; |
| } |
| if (trueBranchInfo.reachMode() != FlowInfo.REACHABLE) { |
| this.nullStatus = this.ifFalseNullStatus; |
| return; |
| } |
| if (falseBranchInfo.reachMode() != FlowInfo.REACHABLE) { |
| this.nullStatus = this.ifTrueNullStatus; |
| return; |
| } |
| |
| // is there a chance of null (or non-null)? -> potentially null etc. |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=133125 |
| int combinedStatus = this.ifTrueNullStatus|this.ifFalseNullStatus; |
| int status = Expression.computeNullStatus(0, combinedStatus); |
| if (status > 0) |
| this.nullStatus = status; |
| } |
| |
| /** |
| * Code generation for the conditional operator ?: |
| * |
| * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope |
| * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream |
| * @param valueRequired boolean |
| */ |
| @Override |
| public void generateCode( |
| BlockScope currentScope, |
| CodeStream codeStream, |
| boolean valueRequired) { |
| |
| int pc = codeStream.position; |
| BranchLabel endifLabel, falseLabel; |
| if (this.constant != Constant.NotAConstant) { |
| if (valueRequired) |
| codeStream.generateConstant(this.constant, this.implicitConversion); |
| codeStream.recordPositionsFrom(pc, this.sourceStart); |
| return; |
| } |
| Constant cst = this.condition.optimizedBooleanConstant(); |
| if (cst == Constant.NotAConstant) { |
| cst = this.condition.optimizedNullComparisonConstant(); |
| } |
| boolean needTruePart = !(cst != Constant.NotAConstant && cst.booleanValue() == false); |
| boolean needFalsePart = !(cst != Constant.NotAConstant && cst.booleanValue() == true); |
| |
| endifLabel = new BranchLabel(codeStream); |
| |
| // Generate code for the condition |
| falseLabel = new BranchLabel(codeStream); |
| falseLabel.tagBits |= BranchLabel.USED; |
| this.condition.generateOptimizedBoolean( |
| currentScope, |
| codeStream, |
| null, |
| falseLabel, |
| cst == Constant.NotAConstant); |
| |
| if (this.trueInitStateIndex != -1) { |
| codeStream.removeNotDefinitelyAssignedVariables( |
| currentScope, |
| this.trueInitStateIndex); |
| codeStream.addDefinitelyAssignedVariables(currentScope, this.trueInitStateIndex); |
| } |
| // Then code generation |
| if (needTruePart) { |
| this.valueIfTrue.generateCode(currentScope, codeStream, valueRequired); |
| if (needFalsePart) { |
| // Jump over the else part |
| int position = codeStream.position; |
| codeStream.goto_(endifLabel); |
| codeStream.recordPositionsFrom(position, this.valueIfTrue.sourceEnd); |
| // Tune codestream stack size |
| if (valueRequired) { |
| switch(this.resolvedType.id) { |
| case TypeIds.T_long : |
| case TypeIds.T_double : |
| codeStream.decrStackSize(2); |
| break; |
| default : |
| codeStream.decrStackSize(1); |
| break; |
| } |
| } |
| } |
| } |
| if (needFalsePart) { |
| if (this.falseInitStateIndex != -1) { |
| codeStream.removeNotDefinitelyAssignedVariables( |
| currentScope, |
| this.falseInitStateIndex); |
| codeStream.addDefinitelyAssignedVariables(currentScope, this.falseInitStateIndex); |
| } |
| if (falseLabel.forwardReferenceCount() > 0) { |
| falseLabel.place(); |
| } |
| this.valueIfFalse.generateCode(currentScope, codeStream, valueRequired); |
| if (valueRequired) { |
| codeStream.recordExpressionType(this.resolvedType); |
| } |
| if (needTruePart) { |
| // End of if statement |
| endifLabel.place(); |
| } |
| } |
| // May loose some local variable initializations : affecting the local variable attributes |
| if (this.mergedInitStateIndex != -1) { |
| codeStream.removeNotDefinitelyAssignedVariables( |
| currentScope, |
| this.mergedInitStateIndex); |
| } |
| // implicit conversion |
| if (valueRequired) |
| codeStream.generateImplicitConversion(this.implicitConversion); |
| codeStream.recordPositionsFrom(pc, this.sourceStart); |
| } |
| |
| /** |
| * Optimized boolean code generation for the conditional operator ?: |
| */ |
| @Override |
| public void generateOptimizedBoolean( |
| BlockScope currentScope, |
| CodeStream codeStream, |
| BranchLabel trueLabel, |
| BranchLabel falseLabel, |
| boolean valueRequired) { |
| |
| int pc = codeStream.position; |
| |
| if ((this.constant != Constant.NotAConstant) && (this.constant.typeID() == T_boolean) // constant |
| || ((this.valueIfTrue.implicitConversion & IMPLICIT_CONVERSION_MASK) >> 4) != T_boolean |
| || ((this.valueIfFalse.implicitConversion & IMPLICIT_CONVERSION_MASK) >> 4) != T_boolean) { // non boolean values |
| super.generateOptimizedBoolean(currentScope, codeStream, trueLabel, falseLabel, valueRequired); |
| return; |
| } |
| Constant cst = this.condition.constant; |
| Constant condCst = this.condition.optimizedBooleanConstant(); |
| boolean needTruePart = |
| !(((cst != Constant.NotAConstant) && (cst.booleanValue() == false)) |
| || ((condCst != Constant.NotAConstant) && (condCst.booleanValue() == false))); |
| boolean needFalsePart = |
| !(((cst != Constant.NotAConstant) && (cst.booleanValue() == true)) |
| || ((condCst != Constant.NotAConstant) && (condCst.booleanValue() == true))); |
| |
| BranchLabel internalFalseLabel, endifLabel = new BranchLabel(codeStream); |
| |
| // Generate code for the condition |
| boolean needConditionValue = (cst == Constant.NotAConstant) && (condCst == Constant.NotAConstant); |
| this.condition.generateOptimizedBoolean( |
| currentScope, |
| codeStream, |
| null, |
| internalFalseLabel = new BranchLabel(codeStream), |
| needConditionValue); |
| |
| if (this.trueInitStateIndex != -1) { |
| codeStream.removeNotDefinitelyAssignedVariables( |
| currentScope, |
| this.trueInitStateIndex); |
| codeStream.addDefinitelyAssignedVariables(currentScope, this.trueInitStateIndex); |
| } |
| // Then code generation |
| if (needTruePart) { |
| this.valueIfTrue.generateOptimizedBoolean(currentScope, codeStream, trueLabel, falseLabel, valueRequired); |
| |
| if (needFalsePart) { |
| // Jump over the else part |
| JumpEndif: { |
| if (falseLabel == null) { |
| if (trueLabel != null) { |
| // implicit falling through the FALSE case |
| cst = this.optimizedIfTrueConstant; |
| boolean isValueIfTrueOptimizedTrue = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == true; |
| if (isValueIfTrueOptimizedTrue) break JumpEndif; // no need to jump over, since branched to true already |
| } |
| } else { |
| // implicit falling through the TRUE case |
| if (trueLabel == null) { |
| cst = this.optimizedIfTrueConstant; |
| boolean isValueIfTrueOptimizedFalse = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == false; |
| if (isValueIfTrueOptimizedFalse) break JumpEndif; // no need to jump over, since branched to false already |
| } else { |
| // no implicit fall through TRUE/FALSE --> should never occur |
| } |
| } |
| int position = codeStream.position; |
| codeStream.goto_(endifLabel); |
| codeStream.recordPositionsFrom(position, this.valueIfTrue.sourceEnd); |
| } |
| // No need to decrement codestream stack size |
| // since valueIfTrue was already consumed by branch bytecode |
| } |
| } |
| if (needFalsePart) { |
| internalFalseLabel.place(); |
| if (this.falseInitStateIndex != -1) { |
| codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.falseInitStateIndex); |
| codeStream.addDefinitelyAssignedVariables(currentScope, this.falseInitStateIndex); |
| } |
| this.valueIfFalse.generateOptimizedBoolean(currentScope, codeStream, trueLabel, falseLabel, valueRequired); |
| |
| // End of if statement |
| endifLabel.place(); |
| } |
| // May loose some local variable initializations : affecting the local variable attributes |
| if (this.mergedInitStateIndex != -1) { |
| codeStream.removeNotDefinitelyAssignedVariables(currentScope, this.mergedInitStateIndex); |
| } |
| // no implicit conversion for boolean values |
| codeStream.recordPositionsFrom(pc, this.sourceEnd); |
| } |
| |
| @Override |
| public int nullStatus(FlowInfo flowInfo, FlowContext flowContext) { |
| if ((this.implicitConversion & TypeIds.BOXING) != 0) |
| return FlowInfo.NON_NULL; |
| return this.nullStatus; |
| } |
| |
| @Override |
| public Constant optimizedBooleanConstant() { |
| |
| return this.optimizedBooleanConstant == null ? this.constant : this.optimizedBooleanConstant; |
| } |
| |
| @Override |
| public StringBuffer printExpressionNoParenthesis(int indent, StringBuffer output) { |
| |
| this.condition.printExpression(indent, output).append(" ? "); //$NON-NLS-1$ |
| this.valueIfTrue.printExpression(0, output).append(" : "); //$NON-NLS-1$ |
| return this.valueIfFalse.printExpression(0, output); |
| } |
| |
| @Override |
| public TypeBinding resolveType(BlockScope scope) { |
| // JLS3 15.25 |
| LookupEnvironment env = scope.environment(); |
| final long sourceLevel = scope.compilerOptions().sourceLevel; |
| boolean use15specifics = sourceLevel >= ClassFileConstants.JDK1_5; |
| this.use18specifics = sourceLevel >= ClassFileConstants.JDK1_8; |
| |
| if (this.use18specifics) { |
| if (this.expressionContext == ASSIGNMENT_CONTEXT || this.expressionContext == INVOCATION_CONTEXT) { |
| this.valueIfTrue.setExpressionContext(this.expressionContext); |
| this.valueIfTrue.setExpectedType(this.expectedType); |
| this.valueIfFalse.setExpressionContext(this.expressionContext); |
| this.valueIfFalse.setExpectedType(this.expectedType); |
| } |
| } |
| |
| if (this.constant != Constant.NotAConstant) { |
| this.constant = Constant.NotAConstant; |
| |
| TypeBinding conditionType = this.condition.resolveTypeExpecting(scope, TypeBinding.BOOLEAN); |
| this.condition.computeConversion(scope, TypeBinding.BOOLEAN, conditionType); |
| |
| if (this.valueIfTrue instanceof CastExpression) this.valueIfTrue.bits |= DisableUnnecessaryCastCheck; // will check later on |
| this.originalValueIfTrueType = this.valueIfTrue.resolveType(scope); |
| |
| if (this.valueIfFalse instanceof CastExpression) this.valueIfFalse.bits |= DisableUnnecessaryCastCheck; // will check later on |
| this.originalValueIfFalseType = this.valueIfFalse.resolveType(scope); |
| |
| if (conditionType == null || this.originalValueIfTrueType == null || this.originalValueIfFalseType == null) |
| return null; |
| } else { |
| if (this.originalValueIfTrueType.kind() == Binding.POLY_TYPE) |
| this.originalValueIfTrueType = this.valueIfTrue.resolveType(scope); |
| if (this.originalValueIfFalseType.kind() == Binding.POLY_TYPE) |
| this.originalValueIfFalseType = this.valueIfFalse.resolveType(scope); |
| |
| if (this.originalValueIfTrueType == null || !this.originalValueIfTrueType.isValidBinding()) |
| return this.resolvedType = null; |
| if (this.originalValueIfFalseType == null || !this.originalValueIfFalseType.isValidBinding()) |
| return this.resolvedType = null; |
| } |
| if (isPolyExpression()) { |
| if (this.expectedType == null || !this.expectedType.isProperType(true)) { |
| return new PolyTypeBinding(this); |
| } |
| return this.resolvedType = computeConversions(scope, this.expectedType) ? this.expectedType : null; |
| } |
| |
| TypeBinding valueIfTrueType = this.originalValueIfTrueType; |
| TypeBinding valueIfFalseType = this.originalValueIfFalseType; |
| if (use15specifics && TypeBinding.notEquals(valueIfTrueType, valueIfFalseType)) { |
| if (valueIfTrueType.isBaseType()) { |
| if (valueIfFalseType.isBaseType()) { |
| // bool ? baseType : baseType |
| if (valueIfTrueType == TypeBinding.NULL) { // bool ? null : 12 --> Integer |
| valueIfFalseType = env.computeBoxingType(valueIfFalseType); // boxing |
| } else if (valueIfFalseType == TypeBinding.NULL) { // bool ? 12 : null --> Integer |
| valueIfTrueType = env.computeBoxingType(valueIfTrueType); // boxing |
| } |
| } else { |
| // bool ? baseType : nonBaseType |
| TypeBinding unboxedIfFalseType = valueIfFalseType.isBaseType() ? valueIfFalseType : env.computeBoxingType(valueIfFalseType); |
| if (valueIfTrueType.isNumericType() && unboxedIfFalseType.isNumericType()) { |
| valueIfFalseType = unboxedIfFalseType; // unboxing |
| } else if (valueIfTrueType != TypeBinding.NULL) { // bool ? 12 : new Integer(12) --> int |
| valueIfFalseType = env.computeBoxingType(valueIfFalseType); // unboxing |
| } |
| } |
| } else if (valueIfFalseType.isBaseType()) { |
| // bool ? nonBaseType : baseType |
| TypeBinding unboxedIfTrueType = valueIfTrueType.isBaseType() ? valueIfTrueType : env.computeBoxingType(valueIfTrueType); |
| if (unboxedIfTrueType.isNumericType() && valueIfFalseType.isNumericType()) { |
| valueIfTrueType = unboxedIfTrueType; // unboxing |
| } else if (valueIfFalseType != TypeBinding.NULL) { // bool ? new Integer(12) : 12 --> int |
| valueIfTrueType = env.computeBoxingType(valueIfTrueType); // unboxing |
| } |
| } else { |
| // bool ? nonBaseType : nonBaseType |
| TypeBinding unboxedIfTrueType = env.computeBoxingType(valueIfTrueType); |
| TypeBinding unboxedIfFalseType = env.computeBoxingType(valueIfFalseType); |
| if (unboxedIfTrueType.isNumericType() && unboxedIfFalseType.isNumericType()) { |
| valueIfTrueType = unboxedIfTrueType; |
| valueIfFalseType = unboxedIfFalseType; |
| } |
| } |
| } |
| // Propagate the constant value from the valueIfTrue and valueIFFalse expression if it is possible |
| Constant condConstant, trueConstant, falseConstant; |
| if ((condConstant = this.condition.constant) != Constant.NotAConstant |
| && (trueConstant = this.valueIfTrue.constant) != Constant.NotAConstant |
| && (falseConstant = this.valueIfFalse.constant) != Constant.NotAConstant) { |
| // all terms are constant expression so we can propagate the constant |
| // from valueIFTrue or valueIfFalse to the receiver constant |
| this.constant = condConstant.booleanValue() ? trueConstant : falseConstant; |
| } |
| if (TypeBinding.equalsEquals(valueIfTrueType, valueIfFalseType)) { // harmed the implicit conversion |
| this.valueIfTrue.computeConversion(scope, valueIfTrueType, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, valueIfFalseType, this.originalValueIfFalseType); |
| if (TypeBinding.equalsEquals(valueIfTrueType, TypeBinding.BOOLEAN)) { |
| this.optimizedIfTrueConstant = this.valueIfTrue.optimizedBooleanConstant(); |
| this.optimizedIfFalseConstant = this.valueIfFalse.optimizedBooleanConstant(); |
| if (this.optimizedIfTrueConstant != Constant.NotAConstant |
| && this.optimizedIfFalseConstant != Constant.NotAConstant |
| && this.optimizedIfTrueConstant.booleanValue() == this.optimizedIfFalseConstant.booleanValue()) { |
| // a ? true : true / a ? false : false |
| this.optimizedBooleanConstant = this.optimizedIfTrueConstant; |
| } else if ((condConstant = this.condition.optimizedBooleanConstant()) != Constant.NotAConstant) { // Propagate the optimized boolean constant if possible |
| this.optimizedBooleanConstant = condConstant.booleanValue() |
| ? this.optimizedIfTrueConstant |
| : this.optimizedIfFalseConstant; |
| } |
| } |
| return this.resolvedType = NullAnnotationMatching.moreDangerousType(valueIfTrueType, valueIfFalseType); |
| } |
| // Determine the return type depending on argument types |
| // Numeric types |
| if (valueIfTrueType.isNumericType() && valueIfFalseType.isNumericType()) { |
| // (Short x Byte) or (Byte x Short)" |
| if ((TypeBinding.equalsEquals(valueIfTrueType, TypeBinding.BYTE) && TypeBinding.equalsEquals(valueIfFalseType, TypeBinding.SHORT)) |
| || (TypeBinding.equalsEquals(valueIfTrueType, TypeBinding.SHORT) && TypeBinding.equalsEquals(valueIfFalseType, TypeBinding.BYTE))) { |
| this.valueIfTrue.computeConversion(scope, TypeBinding.SHORT, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, TypeBinding.SHORT, this.originalValueIfFalseType); |
| return this.resolvedType = TypeBinding.SHORT; |
| } |
| // <Byte|Short|Char> x constant(Int) ---> <Byte|Short|Char> and reciprocally |
| if ((TypeBinding.equalsEquals(valueIfTrueType, TypeBinding.BYTE) || TypeBinding.equalsEquals(valueIfTrueType, TypeBinding.SHORT) || TypeBinding.equalsEquals(valueIfTrueType, TypeBinding.CHAR)) |
| && (TypeBinding.equalsEquals(valueIfFalseType, TypeBinding.INT) |
| && this.valueIfFalse.isConstantValueOfTypeAssignableToType(valueIfFalseType, valueIfTrueType))) { |
| this.valueIfTrue.computeConversion(scope, valueIfTrueType, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, valueIfTrueType, this.originalValueIfFalseType); |
| return this.resolvedType = valueIfTrueType; |
| } |
| if ((TypeBinding.equalsEquals(valueIfFalseType, TypeBinding.BYTE) |
| || TypeBinding.equalsEquals(valueIfFalseType, TypeBinding.SHORT) |
| || TypeBinding.equalsEquals(valueIfFalseType, TypeBinding.CHAR)) |
| && (TypeBinding.equalsEquals(valueIfTrueType, TypeBinding.INT) |
| && this.valueIfTrue.isConstantValueOfTypeAssignableToType(valueIfTrueType, valueIfFalseType))) { |
| this.valueIfTrue.computeConversion(scope, valueIfFalseType, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, valueIfFalseType, this.originalValueIfFalseType); |
| return this.resolvedType = valueIfFalseType; |
| } |
| // Manual binary numeric promotion |
| // int |
| if (BaseTypeBinding.isNarrowing(valueIfTrueType.id, T_int) |
| && BaseTypeBinding.isNarrowing(valueIfFalseType.id, T_int)) { |
| this.valueIfTrue.computeConversion(scope, TypeBinding.INT, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, TypeBinding.INT, this.originalValueIfFalseType); |
| return this.resolvedType = TypeBinding.INT; |
| } |
| // long |
| if (BaseTypeBinding.isNarrowing(valueIfTrueType.id, T_long) |
| && BaseTypeBinding.isNarrowing(valueIfFalseType.id, T_long)) { |
| this.valueIfTrue.computeConversion(scope, TypeBinding.LONG, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, TypeBinding.LONG, this.originalValueIfFalseType); |
| return this.resolvedType = TypeBinding.LONG; |
| } |
| // float |
| if (BaseTypeBinding.isNarrowing(valueIfTrueType.id, T_float) |
| && BaseTypeBinding.isNarrowing(valueIfFalseType.id, T_float)) { |
| this.valueIfTrue.computeConversion(scope, TypeBinding.FLOAT, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, TypeBinding.FLOAT, this.originalValueIfFalseType); |
| return this.resolvedType = TypeBinding.FLOAT; |
| } |
| // double |
| this.valueIfTrue.computeConversion(scope, TypeBinding.DOUBLE, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, TypeBinding.DOUBLE, this.originalValueIfFalseType); |
| return this.resolvedType = TypeBinding.DOUBLE; |
| } |
| // Type references (null null is already tested) |
| if (valueIfTrueType.isBaseType() && valueIfTrueType != TypeBinding.NULL) { |
| if (use15specifics) { |
| valueIfTrueType = env.computeBoxingType(valueIfTrueType); |
| } else { |
| scope.problemReporter().conditionalArgumentsIncompatibleTypes(this, valueIfTrueType, valueIfFalseType); |
| return null; |
| } |
| } |
| if (valueIfFalseType.isBaseType() && valueIfFalseType != TypeBinding.NULL) { |
| if (use15specifics) { |
| valueIfFalseType = env.computeBoxingType(valueIfFalseType); |
| } else { |
| scope.problemReporter().conditionalArgumentsIncompatibleTypes(this, valueIfTrueType, valueIfFalseType); |
| return null; |
| } |
| } |
| if (use15specifics) { |
| // >= 1.5 : LUB(operand types) must exist |
| TypeBinding commonType = null; |
| if (valueIfTrueType == TypeBinding.NULL) { |
| commonType = valueIfFalseType; |
| } else if (valueIfFalseType == TypeBinding.NULL) { |
| commonType = valueIfTrueType; |
| } else { |
| commonType = scope.lowerUpperBound(new TypeBinding[] { valueIfTrueType, valueIfFalseType }); |
| } |
| if (commonType != null) { |
| this.valueIfTrue.computeConversion(scope, commonType, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, commonType, this.originalValueIfFalseType); |
| return this.resolvedType = commonType.capture(scope, this.sourceStart, this.sourceEnd); |
| } |
| } else { |
| // < 1.5 : one operand must be convertible to the other |
| if (valueIfFalseType.isCompatibleWith(valueIfTrueType)) { |
| this.valueIfTrue.computeConversion(scope, valueIfTrueType, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, valueIfTrueType, this.originalValueIfFalseType); |
| return this.resolvedType = valueIfTrueType; |
| } else if (valueIfTrueType.isCompatibleWith(valueIfFalseType)) { |
| this.valueIfTrue.computeConversion(scope, valueIfFalseType, this.originalValueIfTrueType); |
| this.valueIfFalse.computeConversion(scope, valueIfFalseType, this.originalValueIfFalseType); |
| return this.resolvedType = valueIfFalseType; |
| } |
| } |
| scope.problemReporter().conditionalArgumentsIncompatibleTypes( |
| this, |
| valueIfTrueType, |
| valueIfFalseType); |
| return null; |
| } |
| |
| protected boolean computeConversions(BlockScope scope, TypeBinding targetType) { |
| boolean ok = true; |
| if (this.originalValueIfTrueType != null && this.originalValueIfTrueType.isValidBinding()) { |
| if (this.valueIfTrue.isConstantValueOfTypeAssignableToType(this.originalValueIfTrueType, targetType) |
| || this.originalValueIfTrueType.isCompatibleWith(targetType)) { |
| |
| this.valueIfTrue.computeConversion(scope, targetType, this.originalValueIfTrueType); |
| if (this.originalValueIfTrueType.needsUncheckedConversion(targetType)) { |
| scope.problemReporter().unsafeTypeConversion(this.valueIfTrue, this.originalValueIfTrueType, targetType); |
| } |
| if (this.valueIfTrue instanceof CastExpression |
| && (this.valueIfTrue.bits & (ASTNode.UnnecessaryCast|ASTNode.DisableUnnecessaryCastCheck)) == 0) { |
| CastExpression.checkNeedForAssignedCast(scope, targetType, (CastExpression) this.valueIfTrue); |
| } |
| } else if (isBoxingCompatible(this.originalValueIfTrueType, targetType, this.valueIfTrue, scope)) { |
| this.valueIfTrue.computeConversion(scope, targetType, this.originalValueIfTrueType); |
| if (this.valueIfTrue instanceof CastExpression |
| && (this.valueIfTrue.bits & (ASTNode.UnnecessaryCast|ASTNode.DisableUnnecessaryCastCheck)) == 0) { |
| CastExpression.checkNeedForAssignedCast(scope, targetType, (CastExpression) this.valueIfTrue); |
| } |
| } else { |
| scope.problemReporter().typeMismatchError(this.originalValueIfTrueType, targetType, this.valueIfTrue, null); |
| ok = false; |
| } |
| } |
| if (this.originalValueIfFalseType != null && this.originalValueIfFalseType.isValidBinding()) { |
| if (this.valueIfFalse.isConstantValueOfTypeAssignableToType(this.originalValueIfFalseType, targetType) |
| || this.originalValueIfFalseType.isCompatibleWith(targetType)) { |
| |
| this.valueIfFalse.computeConversion(scope, targetType, this.originalValueIfFalseType); |
| if (this.originalValueIfFalseType.needsUncheckedConversion(targetType)) { |
| scope.problemReporter().unsafeTypeConversion(this.valueIfFalse, this.originalValueIfFalseType, targetType); |
| } |
| if (this.valueIfFalse instanceof CastExpression |
| && (this.valueIfFalse.bits & (ASTNode.UnnecessaryCast|ASTNode.DisableUnnecessaryCastCheck)) == 0) { |
| CastExpression.checkNeedForAssignedCast(scope, targetType, (CastExpression) this.valueIfFalse); |
| } |
| } else if (isBoxingCompatible(this.originalValueIfFalseType, targetType, this.valueIfFalse, scope)) { |
| this.valueIfFalse.computeConversion(scope, targetType, this.originalValueIfFalseType); |
| if (this.valueIfFalse instanceof CastExpression |
| && (this.valueIfFalse.bits & (ASTNode.UnnecessaryCast|ASTNode.DisableUnnecessaryCastCheck)) == 0) { |
| CastExpression.checkNeedForAssignedCast(scope, targetType, (CastExpression) this.valueIfFalse); |
| } |
| } else { |
| scope.problemReporter().typeMismatchError(this.originalValueIfFalseType, targetType, this.valueIfFalse, null); |
| ok = false; |
| } |
| } |
| return ok; |
| } |
| |
| @Override |
| public void setExpectedType(TypeBinding expectedType) { |
| this.expectedType = expectedType; |
| } |
| |
| @Override |
| public void setExpressionContext(ExpressionContext context) { |
| this.expressionContext = context; |
| } |
| |
| @Override |
| public ExpressionContext getExpressionContext() { |
| return this.expressionContext; |
| } |
| |
| @Override |
| public Expression[] getPolyExpressions() { |
| Expression [] truePolys = this.valueIfTrue.getPolyExpressions(); |
| Expression [] falsePolys = this.valueIfFalse.getPolyExpressions(); |
| if (truePolys.length == 0) |
| return falsePolys; |
| if (falsePolys.length == 0) |
| return truePolys; |
| Expression [] allPolys = new Expression [truePolys.length + falsePolys.length]; |
| System.arraycopy(truePolys, 0, allPolys, 0, truePolys.length); |
| System.arraycopy(falsePolys, 0, allPolys, truePolys.length, falsePolys.length); |
| return allPolys; |
| } |
| |
| @Override |
| public boolean isPertinentToApplicability(TypeBinding targetType, MethodBinding method) { |
| return this.valueIfTrue.isPertinentToApplicability(targetType, method) |
| && this.valueIfFalse.isPertinentToApplicability(targetType, method); |
| } |
| |
| @Override |
| public boolean isPotentiallyCompatibleWith(TypeBinding targetType, Scope scope) { |
| return this.valueIfTrue.isPotentiallyCompatibleWith(targetType, scope) |
| && this.valueIfFalse.isPotentiallyCompatibleWith(targetType, scope); |
| } |
| |
| @Override |
| public boolean isFunctionalType() { |
| return this.valueIfTrue.isFunctionalType() || this.valueIfFalse.isFunctionalType(); // Even if only one arm is functional type, this will require a functional interface target |
| } |
| |
| @Override |
| public boolean isPolyExpression() throws UnsupportedOperationException { |
| |
| if (!this.use18specifics) |
| return false; |
| |
| if (this.isPolyExpression) |
| return true; |
| |
| if (this.expressionContext != ASSIGNMENT_CONTEXT && this.expressionContext != INVOCATION_CONTEXT) |
| return false; |
| |
| if (this.originalValueIfTrueType == null || this.originalValueIfFalseType == null) // resolution error. |
| return false; |
| |
| if (this.valueIfTrue.isPolyExpression() || this.valueIfFalse.isPolyExpression()) |
| return true; |
| |
| // "... unless both operands produce primitives (or boxed primitives)": |
| if (this.originalValueIfTrueType.isBaseType() || (this.originalValueIfTrueType.id >= TypeIds.T_JavaLangByte && this.originalValueIfTrueType.id <= TypeIds.T_JavaLangBoolean)) { |
| if (this.originalValueIfFalseType.isBaseType() || (this.originalValueIfFalseType.id >= TypeIds.T_JavaLangByte && this.originalValueIfFalseType.id <= TypeIds.T_JavaLangBoolean)) |
| return false; |
| } |
| |
| // clause around generic method's return type prior to instantiation needs double check. |
| return this.isPolyExpression = true; |
| } |
| |
| @Override |
| public boolean isCompatibleWith(TypeBinding left, Scope scope) { |
| return isPolyExpression() ? this.valueIfTrue.isCompatibleWith(left, scope) && this.valueIfFalse.isCompatibleWith(left, scope) : |
| super.isCompatibleWith(left, scope); |
| } |
| |
| @Override |
| public boolean isBoxingCompatibleWith(TypeBinding targetType, Scope scope) { |
| // Note: compatibility check may have failed in just one arm and we may have reached here. |
| return isPolyExpression() ? (this.valueIfTrue.isCompatibleWith(targetType, scope) || |
| this.valueIfTrue.isBoxingCompatibleWith(targetType, scope)) && |
| (this.valueIfFalse.isCompatibleWith(targetType, scope) || |
| this.valueIfFalse.isBoxingCompatibleWith(targetType, scope)) : |
| super.isBoxingCompatibleWith(targetType, scope); |
| } |
| |
| @Override |
| public boolean sIsMoreSpecific(TypeBinding s, TypeBinding t, Scope scope) { |
| if (super.sIsMoreSpecific(s, t, scope)) |
| return true; |
| return isPolyExpression() ? |
| this.valueIfTrue.sIsMoreSpecific(s, t, scope) && this.valueIfFalse.sIsMoreSpecific(s, t, scope): |
| false; |
| } |
| |
| @Override |
| public void traverse(ASTVisitor visitor, BlockScope scope) { |
| if (visitor.visit(this, scope)) { |
| this.condition.traverse(visitor, scope); |
| this.valueIfTrue.traverse(visitor, scope); |
| this.valueIfFalse.traverse(visitor, scope); |
| } |
| visitor.endVisit(this, scope); |
| } |
| } |
| |