public void generatePostIncrement( BlockScope currentScope, CompoundAssignment postIncrement, boolean valueRequired) { switch (this.bits & ASTNode.RestrictiveFlagMASK) { case Binding.FIELD: // assigning to a field FieldBinding fieldBinding = (FieldBinding) this.binding; // https://bugs.eclipse.org/bugs/show_bug.cgi?id=185682 // check if postIncrement is the only usage of a private field reportOnlyUselesslyReadPrivateField(currentScope, fieldBinding, valueRequired); FieldBinding codegenField = fieldBinding.original(); fieldStore( currentScope, codegenField, this.syntheticAccessors == null ? null : this.syntheticAccessors[SingleNameReference.WRITE], this.actualReceiverType, true /*implicit this*/, false); // no need for generic cast return; case Binding.LOCAL: // assigning to a local variable LocalVariableBinding localBinding = (LocalVariableBinding) this.binding; // https://bugs.eclipse.org/bugs/show_bug.cgi?id=185682 // check if postIncrement is the only usage of this local Reference.reportOnlyUselesslyReadLocal(currentScope, localBinding, valueRequired); if (localBinding.resolvedPosition == -1) { if (valueRequired) { // restart code gen localBinding.useFlag = LocalVariableBinding.USED; throw new AbortMethod(null, null); } } } }
public void manageSyntheticAccessIfNecessary( BlockScope currentScope, FlowInfo flowInfo, boolean isReadAccess) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) != 0) return; // If inlinable field, forget the access emulation, the code gen will directly target it if (this.constant != Constant.NotAConstant) return; if ((this.bits & Binding.FIELD) != 0) { FieldBinding fieldBinding = (FieldBinding) this.binding; FieldBinding codegenField = fieldBinding.original(); if (((this.bits & ASTNode.DepthMASK) != 0) && (codegenField.isPrivate() // private access || (codegenField.isProtected() // implicit protected access && codegenField.declaringClass.getPackage() != currentScope.enclosingSourceType().getPackage()))) { if (this.syntheticAccessors == null) this.syntheticAccessors = new MethodBinding[2]; this.syntheticAccessors[ isReadAccess ? SingleNameReference.READ : SingleNameReference.WRITE] = ((SourceTypeBinding) currentScope .enclosingSourceType() .enclosingTypeAt((this.bits & ASTNode.DepthMASK) >> ASTNode.DepthSHIFT)) .addSyntheticMethod(codegenField, isReadAccess, false /*not super access*/); currentScope.problemReporter().needToEmulateFieldAccess(codegenField, this, isReadAccess); return; } } }
/** * @see * org.eclipse.che.ide.ext.java.jdt.internal.compiler.ast.Expression#computeConversion(org.eclipse.che.ide.ext.java.jdt.internal.compiler.lookup.Scope, * org.eclipse.che.ide.ext.java.jdt.internal.compiler.lookup.TypeBinding, * org.eclipse.che.ide.ext.java.jdt.internal.compiler.lookup .TypeBinding) */ public void computeConversion( Scope scope, TypeBinding runtimeTimeType, TypeBinding compileTimeType) { if (runtimeTimeType == null || compileTimeType == null) return; if ((this.bits & Binding.FIELD) != 0 && this.binding != null && this.binding.isValidBinding()) { // set the generic cast after the fact, once the type expectation is fully known (no need for // strict cast) FieldBinding field = (FieldBinding) this.binding; FieldBinding originalBinding = field.original(); TypeBinding originalType = originalBinding.type; // extra cast needed if field type is type variable if (originalType.leafComponentType().isTypeVariable()) { TypeBinding targetType = (!compileTimeType.isBaseType() && runtimeTimeType.isBaseType()) ? compileTimeType // unboxing: checkcast before conversion : runtimeTimeType; this.genericCast = originalType.genericCast(scope.boxing(targetType)); if (this.genericCast instanceof ReferenceBinding) { ReferenceBinding referenceCast = (ReferenceBinding) this.genericCast; if (!referenceCast.canBeSeenBy(scope)) { scope .problemReporter() .invalidType( this, new ProblemReferenceBinding( CharOperation.splitOn('.', referenceCast.shortReadableName()), referenceCast, ProblemReasons.NotVisible)); } } } } super.computeConversion(scope, runtimeTimeType, compileTimeType); }
public void generateCode(BlockScope currentScope, boolean valueRequired) { if (this.constant != Constant.NotAConstant) { return; } else { switch (this.bits & ASTNode.RestrictiveFlagMASK) { case Binding.FIELD: // reading a field FieldBinding codegenField = ((FieldBinding) this.binding).original(); Constant fieldConstant = codegenField.constant(); if (fieldConstant != Constant.NotAConstant) { return; } if (codegenField.isStatic()) { if (!valueRequired // if no valueRequired, still need possible side-effects of <clinit> invocation, // if field belongs to different class && ((FieldBinding) this.binding).original().declaringClass == this.actualReceiverType.erasure() && ((this.implicitConversion & TypeIds.UNBOXING) == 0) && this.genericCast == null) { // if no valueRequired, optimize out entire gen return; } } else { if (!valueRequired && (this.implicitConversion & TypeIds.UNBOXING) == 0 && this.genericCast == null) { // if no valueRequired, optimize out entire gen return; } } break; case Binding.LOCAL: // reading a local LocalVariableBinding localBinding = (LocalVariableBinding) this.binding; if (localBinding.resolvedPosition == -1) { if (valueRequired) { // restart code gen localBinding.useFlag = LocalVariableBinding.USED; throw new AbortMethod(null, null); } return; } if (!valueRequired && (this.implicitConversion & TypeIds.UNBOXING) == 0) { // if no valueRequired, optimize out entire gen return; } break; default: // type return; } } }
public TypeBinding checkFieldAccess(BlockScope scope) { FieldBinding fieldBinding = (FieldBinding) this.binding; this.constant = fieldBinding.constant(); this.bits &= ~ASTNode.RestrictiveFlagMASK; // clear bits this.bits |= Binding.FIELD; MethodScope methodScope = scope.methodScope(); if (fieldBinding.isStatic()) { // check if accessing enum static field in initializer ReferenceBinding declaringClass = fieldBinding.declaringClass; if (declaringClass.isEnum()) { SourceTypeBinding sourceType = scope.enclosingSourceType(); if (this.constant == Constant.NotAConstant && !methodScope.isStatic && (sourceType == declaringClass || sourceType.superclass == declaringClass) // enum constant body && methodScope.isInsideInitializerOrConstructor()) { scope.problemReporter().enumStaticFieldUsedDuringInitialization(fieldBinding, this); } } } else { if (scope.compilerOptions().getSeverity(CompilerOptions.UnqualifiedFieldAccess) != ProblemSeverities.Ignore) { scope.problemReporter().unqualifiedFieldAccess(this, fieldBinding); } // must check for the static status.... if (methodScope.isStatic) { scope.problemReporter().staticFieldAccessToNonStaticVariable(this, fieldBinding); return fieldBinding.type; } } if (isFieldUseDeprecated(fieldBinding, scope, this.bits)) scope.problemReporter().deprecatedField(fieldBinding, this); if ((this.bits & ASTNode.IsStrictlyAssigned) == 0 && methodScope.enclosingSourceType() == fieldBinding.original().declaringClass && methodScope.lastVisibleFieldID >= 0 && fieldBinding.id >= methodScope.lastVisibleFieldID && (!fieldBinding.isStatic() || methodScope.isStatic)) { scope.problemReporter().forwardReference(this, 0, fieldBinding); this.bits |= ASTNode.IgnoreNoEffectAssignCheck; } return fieldBinding.type; }
public FlowInfo analyseCode( BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) { switch (this.bits & ASTNode.RestrictiveFlagMASK) { case Binding.FIELD: // reading a field if (valueRequired || currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4) { manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /*read-access*/); } // check if reading a final blank field FieldBinding fieldBinding = (FieldBinding) this.binding; if (fieldBinding.isBlankFinal() && currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)) { FlowInfo fieldInits = flowContext.getInitsForFinalBlankInitializationCheck( fieldBinding.declaringClass.original(), flowInfo); if (!fieldInits.isDefinitelyAssigned(fieldBinding)) { currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this); } } if (!fieldBinding.isStatic()) { // https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682 currentScope.resetEnclosingMethodStaticFlag(); } break; case Binding.LOCAL: // reading a local variable LocalVariableBinding localBinding; if (!flowInfo.isDefinitelyAssigned(localBinding = (LocalVariableBinding) this.binding)) { currentScope.problemReporter().uninitializedLocalVariable(localBinding, this); } if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) { localBinding.useFlag = LocalVariableBinding.USED; } else if (localBinding.useFlag == LocalVariableBinding.UNUSED) { localBinding.useFlag = LocalVariableBinding.FAKE_USED; } } if (valueRequired) { manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo); } return flowInfo; }
public FlowInfo analyseAssignment( BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound) { boolean isReachable = (flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0; // compound assignment extra work if (isCompound) { // check the variable part is initialized if blank final switch (this.bits & ASTNode.RestrictiveFlagMASK) { case Binding.FIELD: // reading a field FieldBinding fieldBinding = (FieldBinding) this.binding; if (fieldBinding.isBlankFinal() && currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)) { FlowInfo fieldInits = flowContext.getInitsForFinalBlankInitializationCheck( fieldBinding.declaringClass.original(), flowInfo); if (!fieldInits.isDefinitelyAssigned(fieldBinding)) { currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this); } } if (!fieldBinding.isStatic()) { // https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682 currentScope.resetEnclosingMethodStaticFlag(); } manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /*read-access*/); break; case Binding.LOCAL: // reading a local variable // check if assigning a final blank field LocalVariableBinding localBinding; if (!flowInfo.isDefinitelyAssigned(localBinding = (LocalVariableBinding) this.binding)) { currentScope.problemReporter().uninitializedLocalVariable(localBinding, this); // we could improve error msg here telling "cannot use compound assignment on final // local variable" } if (localBinding.useFlag != LocalVariableBinding.USED) { // https://bugs.eclipse.org/bugs/show_bug.cgi?id=185682 // access from compound assignment does not prevent "unused" warning, unless unboxing is // involved: if (isReachable && (this.implicitConversion & TypeIds.UNBOXING) != 0) { localBinding.useFlag = LocalVariableBinding.USED; } else { // use values < 0 to count the number of compound uses: if (localBinding.useFlag <= LocalVariableBinding.UNUSED) localBinding.useFlag--; } } } } if (assignment.expression != null) { flowInfo = assignment .expression .analyseCode(currentScope, flowContext, flowInfo) .unconditionalInits(); } switch (this.bits & ASTNode.RestrictiveFlagMASK) { case Binding.FIELD: // assigning to a field manageSyntheticAccessIfNecessary(currentScope, flowInfo, false /*write-access*/); // check if assigning a final field FieldBinding fieldBinding = (FieldBinding) this.binding; if (fieldBinding.isFinal()) { // inside a context where allowed if (!isCompound && fieldBinding.isBlankFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) { if (flowInfo.isPotentiallyAssigned(fieldBinding)) { currentScope .problemReporter() .duplicateInitializationOfBlankFinalField(fieldBinding, this); } else { flowContext.recordSettingFinal(fieldBinding, this, flowInfo); } flowInfo.markAsDefinitelyAssigned(fieldBinding); } else { currentScope.problemReporter().cannotAssignToFinalField(fieldBinding, this); } } if (!fieldBinding.isStatic()) { // https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682 currentScope.resetEnclosingMethodStaticFlag(); } break; case Binding.LOCAL: // assigning to a local variable LocalVariableBinding localBinding = (LocalVariableBinding) this.binding; if (!flowInfo.isDefinitelyAssigned(localBinding)) { // for local variable debug attributes this.bits |= ASTNode.FirstAssignmentToLocal; } else { this.bits &= ~ASTNode.FirstAssignmentToLocal; } if (localBinding.isFinal()) { if ((this.bits & ASTNode.DepthMASK) == 0) { // tolerate assignment to final local in unreachable code (45674) if ((isReachable && isCompound) || !localBinding.isBlankFinal()) { currentScope.problemReporter().cannotAssignToFinalLocal(localBinding, this); } else if (flowInfo.isPotentiallyAssigned(localBinding)) { currentScope .problemReporter() .duplicateInitializationOfFinalLocal(localBinding, this); } else { flowContext.recordSettingFinal(localBinding, this, flowInfo); } } else { currentScope.problemReporter().cannotAssignToFinalOuterLocal(localBinding, this); } } else /* avoid double diagnostic */ if ((localBinding.tagBits & TagBits.IsArgument) != 0) { currentScope.problemReporter().parameterAssignment(localBinding, this); } flowInfo.markAsDefinitelyAssigned(localBinding); } manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo); return flowInfo; }