Overview  Package  Class   Use  Tree  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

Uses of Class
org.eclipse.jdt.internal.compiler.lookup.BlockScope

Packages that use BlockScope
org.eclipse.jdt.internal.compiler   
org.eclipse.jdt.internal.compiler.ast   
org.eclipse.jdt.internal.compiler.codegen   
org.eclipse.jdt.internal.compiler.flow   
org.eclipse.jdt.internal.compiler.lookup   
 

Uses of BlockScope in org.eclipse.jdt.internal.compiler
 

Methods in org.eclipse.jdt.internal.compiler with parameters of type BlockScope
 void ASTVisitor.endVisit(AllocationExpression allocationExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(AND_AND_Expression and_and_Expression, BlockScope scope)
           
 void ASTVisitor.endVisit(Argument argument, BlockScope scope)
           
 void ASTVisitor.endVisit(ArrayAllocationExpression arrayAllocationExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(ArrayInitializer arrayInitializer, BlockScope scope)
           
 void ASTVisitor.endVisit(ArrayQualifiedTypeReference arrayQualifiedTypeReference, BlockScope scope)
           
 void ASTVisitor.endVisit(ArrayReference arrayReference, BlockScope scope)
           
 void ASTVisitor.endVisit(ArrayTypeReference arrayTypeReference, BlockScope scope)
           
 void ASTVisitor.endVisit(AssertStatement assertStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(Assignment assignment, BlockScope scope)
           
 void ASTVisitor.endVisit(BinaryExpression binaryExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(Block block, BlockScope scope)
           
 void ASTVisitor.endVisit(BreakStatement breakStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(CaseStatement caseStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(CastExpression castExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(CharLiteral charLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(ClassLiteralAccess classLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(CompoundAssignment compoundAssignment, BlockScope scope)
           
 void ASTVisitor.endVisit(ConditionalExpression conditionalExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(ContinueStatement continueStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(DoStatement doStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(DoubleLiteral doubleLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(EmptyStatement emptyStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(EqualExpression equalExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(ExplicitConstructorCall explicitConstructor, BlockScope scope)
           
 void ASTVisitor.endVisit(ExtendedStringLiteral extendedStringLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(FalseLiteral falseLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(FieldReference fieldReference, BlockScope scope)
           
 void ASTVisitor.endVisit(FloatLiteral floatLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(ForeachStatement forStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(ForStatement forStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(IfStatement ifStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(InstanceOfExpression instanceOfExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(IntersectionCastTypeReference intersectionCastTypeReference, BlockScope scope)
           
 void ASTVisitor.endVisit(IntLiteral intLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocAllocationExpression expression, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocArgumentExpression expression, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocArrayQualifiedTypeReference typeRef, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocArraySingleTypeReference typeRef, BlockScope scope)
           
 void ASTVisitor.endVisit(Javadoc javadoc, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocFieldReference fieldRef, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocImplicitTypeReference implicitTypeReference, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocMessageSend messageSend, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocQualifiedTypeReference typeRef, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocReturnStatement statement, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocSingleNameReference argument, BlockScope scope)
           
 void ASTVisitor.endVisit(JavadocSingleTypeReference typeRef, BlockScope scope)
           
 void ASTVisitor.endVisit(LabeledStatement labeledStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(LambdaExpression lambdaExpression, BlockScope blockScope)
           
 void ASTVisitor.endVisit(LocalDeclaration localDeclaration, BlockScope scope)
           
 void ASTVisitor.endVisit(LongLiteral longLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(MarkerAnnotation annotation, BlockScope scope)
           
 void ASTVisitor.endVisit(MemberValuePair pair, BlockScope scope)
           
 void ASTVisitor.endVisit(MessageSend messageSend, BlockScope scope)
           
 void ASTVisitor.endVisit(NormalAnnotation annotation, BlockScope scope)
           
 void ASTVisitor.endVisit(NullLiteral nullLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(OR_OR_Expression or_or_Expression, BlockScope scope)
           
 void ASTVisitor.endVisit(ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference, BlockScope scope)
           
 void ASTVisitor.endVisit(ParameterizedSingleTypeReference parameterizedSingleTypeReference, BlockScope scope)
           
 void ASTVisitor.endVisit(PostfixExpression postfixExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(PrefixExpression prefixExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(QualifiedAllocationExpression qualifiedAllocationExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(QualifiedNameReference qualifiedNameReference, BlockScope scope)
           
 void ASTVisitor.endVisit(QualifiedSuperReference qualifiedSuperReference, BlockScope scope)
           
 void ASTVisitor.endVisit(QualifiedThisReference qualifiedThisReference, BlockScope scope)
           
 void ASTVisitor.endVisit(QualifiedTypeReference qualifiedTypeReference, BlockScope scope)
           
 void ASTVisitor.endVisit(ReferenceExpression referenceExpression, BlockScope blockScope)
           
 void ASTVisitor.endVisit(ReturnStatement returnStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(SingleMemberAnnotation annotation, BlockScope scope)
           
 void ASTVisitor.endVisit(SingleNameReference singleNameReference, BlockScope scope)
           
 void ASTVisitor.endVisit(SingleTypeReference singleTypeReference, BlockScope scope)
           
 void ASTVisitor.endVisit(StringLiteral stringLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(StringLiteralConcatenation literal, BlockScope scope)
           
 void ASTVisitor.endVisit(SuperReference superReference, BlockScope scope)
           
 void ASTVisitor.endVisit(SwitchStatement switchStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(SynchronizedStatement synchronizedStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(ThisReference thisReference, BlockScope scope)
           
 void ASTVisitor.endVisit(ThrowStatement throwStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(TrueLiteral trueLiteral, BlockScope scope)
           
 void ASTVisitor.endVisit(TryStatement tryStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(TypeDeclaration localTypeDeclaration, BlockScope scope)
           
 void ASTVisitor.endVisit(TypeParameter typeParameter, BlockScope scope)
           
 void ASTVisitor.endVisit(UnaryExpression unaryExpression, BlockScope scope)
           
 void ASTVisitor.endVisit(UnionTypeReference unionTypeReference, BlockScope scope)
           
 void ASTVisitor.endVisit(WhileStatement whileStatement, BlockScope scope)
           
 void ASTVisitor.endVisit(Wildcard wildcard, BlockScope scope)
           
 boolean ASTVisitor.visit(AllocationExpression allocationExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(AND_AND_Expression and_and_Expression, BlockScope scope)
           
 boolean ASTVisitor.visit(Argument argument, BlockScope scope)
           
 boolean ASTVisitor.visit(ArrayAllocationExpression arrayAllocationExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(ArrayInitializer arrayInitializer, BlockScope scope)
           
 boolean ASTVisitor.visit(ArrayQualifiedTypeReference arrayQualifiedTypeReference, BlockScope scope)
           
 boolean ASTVisitor.visit(ArrayReference arrayReference, BlockScope scope)
           
 boolean ASTVisitor.visit(ArrayTypeReference arrayTypeReference, BlockScope scope)
           
 boolean ASTVisitor.visit(AssertStatement assertStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(Assignment assignment, BlockScope scope)
           
 boolean ASTVisitor.visit(BinaryExpression binaryExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(Block block, BlockScope scope)
           
 boolean ASTVisitor.visit(BreakStatement breakStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(CaseStatement caseStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(CastExpression castExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(CharLiteral charLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(ClassLiteralAccess classLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(CompoundAssignment compoundAssignment, BlockScope scope)
           
 boolean ASTVisitor.visit(ConditionalExpression conditionalExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(ContinueStatement continueStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(DoStatement doStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(DoubleLiteral doubleLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(EmptyStatement emptyStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(EqualExpression equalExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(ExplicitConstructorCall explicitConstructor, BlockScope scope)
           
 boolean ASTVisitor.visit(ExtendedStringLiteral extendedStringLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(FalseLiteral falseLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(FieldReference fieldReference, BlockScope scope)
           
 boolean ASTVisitor.visit(FloatLiteral floatLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(ForeachStatement forStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(ForStatement forStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(IfStatement ifStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(InstanceOfExpression instanceOfExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(IntersectionCastTypeReference intersectionCastTypeReference, BlockScope scope)
           
 boolean ASTVisitor.visit(IntLiteral intLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocAllocationExpression expression, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocArgumentExpression expression, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocArrayQualifiedTypeReference typeRef, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocArraySingleTypeReference typeRef, BlockScope scope)
           
 boolean ASTVisitor.visit(Javadoc javadoc, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocFieldReference fieldRef, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocImplicitTypeReference implicitTypeReference, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocMessageSend messageSend, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocQualifiedTypeReference typeRef, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocReturnStatement statement, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocSingleNameReference argument, BlockScope scope)
           
 boolean ASTVisitor.visit(JavadocSingleTypeReference typeRef, BlockScope scope)
           
 boolean ASTVisitor.visit(LabeledStatement labeledStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(LambdaExpression lambdaExpression, BlockScope blockScope)
           
 boolean ASTVisitor.visit(LocalDeclaration localDeclaration, BlockScope scope)
           
 boolean ASTVisitor.visit(LongLiteral longLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(MarkerAnnotation annotation, BlockScope scope)
           
 boolean ASTVisitor.visit(MemberValuePair pair, BlockScope scope)
           
 boolean ASTVisitor.visit(MessageSend messageSend, BlockScope scope)
           
 boolean ASTVisitor.visit(NormalAnnotation annotation, BlockScope scope)
           
 boolean ASTVisitor.visit(NullLiteral nullLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(OR_OR_Expression or_or_Expression, BlockScope scope)
           
 boolean ASTVisitor.visit(ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference, BlockScope scope)
           
 boolean ASTVisitor.visit(ParameterizedSingleTypeReference parameterizedSingleTypeReference, BlockScope scope)
           
 boolean ASTVisitor.visit(PostfixExpression postfixExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(PrefixExpression prefixExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(QualifiedAllocationExpression qualifiedAllocationExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(QualifiedNameReference qualifiedNameReference, BlockScope scope)
           
 boolean ASTVisitor.visit(QualifiedSuperReference qualifiedSuperReference, BlockScope scope)
           
 boolean ASTVisitor.visit(QualifiedThisReference qualifiedThisReference, BlockScope scope)
           
 boolean ASTVisitor.visit(QualifiedTypeReference qualifiedTypeReference, BlockScope scope)
           
 boolean ASTVisitor.visit(ReferenceExpression referenceExpression, BlockScope blockScope)
           
 boolean ASTVisitor.visit(ReturnStatement returnStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(SingleMemberAnnotation annotation, BlockScope scope)
           
 boolean ASTVisitor.visit(SingleNameReference singleNameReference, BlockScope scope)
           
 boolean ASTVisitor.visit(SingleTypeReference singleTypeReference, BlockScope scope)
           
 boolean ASTVisitor.visit(StringLiteral stringLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(StringLiteralConcatenation literal, BlockScope scope)
           
 boolean ASTVisitor.visit(SuperReference superReference, BlockScope scope)
           
 boolean ASTVisitor.visit(SwitchStatement switchStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(SynchronizedStatement synchronizedStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(ThisReference thisReference, BlockScope scope)
           
 boolean ASTVisitor.visit(ThrowStatement throwStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(TrueLiteral trueLiteral, BlockScope scope)
           
 boolean ASTVisitor.visit(TryStatement tryStatement, BlockScope scope)
           
 boolean SourceElementNotifier.LocalDeclarationVisitor.visit(TypeDeclaration typeDeclaration, BlockScope scope)
           
 boolean ASTVisitor.visit(TypeDeclaration localTypeDeclaration, BlockScope scope)
           
 boolean ASTVisitor.visit(TypeParameter typeParameter, BlockScope scope)
           
 boolean ASTVisitor.visit(UnaryExpression unaryExpression, BlockScope scope)
           
 boolean ASTVisitor.visit(UnionTypeReference unionTypeReference, BlockScope scope)
           
 boolean ASTVisitor.visit(WhileStatement whileStatement, BlockScope scope)
           
 boolean ASTVisitor.visit(Wildcard wildcard, BlockScope scope)
           
 

Uses of BlockScope in org.eclipse.jdt.internal.compiler.ast
 

Fields in org.eclipse.jdt.internal.compiler.ast declared as BlockScope
 BlockScope FunctionalExpression.enclosingScope
           
 BlockScope ForStatement.scope
           
 BlockScope ForeachStatement.scope
           
 BlockScope SynchronizedStatement.scope
           
 BlockScope SwitchStatement.scope
           
 BlockScope Block.scope
           
 

Methods in org.eclipse.jdt.internal.compiler.ast with parameters of type BlockScope
protected  void Statement.analyseArguments(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, MethodBinding methodBinding, Expression[] arguments)
          Analysing arguments of MessageSend, ExplicitConstructorCall, AllocationExpression.
abstract  FlowInfo Reference.analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound)
           
 FlowInfo FieldReference.analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound)
           
 FlowInfo SingleNameReference.analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound)
           
 FlowInfo QualifiedNameReference.analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound)
           
 FlowInfo ArrayReference.analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean compoundAssignment)
           
 FlowInfo ThisReference.analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound)
           
static void FakedTrackingVariable.analyseCloseableAllocation(BlockScope scope, FlowInfo flowInfo, AllocationExpression allocation)
          Compute/assign a tracking variable for a freshly allocated closeable value, using information from our white lists.
 FlowInfo DoStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo AssertStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo Reference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
abstract  FlowInfo Statement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo FieldReference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo Expression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo OR_OR_Expression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo Assignment.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo CombinedBinaryExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ExplicitConstructorCall.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo AbstractVariableDeclaration.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ForStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ConditionalExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo TypeDeclaration.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
          Flow analysis for a local innertype
 FlowInfo EmptyStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ForeachStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ThrowStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo SynchronizedStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo WhileStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo TypeReference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo SingleNameReference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo AND_AND_Expression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo LocalDeclaration.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ArrayInitializer.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo QualifiedAllocationExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo LabeledStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo IfStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo LambdaExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo QualifiedNameReference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ArrayReference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo AllocationExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ReturnStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo CompoundAssignment.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo InstanceOfExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo UnaryExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo SwitchStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo QualifiedThisReference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ReferenceExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo Block.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ClassLiteralAccess.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ArrayAllocationExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo BreakStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo EqualExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo BinaryExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo CaseStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo ContinueStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo Literal.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo CastExpression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo MessageSend.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo TryStatement.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo)
           
 FlowInfo FieldReference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired)
           
 FlowInfo Expression.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired)
          More sophisticated for of the flow analysis used for analyzing expressions, and be able to optimize out portions of expressions where no actual value is required.
 FlowInfo SingleNameReference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired)
           
 FlowInfo QualifiedNameReference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired)
           
 FlowInfo QualifiedThisReference.analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired)
           
 boolean ThisReference.checkAccess(BlockScope scope, ReferenceBinding receiverType)
           
protected  void Statement.checkAgainstNullTypeAnnotation(BlockScope scope, TypeBinding requiredType, Expression expression, FlowContext flowContext, FlowInfo flowInfo)
           
static int NullAnnotationMatching.checkAssignment(BlockScope currentScope, FlowContext flowContext, VariableBinding var, int nullStatus, Expression expression, TypeBinding providedType)
          Check null-ness of 'var' against a possible null annotation
 void AllocationExpression.checkCapturedLocalInitializationIfNecessary(ReferenceBinding checkedType, BlockScope currentScope, FlowInfo flowInfo)
           
static void Annotation.checkContainerAnnotationType(ASTNode culpritNode, BlockScope scope, ReferenceBinding containerAnnotationType, ReferenceBinding repeatableAnnotationType, boolean useSite)
           
static void Annotation.checkContainingAnnotationTargetAtUse(Annotation repeatingAnnotation, BlockScope scope, TypeBinding containerAnnotationType, TypeBinding repeatingAnnotationType)
           
 TypeBinding SingleNameReference.checkFieldAccess(BlockScope scope)
           
static void Annotation.checkForInstancesOfRepeatableWithRepeatingContainerAnnotation(BlockScope scope, ReferenceBinding repeatedAnnotationType, Annotation[] sourceAnnotations)
          Check to see if a repeating annotation is in fact of a container annotation type for an annotation which is also present at the same target.
static boolean ASTNode.checkInvocationArguments(BlockScope scope, Expression receiver, TypeBinding receiverType, MethodBinding method, Expression[] arguments, TypeBinding[] argumentTypes, boolean argsContainCast, InvocationSite invocationSite)
           
static void CastExpression.checkNeedForArgumentCast(BlockScope scope, int operator, int operatorSignature, Expression expression, int expressionTypeId)
          Only complain for identity cast, since other type of casts may be useful: e.g.
static void CastExpression.checkNeedForArgumentCasts(BlockScope scope, Expression receiver, TypeBinding receiverType, MethodBinding binding, Expression[] arguments, TypeBinding[] argumentTypes, InvocationSite invocationSite)
          Cast expressions will considered as useful if removing them all would actually bind to a different method (no fine grain analysis on per casted argument basis, simply separate widening cast from narrowing ones)
static void CastExpression.checkNeedForArgumentCasts(BlockScope scope, int operator, int operatorSignature, Expression left, int leftTypeId, boolean leftIsCast, Expression right, int rightTypeId, boolean rightIsCast)
          Check binary operator casted arguments
static void CastExpression.checkNeedForAssignedCast(BlockScope scope, TypeBinding expectedType, CastExpression rhs)
          Complain if assigned expression is cast, but not actually used as such, e.g.
static void CastExpression.checkNeedForCastCast(BlockScope scope, CastExpression enclosingCast)
          Complain if cast expression is cast, but not actually needed, int i = (int)(Integer) 12; Note that this (int) cast is however needed: Integer i = 0; char c = (char)((int) i);
static void CastExpression.checkNeedForEnclosingInstanceCast(BlockScope scope, Expression enclosingInstance, TypeBinding enclosingInstanceType, TypeBinding memberType)
          Casting an enclosing instance will considered as useful if removing it would actually bind to a different type
 boolean Reference.checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
           
 boolean FieldReference.checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
           
 boolean Expression.checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
          Check this expression against potential NPEs, which may occur: if the expression is the receiver in a field access, qualified allocation, array reference or message send incl.
 boolean ConditionalExpression.checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
           
 boolean SingleNameReference.checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
           
 boolean QualifiedNameReference.checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
           
 boolean ArrayReference.checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
           
 boolean ThisReference.checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
           
 boolean CastExpression.checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
           
 boolean MessageSend.checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
           
protected  void Expression.checkNPEbyUnboxing(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo)
          If this expression requires unboxing check if that operation can throw NPE.
 void Annotation.checkRepeatableMetaAnnotation(BlockScope scope)
           
 void AllocationExpression.checkTypeArgumentRedundancy(ParameterizedTypeBinding allocationType, ReferenceBinding enclosingType, TypeBinding[] argumentTypes, BlockScope scope)
           
static void FakedTrackingVariable.cleanUpAfterAssignment(BlockScope currentScope, int lhsBits, Expression expression)
           
 int Statement.complainIfUnreachable(FlowInfo flowInfo, BlockScope scope, int previousComplaintLevel, boolean endOfBlock)
           
 int EmptyStatement.complainIfUnreachable(FlowInfo flowInfo, BlockScope scope, int complaintLevel, boolean endOfBlock)
           
 void BinaryExpression.computeConstant(BlockScope scope, int leftId, int rightId)
           
protected  void ConditionalExpression.computeConversions(BlockScope scope, TypeBinding targetType)
           
static void ASTNode.copySE8AnnotationsToType(BlockScope scope, Binding recipient, Annotation[] annotations, boolean isLegalLocation)
           
protected  MethodBinding Statement.findConstructorBinding(BlockScope scope, Invocation site, ReferenceBinding receiverType, TypeBinding[] argumentTypes)
          For all constructor invocations: find the constructor binding; if site.innersNeedUpdate() perform some post processing for those and produce any updates as side-effects into 'argumentTypes'.
 ReferenceBinding LambdaExpression.findGroundTargetTypeForElidedLambda(BlockScope blockScope, ParameterizedTypeBinding withWildCards)
           
protected  void MessageSend.findMethodBinding(BlockScope scope, TypeBinding[] argumentTypes)
          Find the method binding; if this.innersNeedUpdate allow for two attempts where the first round may stop after applicability checking (18.5.1) to include more information into the final invocation type inference (18.5.2).
 int FakedTrackingVariable.findMostSpecificStatus(FlowInfo flowInfo, BlockScope currentScope, BlockScope locationScope)
           
 void Statement.generateArguments(MethodBinding binding, Expression[] arguments, BlockScope currentScope, CodeStream codeStream)
          Generate invocation arguments, considering varargs methods
abstract  void Reference.generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired)
           
 void FieldReference.generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired)
           
 void SingleNameReference.generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired)
           
 void QualifiedNameReference.generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired)
           
 void ArrayReference.generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired)
           
 void ThisReference.generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired)
           
 void EqualExpression.generateBooleanEqual(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Boolean generation for == with boolean operands Note this code does not optimize conditional constants !!!!
 void DoStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          Do statement code generation
 void AssertStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
           
abstract  void Statement.generateCode(BlockScope currentScope, CodeStream codeStream)
           
 void Expression.generateCode(BlockScope currentScope, CodeStream codeStream)
          Expression statements are plain expressions, however they generate like normal expressions with no value required.
 void BranchStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          Branch code generation generate the finallyInvocationSequence.
 void FakedTrackingVariable.generateCode(BlockScope currentScope, CodeStream codeStream)
           
 void ExplicitConstructorCall.generateCode(BlockScope currentScope, CodeStream codeStream)
          Constructor call code generation
 void ForStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          For statement code generation
 void TypeDeclaration.generateCode(BlockScope blockScope, CodeStream codeStream)
          Bytecode generation for a local inner type (API as a normal statement code gen)
 void EmptyStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
           
 void ForeachStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          For statement code generation
 void FieldDeclaration.generateCode(BlockScope currentScope, CodeStream codeStream)
          Code generation for a field declaration: standard assignment to a field
 void ThrowStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          Throw code generation
 void SynchronizedStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          Synchronized statement code generation
 void WhileStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          While code generation
 void LocalDeclaration.generateCode(BlockScope currentScope, CodeStream codeStream)
          Code generation for a local declaration: i.e. normal assignment to a local variable + unused variable handling
 void LabeledStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          Code generation for labeled statement may not need actual source positions recording
 void IfStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          If code generation
 void ReturnStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          Retrun statement code generation generate the finallyInvocationSequence.
 void SwitchStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          Switch code generation
 void Block.generateCode(BlockScope currentScope, CodeStream codeStream)
          Code generation for a block
 void Initializer.generateCode(BlockScope currentScope, CodeStream codeStream)
          Code generation for a non-static initializer: standard block code gen
 void TypeParameter.generateCode(BlockScope currentScope, CodeStream codeStream)
           
 void CaseStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          Case code generation
 void TryStatement.generateCode(BlockScope currentScope, CodeStream codeStream)
          Try statement code generation with or without jsr bytecode use post 1.5 target level, cannot use jsr bytecode, must instead inline finally block returnAddress is only allocated if jsr is allowed
 void FieldReference.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Field reference code generation
 void Expression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Every expression is responsible for generating its implicit conversion when necessary.
 void OR_OR_Expression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for a binary operation
 void Assignment.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void PostfixExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for PostfixExpression
 void DoubleLiteral.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for the double literak
 void ConditionalExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for the conditional operator ?:
 void FloatLiteral.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for float literal
 void StringLiteral.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for string literal
 void CharLiteral.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          CharLiteral code generation
 void SingleNameReference.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void AND_AND_Expression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for a binary operation
 void ArrayInitializer.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void QualifiedAllocationExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void LambdaExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void QualifiedNameReference.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void ArrayReference.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for a array reference
 void AllocationExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void CompoundAssignment.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void InstanceOfExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for instanceOfExpression
 void UnaryExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for an unary operation
 void QualifiedThisReference.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for QualifiedThisReference
 void ReferenceExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void ClassLiteralAccess.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          MessageSendDotClass code generation
 void ArrayAllocationExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for a array allocation expression
 void EqualExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Normal == or != code generation.
 void BinaryExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for a binary operation
 void ThisReference.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void FalseLiteral.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for false literal
 void IntLiteral.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for long literal
 void CastExpression.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Cast expression code generation
 void NullLiteral.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for the null literal
 void TrueLiteral.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for the true literal
 void MessageSend.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          MessageSend code generation
 void LongLiteral.generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for long literal
 void ArrayInitializer.generateCode(TypeReference typeReference, ArrayAllocationExpression allocationExpression, BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Code generation for a array initializer
 void SwitchStatement.generateCodeForStringSwitch(BlockScope currentScope, CodeStream codeStream)
          Switch on String code generation This assumes that hashCode() specification for java.lang.String is API and is stable.
abstract  void Reference.generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired)
           
 void FieldReference.generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired)
           
 void SingleNameReference.generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired)
           
 void QualifiedNameReference.generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired)
           
 void ArrayReference.generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired)
           
 void ThisReference.generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired)
           
 void SingleNameReference.generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, MethodBinding writeAccessor, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired)
           
 void ReferenceExpression.generateImplicitLambda(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
           
 void BinaryExpression.generateLogicalAnd(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Boolean generation for &
 void BinaryExpression.generateLogicalOr(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Boolean generation for |
 void BinaryExpression.generateLogicalXor(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Boolean generation for ^
 void EqualExpression.generateNonBooleanEqual(BlockScope currentScope, CodeStream codeStream, boolean valueRequired)
          Boolean generation for == with non-boolean operands
 void Expression.generateOptimizedBoolean(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Default generation of a boolean value
 void OR_OR_Expression.generateOptimizedBoolean(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean operator code generation Optimized operations are: ||
 void ConditionalExpression.generateOptimizedBoolean(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Optimized boolean code generation for the conditional operator ?:
 void AND_AND_Expression.generateOptimizedBoolean(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean operator code generation Optimized operations are: &&
 void UnaryExpression.generateOptimizedBoolean(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean operator code generation Optimized operations are: &&, ||, <, <=, >, >=, &, |, ^
 void EqualExpression.generateOptimizedBoolean(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean operator code generation Optimized operations are: == and !=
 void BinaryExpression.generateOptimizedBoolean(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean operator code generation Optimized operations are: <, <=, >, >=, &, |, ^
 void FalseLiteral.generateOptimizedBoolean(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
           
 void TrueLiteral.generateOptimizedBoolean(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
           
 void EqualExpression.generateOptimizedBooleanEqual(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean generation for == with boolean operands Note this code does not optimize conditional constants !!!!
 void BinaryExpression.generateOptimizedGreaterThan(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean generation for >
 void BinaryExpression.generateOptimizedGreaterThanOrEqual(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean generation for >=
 void BinaryExpression.generateOptimizedLessThan(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean generation for <
 void BinaryExpression.generateOptimizedLessThanOrEqual(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean generation for <=
 void BinaryExpression.generateOptimizedLogicalAnd(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean generation for &
 void BinaryExpression.generateOptimizedLogicalOr(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean generation for |
 void BinaryExpression.generateOptimizedLogicalXor(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean generation for ^
 void EqualExpression.generateOptimizedNonBooleanEqual(BlockScope currentScope, CodeStream codeStream, BranchLabel trueLabel, BranchLabel falseLabel, boolean valueRequired)
          Boolean generation for == with non-boolean operands
 void Expression.generateOptimizedStringConcatenation(BlockScope blockScope, CodeStream codeStream, int typeID)
           
 void CombinedBinaryExpression.generateOptimizedStringConcatenation(BlockScope blockScope, CodeStream codeStream, int typeID)
           
 void BinaryExpression.generateOptimizedStringConcatenation(BlockScope blockScope, CodeStream codeStream, int typeID)
           
 void Expression.generateOptimizedStringConcatenationCreation(BlockScope blockScope, CodeStream codeStream, int typeID)
           
 void CombinedBinaryExpression.generateOptimizedStringConcatenationCreation(BlockScope blockScope, CodeStream codeStream, int typeID)
           
 void BinaryExpression.generateOptimizedStringConcatenationCreation(BlockScope blockScope, CodeStream codeStream, int typeID)
           
abstract  void Reference.generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired)
           
 void FieldReference.generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired)
           
 void SingleNameReference.generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired)
           
 void QualifiedNameReference.generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired)
           
 void ArrayReference.generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired)
           
 void ThisReference.generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired)
           
 FieldBinding QualifiedNameReference.generateReadSequence(BlockScope currentScope, CodeStream codeStream)
           
abstract  boolean SubRoutineStatement.generateSubRoutineInvocation(BlockScope currentScope, CodeStream codeStream, java.lang.Object targetLocation, int stateIndex, LocalVariableBinding secretLocal)
          Generate an invocation of a subroutine (e.g.
 boolean SynchronizedStatement.generateSubRoutineInvocation(BlockScope currentScope, CodeStream codeStream, java.lang.Object targetLocation, int stateIndex, LocalVariableBinding secretLocal)
           
 boolean TryStatement.generateSubRoutineInvocation(BlockScope currentScope, CodeStream codeStream, java.lang.Object targetLocation, int stateIndex, LocalVariableBinding secretLocal)
           
 TypeBinding QualifiedNameReference.getOtherFieldBindings(BlockScope scope)
           
static void FakedTrackingVariable.handleResourceAssignment(BlockScope scope, FlowInfo upstreamInfo, FlowInfo flowInfo, FlowContext flowContext, ASTNode location, Expression rhs, LocalVariableBinding local)
          Given the rhs of an assignment or local declaration has a (Auto)Closeable type (or null), setup for leak analysis now: Create or re-use a tracking variable, and wire and initialize everything.
 TypeBinding[] AllocationExpression.inferElidedTypes(ParameterizedTypeBinding allocationType, ReferenceBinding enclosingType, TypeBinding[] argumentTypes, BlockScope scope)
           
 boolean FakedTrackingVariable.isClosedInFinallyOfEnclosing(BlockScope scope)
           
 TypeBinding DoubleLiteral.literalType(BlockScope scope)
           
 TypeBinding FloatLiteral.literalType(BlockScope scope)
           
 TypeBinding StringLiteral.literalType(BlockScope scope)
           
 TypeBinding CharLiteral.literalType(BlockScope scope)
           
 TypeBinding FalseLiteral.literalType(BlockScope scope)
           
abstract  TypeBinding Literal.literalType(BlockScope scope)
           
 TypeBinding IntLiteral.literalType(BlockScope scope)
           
 TypeBinding NullLiteral.literalType(BlockScope scope)
           
 TypeBinding TrueLiteral.literalType(BlockScope scope)
           
 TypeBinding LongLiteral.literalType(BlockScope scope)
           
 void TypeDeclaration.manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo)
           
 void SingleNameReference.manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo)
           
 void QualifiedAllocationExpression.manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo)
           
 void QualifiedNameReference.manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo)
           
 void AllocationExpression.manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo)
           
 void QualifiedNameReference.manageSyntheticAccessIfNecessary(BlockScope currentScope, FieldBinding fieldBinding, int index, FlowInfo flowInfo)
          index is <0 to denote write access emulation
 void AssertStatement.manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo)
           
 void ExplicitConstructorCall.manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo)
           
 void AllocationExpression.manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo)
           
 void ReferenceExpression.manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo)
           
 void MessageSend.manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo)
           
 void FieldReference.manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo, boolean isReadAccess)
           
 void SingleNameReference.manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo, boolean isReadAccess)
           
static FlowInfo FakedTrackingVariable.markPassedToOutside(BlockScope scope, Expression expression, FlowInfo flowInfo, FlowContext flowContext, boolean owned)
          Mark that this resource is passed to some outside code (as argument to a method/ctor call or as a return value from the current method), and thus should be considered as potentially closed.
 int FakedTrackingVariable.mergeCloseStatus(BlockScope currentScope, int status, LocalVariableBinding local, BlockScope outerScope)
           
static FakedTrackingVariable FakedTrackingVariable.pickVarForReporting(java.util.Set varsOfScope, BlockScope scope, boolean atExit)
          Pick tracking variables from 'varsOfScope' to establish a proper order of processing: As much as possible pick wrapper resources before their inner resources.
protected  void Statement.recordExceptionsForEnclosingLambda(BlockScope scope, TypeBinding... thrownExceptions)
          If an exception-throwing statement is resolved within the scope of a lambda, record the exception type(s).
 TypeBinding SingleNameReference.reportError(BlockScope scope)
           
 TypeBinding QualifiedNameReference.reportError(BlockScope scope)
          Normal field binding did not work, try to bind to a field of the delegate receiver.
protected  TypeBinding FunctionalExpression.reportSamProblem(BlockScope blockScope, MethodBinding sam)
           
 void DoStatement.resolve(BlockScope scope)
           
 void AssertStatement.resolve(BlockScope scope)
           
 void JavadocReturnStatement.resolve(BlockScope scope)
           
abstract  void Statement.resolve(BlockScope scope)
           
 void Expression.resolve(BlockScope scope)
           
 void JavadocSingleNameReference.resolve(BlockScope scope)
           
 void BranchStatement.resolve(BlockScope scope)
           
 void FakedTrackingVariable.resolve(BlockScope scope)
           
 void ExplicitConstructorCall.resolve(BlockScope scope)
           
 void AbstractVariableDeclaration.resolve(BlockScope scope)
           
 void ForStatement.resolve(BlockScope upperScope)
           
 void JavadocArgumentExpression.resolve(BlockScope scope)
           
 void TypeDeclaration.resolve(BlockScope blockScope)
          Resolve a local type declaration
 void EmptyStatement.resolve(BlockScope scope)
           
 void ForeachStatement.resolve(BlockScope upperScope)
           
 void ThrowStatement.resolve(BlockScope scope)
           
 void SynchronizedStatement.resolve(BlockScope upperScope)
           
 void WhileStatement.resolve(BlockScope scope)
           
 void LocalDeclaration.resolve(BlockScope scope)
           
 void LabeledStatement.resolve(BlockScope scope)
           
 void IfStatement.resolve(BlockScope scope)
           
 void ReturnStatement.resolve(BlockScope scope)
           
 void SwitchStatement.resolve(BlockScope upperScope)
           
 void Block.resolve(BlockScope upperScope)
           
 void TypeParameter.resolve(BlockScope scope)
           
 void CaseStatement.resolve(BlockScope scope)
          No-op : should use resolveCase(...) instead.
 void TryStatement.resolve(BlockScope upperScope)
           
 void JavadocSingleNameReference.resolve(BlockScope scope, boolean warn, boolean considerParamRefAsUsage)
          Resolve without warnings
static TypeBinding ASTNode.resolveAnnotations(BlockScope scope, Annotation[][] sourceAnnotations, TypeBinding type)
          Resolve JSR308 annotations on a type reference, array creation expression or a wildcard.
static void ASTNode.resolveAnnotations(BlockScope scope, Annotation[] sourceAnnotations, Binding recipient)
           
static AnnotationBinding[] ASTNode.resolveAnnotations(BlockScope scope, Annotation[] sourceAnnotations, Binding recipient, boolean copySE8AnnotationsToType)
          Resolve annotations, and check duplicates, answers combined tagBits for recognized standard annotations.
 Constant Statement.resolveCase(BlockScope scope, TypeBinding testType, SwitchStatement switchStatement)
          Returns case constant associated to this statement (NotAConstant if none)
 Constant CaseStatement.resolveCase(BlockScope scope, TypeBinding switchExpressionType, SwitchStatement switchStatement)
          Returns the constant intValue or ordinal for enum constants.
static void ASTNode.resolveDeprecatedAnnotations(BlockScope scope, Annotation[] annotations, Binding recipient)
          Figures if @Deprecated annotation is specified, do not resolve entire annotations.
 TypeBinding Argument.resolveForCatch(BlockScope scope)
           
 TypeBinding SuperReference.resolveType(BlockScope scope)
           
 TypeBinding FieldReference.resolveType(BlockScope scope)
           
 TypeBinding Expression.resolveType(BlockScope scope)
          Resolve the type of this expression in the context of a blockScope
 TypeBinding OR_OR_Expression.resolveType(BlockScope scope)
           
 TypeBinding Assignment.resolveType(BlockScope scope)
           
 TypeBinding CombinedBinaryExpression.resolveType(BlockScope scope)
           
 TypeBinding ConditionalExpression.resolveType(BlockScope scope)
           
 TypeBinding FunctionalExpression.resolveType(BlockScope blockScope)
           
 TypeBinding JavadocArgumentExpression.resolveType(BlockScope scope)
           
 TypeBinding JavadocMessageSend.resolveType(BlockScope scope)
           
 TypeBinding TypeReference.resolveType(BlockScope blockScope)
           
 TypeBinding SingleNameReference.resolveType(BlockScope scope)
           
 TypeBinding AND_AND_Expression.resolveType(BlockScope scope)
           
 TypeBinding QualifiedSuperReference.resolveType(BlockScope scope)
           
 TypeBinding JavadocFieldReference.resolveType(BlockScope scope)
           
 TypeBinding JavadocAllocationExpression.resolveType(BlockScope scope)
           
 TypeBinding QualifiedAllocationExpression.resolveType(BlockScope scope)
           
 TypeBinding Annotation.resolveType(BlockScope scope)
           
 TypeBinding LambdaExpression.resolveType(BlockScope blockScope)
           
 TypeBinding QualifiedNameReference.resolveType(BlockScope scope)
           
 TypeBinding ArrayReference.resolveType(BlockScope scope)
           
 TypeBinding AllocationExpression.resolveType(BlockScope scope)
           
 TypeBinding CompoundAssignment.resolveType(BlockScope scope)
           
 TypeBinding InstanceOfExpression.resolveType(BlockScope scope)
           
 TypeBinding UnaryExpression.resolveType(BlockScope scope)
           
 TypeBinding QualifiedThisReference.resolveType(BlockScope scope)
           
 TypeBinding ReferenceExpression.resolveType(BlockScope scope)
           
 TypeBinding ClassLiteralAccess.resolveType(BlockScope scope)
           
 TypeBinding ArrayAllocationExpression.resolveType(BlockScope scope)
           
 TypeBinding EqualExpression.resolveType(BlockScope scope)
           
 TypeBinding BinaryExpression.resolveType(BlockScope scope)
           
 TypeBinding ContainerAnnotation.resolveType(BlockScope scope)
           
 TypeBinding ThisReference.resolveType(BlockScope scope)
           
 TypeBinding Literal.resolveType(BlockScope scope)
           
 TypeBinding CastExpression.resolveType(BlockScope scope)
           
 TypeBinding MessageSend.resolveType(BlockScope scope)
           
 TypeBinding TypeReference.resolveType(BlockScope scope, boolean checkBounds)
           
 TypeBinding UnionTypeReference.resolveType(BlockScope scope, boolean checkBounds, int location)
           
 TypeBinding JavadocQualifiedTypeReference.resolveType(BlockScope blockScope, boolean checkBounds, int location)
           
 TypeBinding TypeReference.resolveType(BlockScope scope, boolean checkBounds, int location)
           
 TypeBinding Wildcard.resolveType(BlockScope scope, boolean checkBounds, int location)
           
 TypeBinding IntersectionCastTypeReference.resolveType(BlockScope scope, boolean checkBounds, int location)
           
 TypeBinding ParameterizedQualifiedTypeReference.resolveType(BlockScope scope, boolean checkBounds, int location)
           
 TypeBinding ParameterizedSingleTypeReference.resolveType(BlockScope scope, boolean checkBounds, int location)
           
 TypeBinding TypeReference.resolveTypeArgument(BlockScope blockScope, ReferenceBinding genericType, int rank)
           
 TypeBinding Wildcard.resolveTypeArgument(BlockScope blockScope, ReferenceBinding genericType, int rank)
           
 TypeBinding SingleTypeReference.resolveTypeEnclosing(BlockScope scope, ReferenceBinding enclosingType)
           
 TypeBinding ParameterizedSingleTypeReference.resolveTypeEnclosing(BlockScope scope, ReferenceBinding enclosingType)
           
 TypeBinding Expression.resolveTypeExpecting(BlockScope scope, TypeBinding expectedType)
           
 TypeBinding Assignment.resolveTypeExpecting(BlockScope scope, TypeBinding expectedType)
           
 TypeBinding ArrayInitializer.resolveTypeExpecting(BlockScope scope, TypeBinding expectedType)
           
 void MemberValuePair.resolveTypeExpecting(BlockScope scope, TypeBinding requiredType)
           
 void Block.resolveUsing(BlockScope givenScope)
           
 void DoStatement.traverse(ASTVisitor visitor, BlockScope scope)
           
 void AssertStatement.traverse(ASTVisitor visitor, BlockScope scope)
           
 void JavadocReturnStatement.traverse(ASTVisitor visitor, BlockScope scope)
           
 void SuperReference.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void FieldReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void Expression.traverse(ASTVisitor visitor, BlockScope scope)
          Traverse an expression in the context of a blockScope
 void OR_OR_Expression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void Assignment.traverse(ASTVisitor visitor, BlockScope scope)
           
 void JavadocSingleNameReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void CombinedBinaryExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void PostfixExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ExplicitConstructorCall.traverse(ASTVisitor visitor, BlockScope scope)
           
 void DoubleLiteral.traverse(ASTVisitor visitor, BlockScope scope)
           
 void JavadocArrayQualifiedTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ForStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void ConditionalExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void SingleMemberAnnotation.traverse(ASTVisitor visitor, BlockScope scope)
           
 void StringLiteralConcatenation.traverse(ASTVisitor visitor, BlockScope scope)
           
 void JavadocArgumentExpression.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void TypeDeclaration.traverse(ASTVisitor visitor, BlockScope blockScope)
          Iteration for a local inner type
 void UnionTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void EmptyStatement.traverse(ASTVisitor visitor, BlockScope scope)
           
 void MarkerAnnotation.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ForeachStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void ThrowStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void SynchronizedStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void FloatLiteral.traverse(ASTVisitor visitor, BlockScope scope)
           
 void StringLiteral.traverse(ASTVisitor visitor, BlockScope scope)
           
 void CharLiteral.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void WhileStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void JavadocQualifiedTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void JavadocMessageSend.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void ArrayQualifiedTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
abstract  void TypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void SingleNameReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ASTNode.traverse(ASTVisitor visitor, BlockScope scope)
           
 void AND_AND_Expression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void QualifiedSuperReference.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void JavadocFieldReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void JavadocAllocationExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void LocalDeclaration.traverse(ASTVisitor visitor, BlockScope scope)
           
 void NormalAnnotation.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ArrayInitializer.traverse(ASTVisitor visitor, BlockScope scope)
           
 void QualifiedAllocationExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
abstract  void Annotation.traverse(ASTVisitor visitor, BlockScope scope)
           
 void Wildcard.traverse(ASTVisitor visitor, BlockScope scope)
           
 void LabeledStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void IfStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void LambdaExpression.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void JavadocImplicitTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void QualifiedNameReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ArrayReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void AllocationExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void PrefixExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ExtendedStringLiteral.traverse(ASTVisitor visitor, BlockScope scope)
           
 void MemberValuePair.traverse(ASTVisitor visitor, BlockScope scope)
           
 void SingleTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void IntersectionCastTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ReturnStatement.traverse(ASTVisitor visitor, BlockScope scope)
           
 void CompoundAssignment.traverse(ASTVisitor visitor, BlockScope scope)
           
 void InstanceOfExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ParameterizedQualifiedTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void UnaryExpression.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void SwitchStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void QualifiedThisReference.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void ReferenceExpression.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void Block.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void ClassLiteralAccess.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void QualifiedTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void JavadocSingleTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ArrayAllocationExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void JavadocArraySingleTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void BreakStatement.traverse(ASTVisitor visitor, BlockScope blockscope)
           
 void ArrayTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void TypeParameter.traverse(ASTVisitor visitor, BlockScope scope)
           
 void EqualExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ParameterizedSingleTypeReference.traverse(ASTVisitor visitor, BlockScope scope)
           
 void BinaryExpression.traverse(ASTVisitor visitor, BlockScope scope)
           
 void ThisReference.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void FalseLiteral.traverse(ASTVisitor visitor, BlockScope scope)
           
 void CaseStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void ContinueStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void IntLiteral.traverse(ASTVisitor visitor, BlockScope scope)
           
 void CastExpression.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void NullLiteral.traverse(ASTVisitor visitor, BlockScope scope)
           
 void Argument.traverse(ASTVisitor visitor, BlockScope scope)
           
 void TrueLiteral.traverse(ASTVisitor visitor, BlockScope scope)
           
 void MessageSend.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 void LongLiteral.traverse(ASTVisitor visitor, BlockScope scope)
           
 void Javadoc.traverse(ASTVisitor visitor, BlockScope scope)
           
 void TryStatement.traverse(ASTVisitor visitor, BlockScope blockScope)
           
 

Constructors in org.eclipse.jdt.internal.compiler.ast with parameters of type BlockScope
ContainerAnnotation(Annotation repeatingAnnotation, ReferenceBinding containerAnnotationType, BlockScope scope)
           
 

Uses of BlockScope in org.eclipse.jdt.internal.compiler.codegen
 

Methods in org.eclipse.jdt.internal.compiler.codegen with parameters of type BlockScope
 void CodeStream.exitUserScope(BlockScope currentScope)
           
 void CodeStream.exitUserScope(BlockScope currentScope, LocalVariableBinding binding)
           
 void CodeStream.generateStringConcatenationAppend(BlockScope blockScope, Expression oper1, Expression oper2)
          The equivalent code performs a string conversion:
 void CodeStream.generateSyntheticEnclosingInstanceValues(BlockScope currentScope, ReferenceBinding targetType, Expression enclosingInstance, ASTNode invocationSite)
          Code responsible to generate the suitable code to supply values for the synthetic enclosing instance arguments of a constructor invocation of a nested type.
 void CodeStream.generateSyntheticOuterArgumentValues(BlockScope currentScope, ReferenceBinding targetType, ASTNode invocationSite)
          Code responsible to generate the suitable code to supply values for the synthetic outer local variable arguments of a constructor invocation of a nested type.
 

Uses of BlockScope in org.eclipse.jdt.internal.compiler.flow
 

Methods in org.eclipse.jdt.internal.compiler.flow with parameters of type BlockScope
 void FlowContext.checkExceptionHandlers(TypeBinding[] raisedExceptions, ASTNode location, FlowInfo flowInfo, BlockScope scope)
           
 void FlowContext.checkExceptionHandlers(TypeBinding raisedException, ASTNode location, FlowInfo flowInfo, BlockScope scope)
           
 void FlowContext.checkExceptionHandlers(TypeBinding raisedException, ASTNode location, FlowInfo flowInfo, BlockScope scope, boolean isExceptionOnAutoClose)
           
 void InitializationFlowContext.checkInitializerExceptions(BlockScope currentScope, FlowContext initializerContext, FlowInfo flowInfo)
           
 void ExceptionHandlingFlowContext.complainIfUnusedExceptionHandlers(BlockScope scope, TryStatement tryStatement)
           
 void FinallyFlowContext.complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope)
          Given some contextual initialization info (derived from a try block or a catch block), this code will check that the subroutine context does not also initialize a final variable potentially set redundantly.
 void LoopingFlowContext.complainOnDeferredFinalChecks(BlockScope scope, FlowInfo flowInfo)
          Perform deferred checks relative to final variables duplicate initialization of lack of initialization.
 void LoopingFlowContext.complainOnDeferredNullChecks(BlockScope scope, FlowInfo callerFlowInfo)
          Perform deferred checks relative to the null status of local variables.
 boolean FlowContext.recordExitAgainstResource(BlockScope scope, FlowInfo flowInfo, FakedTrackingVariable trackingVar, ASTNode reference)
          Record that we found an early exit from a method while a resource is in scope.
 boolean LoopingFlowContext.recordExitAgainstResource(BlockScope scope, FlowInfo flowInfo, FakedTrackingVariable trackingVar, ASTNode reference)
          Record the fact that we see an early exit (in 'reference') while 'trackingVar' is in scope and may be unclosed.
 void FlowContext.recordNullityMismatch(BlockScope currentScope, Expression expression, TypeBinding providedType, TypeBinding expectedType, int nullStatus)
          Record that a nullity mismatch was detected against an annotated type reference.
 

Constructors in org.eclipse.jdt.internal.compiler.flow with parameters of type BlockScope
ExceptionHandlingFlowContext(FlowContext parent, ASTNode associatedNode, ReferenceBinding[] handledExceptions, FlowContext initializationParent, BlockScope scope, UnconditionalFlowInfo flowInfo)
           
ExceptionHandlingFlowContext(FlowContext parent, TryStatement tryStatement, ReferenceBinding[] handledExceptions, int[] exceptionToCatchBlockMap, FlowContext initializationParent, BlockScope scope, FlowInfo flowInfo)
           
InitializationFlowContext(FlowContext parent, ASTNode associatedNode, FlowInfo initsBeforeContext, FlowContext initializationParent, BlockScope scope)
           
LabelFlowContext(FlowContext parent, ASTNode associatedNode, char[] labelName, BranchLabel breakLabel, BlockScope scope)
           
 

Uses of BlockScope in org.eclipse.jdt.internal.compiler.lookup
 

Subclasses of BlockScope in org.eclipse.jdt.internal.compiler.lookup
 class MethodScope
          Specific block scope used for methods, constructors or clinits, representing its outermost blockscope.
 

Fields in org.eclipse.jdt.internal.compiler.lookup declared as BlockScope
 BlockScope LocalVariableBinding.declaringScope
           
 BlockScope InnerEmulationDependency.scope
           
 BlockScope[] BlockScope.shiftScopes
           
 

Methods in org.eclipse.jdt.internal.compiler.lookup that return BlockScope
static BlockScope Scope.typeAnnotationsResolutionScope(Scope scope)
           
 

Methods in org.eclipse.jdt.internal.compiler.lookup with parameters of type BlockScope
 void LocalTypeBinding.addInnerEmulationDependent(BlockScope dependentScope, boolean wasEnclosingInstanceSupplied)
           
 FieldBinding SourceTypeBinding.addSyntheticFieldForAssert(BlockScope blockScope)
           
 FieldBinding SourceTypeBinding.addSyntheticFieldForClassLiteral(TypeBinding targetType, BlockScope blockScope)
           
 void BlockScope.checkUnclosedCloseables(FlowInfo flowInfo, FlowContext flowContext, ASTNode location, BlockScope locationScope)
          At the end of a block check the closing-status of all tracked closeables that are declared in this block.
 ReferenceBinding InferenceContext18.inferFunctionalInterfaceParameterization(LambdaExpression lambda, BlockScope blockScope, ParameterizedTypeBinding targetTypeWithWildCards)
          18.5.3 Functional Interface Parameterization Inference
 

Constructors in org.eclipse.jdt.internal.compiler.lookup with parameters of type BlockScope
BlockScope(BlockScope parent)
           
BlockScope(BlockScope parent, boolean addToParentScope)
           
BlockScope(BlockScope parent, int variableCount)
           
InnerEmulationDependency(BlockScope scope, boolean wasEnclosingInstanceSupplied)
           
 

Overview  Package  Class   Use  Tree  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES