Uses of Class
org.eclipse.jdt.internal.compiler.ast.Expression

Packages that use Expression
org.eclipse.jdt.internal.compiler.ast   
org.eclipse.jdt.internal.compiler.codegen   
org.eclipse.jdt.internal.compiler.flow   
org.eclipse.jdt.internal.compiler.lookup   
org.eclipse.jdt.internal.compiler.parser   
org.eclipse.jdt.internal.compiler.problem   
 

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

Subclasses of Expression in org.eclipse.jdt.internal.compiler.ast
 class AllocationExpression
           
 class AND_AND_Expression
           
 class Annotation
          Annotation
 class ArrayAllocationExpression
           
 class ArrayInitializer
           
 class ArrayQualifiedTypeReference
           
 class ArrayReference
           
 class ArrayTypeReference
           
 class Assignment
           
 class BinaryExpression
           
 class CastExpression
           
 class CharLiteral
           
 class ClassLiteralAccess
           
 class CombinedBinaryExpression
          CombinedBinaryExpression is an implementation of BinaryExpression that specifically attempts to mitigate the issues raised by expressions which have a very deep leftmost branch.
 class CompoundAssignment
           
 class ConditionalExpression
           
 class DoubleLiteral
           
 class EqualExpression
           
 class ExtendedStringLiteral
           
 class FalseLiteral
           
 class FieldReference
           
 class FloatLiteral
           
 class InstanceOfExpression
           
 class IntLiteral
           
 class IntLiteralMinValue
           
 class JavadocAllocationExpression
           
 class JavadocArgumentExpression
           
 class JavadocArrayQualifiedTypeReference
           
 class JavadocArraySingleTypeReference
           
 class JavadocFieldReference
           
 class JavadocImplicitTypeReference
           
 class JavadocMessageSend
           
 class JavadocQualifiedTypeReference
           
 class JavadocSingleNameReference
           
 class JavadocSingleTypeReference
           
 class Literal
           
 class LongLiteral
           
 class LongLiteralMinValue
           
 class MagicLiteral
           
 class MarkerAnnotation
           
 class MessageSend
           
 class NameReference
           
 class NormalAnnotation
          Normal annotation node
 class NullLiteral
           
 class NumberLiteral
           
 class OperatorExpression
           
 class OR_OR_Expression
           
 class ParameterizedQualifiedTypeReference
          Syntactic representation of a reference to a generic type.
 class ParameterizedSingleTypeReference
          Syntactic representation of a reference to a generic type.
 class PostfixExpression
           
 class PrefixExpression
           
 class QualifiedAllocationExpression
          Variation on allocation, where can optionally be specified any of: - leading enclosing instance - trailing anonymous type - generic type arguments for generic constructor invocation
 class QualifiedNameReference
           
 class QualifiedSuperReference
           
 class QualifiedThisReference
           
 class QualifiedTypeReference
           
 class Reference
           
 class SingleMemberAnnotation
          SingleMemberAnnotation node
 class SingleNameReference
           
 class SingleTypeReference
           
 class StringLiteral
           
 class StringLiteralConcatenation
          Flatten string literal
 class SuperReference
           
 class ThisReference
           
 class TrueLiteral
           
 class TypeReference
           
 class UnaryExpression
           
 class UnionTypeReference
           
 class Wildcard
          Node to represent Wildcard
 

Fields in org.eclipse.jdt.internal.compiler.ast declared as Expression
 Expression[] MessageSend.arguments
           
 Expression[] ExplicitConstructorCall.arguments
           
 Expression[] AllocationExpression.arguments
           
 Expression AssertStatement.assertExpression
           
 Expression ForeachStatement.collection
           
 Expression WhileStatement.condition
           
 Expression IfStatement.condition
           
 Expression ForStatement.condition
           
 Expression DoStatement.condition
           
 Expression ConditionalExpression.condition
           
 Expression CaseStatement.constantExpression
           
 Expression AnnotationMethodDeclaration.defaultValue
           
 Expression[] ArrayAllocationExpression.dimensions
           
 Expression QualifiedAllocationExpression.enclosingInstance
           
 Expression ThrowStatement.exception
           
 Expression AssertStatement.exceptionArgument
           
 Expression UnaryExpression.expression
           
 Expression SynchronizedStatement.expression
           
 Expression SwitchStatement.expression
           
 Expression ReturnStatement.expression
           
 Expression InstanceOfExpression.expression
           
 Expression CastExpression.expression
           
 Expression Assignment.expression
           
 Expression[] ArrayInitializer.expressions
           
 Expression AbstractVariableDeclaration.initialization
           
 Expression BinaryExpression.left
           
 Expression Assignment.lhs
           
 Expression[] StringLiteralConcatenation.literals
           
 Expression SingleMemberAnnotation.memberValue
           
 Expression ArrayReference.position
           
 Expression ExplicitConstructorCall.qualification
           
 Expression MessageSend.receiver
           
 Expression FieldReference.receiver
           
 Expression ArrayReference.receiver
           
 Expression BinaryExpression.right
           
 Expression[] Javadoc.seeReferences
           
 Expression MemberValuePair.value
           
 Expression ConditionalExpression.valueIfFalse
           
 Expression ConditionalExpression.valueIfTrue
           
 

Methods in org.eclipse.jdt.internal.compiler.ast that return Expression
 Expression QualifiedAllocationExpression.enclosingInstance()
           
 Expression AllocationExpression.enclosingInstance()
           
 Expression CastExpression.innermostCastedExpression()
           
 Expression Expression.toTypeReference()
           
 

Methods in org.eclipse.jdt.internal.compiler.ast with parameters of type Expression
 boolean Expression.checkCastTypesCompatibility(Scope scope, TypeBinding castType, TypeBinding expressionType, Expression expression)
          Returns false if cast is not legal.
static boolean ASTNode.checkInvocationArguments(BlockScope scope, Expression receiver, TypeBinding receiverType, MethodBinding method, Expression[] arguments, TypeBinding[] argumentTypes, boolean argsContainCast, InvocationSite invocationSite)
           
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, 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.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
 void Statement.generateArguments(MethodBinding binding, Expression[] arguments, BlockScope currentScope, CodeStream codeStream)
          Generate invocation arguments, considering varargs methods
 void ThisReference.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)
           
abstract  void Reference.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 FieldReference.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 SingleNameReference.generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, MethodBinding writeAccessor, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired)
           
static Binding Expression.getDirectBinding(Expression someExpression)
           
protected  boolean Statement.isBoxingCompatible(TypeBinding expressionType, TypeBinding targetType, Expression expression, Scope scope)
           
protected static boolean Statement.isKnowDeadCodePattern(Expression expression)
          Answers true if the if is identified as a known coding pattern which should be tolerated by dead code analysis.
 

Constructors in org.eclipse.jdt.internal.compiler.ast with parameters of type Expression
AND_AND_Expression(Expression left, Expression right, int operator)
           
ArrayReference(Expression rec, Expression pos)
           
AssertStatement(Expression exceptionArgument, Expression assertExpression, int startPosition)
           
AssertStatement(Expression assertExpression, int startPosition)
           
Assignment(Expression lhs, Expression expression, int sourceEnd)
           
BinaryExpression(Expression left, Expression right, int operator)
           
CaseStatement(Expression constantExpression, int sourceEnd, int sourceStart)
           
CastExpression(Expression expression, TypeReference type)
           
CombinedBinaryExpression(Expression left, Expression right, int operator, int arity)
          Make a new CombinedBinaryExpression.
CompoundAssignment(Expression lhs, Expression expression, int operator, int sourceEnd)
           
ConditionalExpression(Expression condition, Expression valueIfTrue, Expression valueIfFalse)
           
DoStatement(Expression condition, Statement action, int sourceStart, int sourceEnd)
           
EqualExpression(Expression left, Expression right, int operator)
           
ForStatement(Statement[] initializations, Expression condition, Statement[] increments, Statement action, boolean neededScope, int s, int e)
           
IfStatement(Expression condition, Statement thenStatement, int sourceStart, int sourceEnd)
           
IfStatement(Expression condition, Statement thenStatement, Statement elseStatement, int sourceStart, int sourceEnd)
           
InstanceOfExpression(Expression expression, TypeReference type)
           
MemberValuePair(char[] token, int sourceStart, int sourceEnd, Expression value)
           
OR_OR_Expression(Expression left, Expression right, int operator)
           
PostfixExpression(Expression lhs, Expression expression, int operator, int pos)
           
PrefixExpression(Expression lhs, Expression expression, int operator, int pos)
          PrefixExpression constructor comment.
ReturnStatement(Expression expression, int sourceStart, int sourceEnd)
           
SynchronizedStatement(Expression expression, Block statement, int s, int e)
           
ThrowStatement(Expression exception, int sourceStart, int sourceEnd)
           
UnaryExpression(Expression expression, int operator)
           
WhileStatement(Expression condition, Statement action, int s, int e)
           
 

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

Methods in org.eclipse.jdt.internal.compiler.codegen with parameters of type Expression
 void CodeStream.generateReturnBytecode(Expression expression)
           
 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.
 

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

Methods in org.eclipse.jdt.internal.compiler.flow with parameters of type Expression
protected  void LoopingFlowContext.recordNullReference(LocalVariableBinding local, Expression expression, int status)
           
protected  void FlowContext.recordNullReference(LocalVariableBinding local, Expression expression, int status)
          Record a null reference for use by deferred checks.
protected  void FinallyFlowContext.recordNullReference(LocalVariableBinding local, Expression expression, int status)
           
 void LoopingFlowContext.recordUsingNullReference(Scope scope, LocalVariableBinding local, Expression reference, int checkType, FlowInfo flowInfo)
           
 void FlowContext.recordUsingNullReference(Scope scope, LocalVariableBinding local, Expression reference, int checkType, FlowInfo flowInfo)
          Record a null reference for use by deferred checks.
 void FinallyFlowContext.recordUsingNullReference(Scope scope, LocalVariableBinding local, Expression reference, int checkType, FlowInfo flowInfo)
           
 

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

Methods in org.eclipse.jdt.internal.compiler.lookup with parameters of type Expression
static Object ElementValuePair.getValue(Expression expression)
           
 

Constructors in org.eclipse.jdt.internal.compiler.lookup with parameters of type Expression
ElementValuePair(char[] name, Expression expression, MethodBinding binding)
           
 

Uses of Expression in org.eclipse.jdt.internal.compiler.parser
 

Fields in org.eclipse.jdt.internal.compiler.parser declared as Expression
protected  Expression[] Parser.expressionStack
           
 

Methods in org.eclipse.jdt.internal.compiler.parser that return Expression
protected  Expression Parser.getTypeReference(Expression exp)
           
 Expression Parser.parseExpression(char[] source, int offset, int length, CompilationUnitDeclaration unit)
           
 Expression Parser.parseMemberValue(char[] source, int offset, int length, CompilationUnitDeclaration unit)
           
 

Methods in org.eclipse.jdt.internal.compiler.parser with parameters of type Expression
protected  Expression Parser.getTypeReference(Expression exp)
           
protected  void Parser.pushOnExpressionStack(Expression expr)
           
protected  void Parser.updateSourcePosition(Expression exp)
           
 

Uses of Expression in org.eclipse.jdt.internal.compiler.problem
 

Methods in org.eclipse.jdt.internal.compiler.problem with parameters of type Expression
 void ProblemReporter.annotationValueMustBeAnnotation(TypeBinding annotationType, char[] name, Expression value, TypeBinding expectedType)
           
 void ProblemReporter.annotationValueMustBeArrayInitializer(TypeBinding annotationType, char[] name, Expression value)
           
 void ProblemReporter.annotationValueMustBeClassLiteral(TypeBinding annotationType, char[] name, Expression value)
           
 void ProblemReporter.annotationValueMustBeConstant(TypeBinding annotationType, char[] name, Expression value, boolean isEnum)
           
 void ProblemReporter.autoboxing(Expression expression, TypeBinding originalType, TypeBinding convertedType)
           
 void ProblemReporter.cannotAllocateVoidArray(Expression expression)
           
 void ProblemReporter.caseExpressionMustBeConstant(Expression expression)
           
 void ProblemReporter.comparingIdenticalExpressions(Expression comparison)
           
 void ProblemReporter.enumConstantsCannotBeSurroundedByParenthesis(Expression expression)
           
 void ProblemReporter.expressionShouldBeAVariable(Expression expression)
           
 void ProblemReporter.incorrectSwitchType(Expression expression, TypeBinding testType)
           
 void ProblemReporter.invalidEnclosingType(Expression expression, TypeBinding type, ReferenceBinding enclosingType)
           
 void ProblemReporter.invalidExpressionAsStatement(Expression expression)
           
 void ProblemReporter.invalidNullToSynchronize(Expression expression)
           
 void ProblemReporter.invalidTypeForCollection(Expression expression)
           
 void ProblemReporter.invalidTypeForCollectionTarget14(Expression expression)
           
 void ProblemReporter.invalidTypeToSynchronize(Expression expression, TypeBinding type)
           
 void ProblemReporter.invalidUnaryExpression(Expression expression)
           
 void ProblemReporter.invalidUsageOfForeachStatements(LocalDeclaration elementVariable, Expression collection)
           
 void ProblemReporter.missingSemiColon(Expression expression)
           
 void ProblemReporter.notCompatibleTypesErrorInForeach(Expression expression, TypeBinding leftType, TypeBinding rightType)
           
 void ProblemReporter.signalNoImplicitStringConversionForCharArrayExpression(Expression expression)
           
 void ProblemReporter.unhandledWarningToken(Expression token)
           
 void ProblemReporter.unnecessaryEnclosingInstanceSpecification(Expression expression, ReferenceBinding targetType)
           
 void ProblemReporter.unsafeTypeConversion(Expression expression, TypeBinding expressionType, TypeBinding expectedType)
           
 void ProblemReporter.unusedWarningToken(Expression token)
           
 



Copyright © 2012. All Rights Reserved.