Uses of Class
org.ek9lang.antlr.EK9Parser.ExpressionContext

Packages that use EK9Parser.ExpressionContext

Package	Description
org.ek9lang.antlr
org.ek9lang.compiler.phase1	E - Initial Symbol definition by traversing the 'ANTLR' - 'AST'.
org.ek9lang.compiler.phase3	G - Full Symbol Resolution can now take place.
org.ek9lang.compiler.phase5	I - PRE Intermediate Representation generation checks.
org.ek9lang.compiler.phase5.callgraph	Call graph infrastructure for EK9 compiler static analysis.
org.ek9lang.compiler.phase5.flow
org.ek9lang.compiler.phase7.generator
org.ek9lang.compiler.phase7.support
org.ek9lang.compiler.repair	THE automatic source repairs - one engine for every door (ek9 -ff, ek9_format, the MCP editors, ek9_write_file, ek9_edit_file, ek9_compile).
org.ek9lang.compiler.repair.expressions	THE string-expression primitives the selection- and cursor-driven editors share (was the one grab-bag StringExpressionClassifier): the + chain (IsAddExpression, WholeAddChain), the single String literal (StringLiteralOf, IsSingleStringLiteral), and the finders - by selection (ExpressionSpanningSelection) or by cursor (ExpressionAtCursor, ConcatAtCursor, StringLiteralAtCursor, TextMethodAtCursor), all over SmallestExpression.
org.ek9lang.compiler.support	Contains critical general components used in the Ek9Compiler listeners.
org.ek9lang.compiler.support.retention
org.ek9lang.compiler.support.selfreference	THE reading of a statement that stores the object in one of its OWN properties - me: this, next := this, this.owner :=? this - a property of the object's own type that refers back to it (StoredProperty).
org.ek9lang.compiler.support.sharing
org.ek9lang.compiler.symbolic

Uses of EK9Parser.ExpressionContext in org.ek9lang.antlr

Fields in org.ek9lang.antlr declared as EK9Parser.ExpressionContext

Modifier and Type	Field	Description
EK9Parser.ExpressionContext	EK9Parser.ExpressionContext.control
EK9Parser.ExpressionContext	EK9Parser.PreFlowAndControlContext.control
EK9Parser.ExpressionContext	EK9Parser.WhileStatementExpressionContext.control
EK9Parser.ExpressionContext	EK9Parser.ExpressionContext.left
EK9Parser.ExpressionContext	EK9Parser.ExpressionContext.rangeFrom
EK9Parser.ExpressionContext	EK9Parser.ExpressionContext.right

Methods in org.ek9lang.antlr that return EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.ExpressionContext	EK9Parser.AssertDoesNotThrowExpressionContext.expression()
EK9Parser.ExpressionContext	EK9Parser.AssertPanicExpressionContext.expression()
EK9Parser.ExpressionContext	EK9Parser.AssertStatementContext.expression()
EK9Parser.ExpressionContext	EK9Parser.AssertThrowsExpressionContext.expression()
EK9Parser.ExpressionContext	EK9Parser.AssignmentExpressionContext.expression()
EK9Parser.ExpressionContext	EK9Parser.CaseExpressionContext.expression()
EK9Parser.ExpressionContext	EK9Parser.ExcludedControlFlowStatementContext.expression()
EK9Parser.ExpressionContext	EK9Parser.ExcludedListComprehensionContext.expression(int i)
final EK9Parser.ExpressionContext	EK9Parser.expression()
EK9Parser.ExpressionContext	EK9Parser.ExpressionContext.expression(int i)
EK9Parser.ExpressionContext	EK9Parser.ExpressionParamContext.expression()
EK9Parser.ExpressionContext	EK9Parser.ForLoopContext.expression()
EK9Parser.ExpressionContext	EK9Parser.InitValuePairContext.expression(int i)
EK9Parser.ExpressionContext	EK9Parser.ListContext.expression(int i)
EK9Parser.ExpressionContext	EK9Parser.PreFlowAndControlContext.expression()
EK9Parser.ExpressionContext	EK9Parser.PrimaryContext.expression()
EK9Parser.ExpressionContext	EK9Parser.RangeContext.expression(int i)
EK9Parser.ExpressionContext	EK9Parser.RequireStatementContext.expression()
EK9Parser.ExpressionContext	EK9Parser.StreamCatContext.expression(int i)
EK9Parser.ExpressionContext	EK9Parser.StringPartContext.expression()
EK9Parser.ExpressionContext	EK9Parser.TernaryPartContext.expression()
EK9Parser.ExpressionContext	EK9Parser.WhileStatementExpressionContext.expression()

Methods in org.ek9lang.antlr that return types with arguments of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
List<EK9Parser.ExpressionContext>	EK9Parser.ExcludedListComprehensionContext.expression()
List<EK9Parser.ExpressionContext>	EK9Parser.ExpressionContext.expression()
List<EK9Parser.ExpressionContext>	EK9Parser.InitValuePairContext.expression()
List<EK9Parser.ExpressionContext>	EK9Parser.ListContext.expression()
List<EK9Parser.ExpressionContext>	EK9Parser.RangeContext.expression()
List<EK9Parser.ExpressionContext>	EK9Parser.StreamCatContext.expression()

Methods in org.ek9lang.antlr with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
void	EK9BaseListener.enterExpression(EK9Parser.ExpressionContext ctx)	Enter a parse tree produced by EK9Parser.expression().
void	EK9Listener.enterExpression(EK9Parser.ExpressionContext ctx)	Enter a parse tree produced by EK9Parser.expression().
void	EK9BaseListener.exitExpression(EK9Parser.ExpressionContext ctx)	Exit a parse tree produced by EK9Parser.expression().
void	EK9Listener.exitExpression(EK9Parser.ExpressionContext ctx)	Exit a parse tree produced by EK9Parser.expression().
T	EK9BaseVisitor.visitExpression(EK9Parser.ExpressionContext ctx)	Visit a parse tree produced by EK9Parser.expression().
T	EK9Visitor.visitExpression(EK9Parser.ExpressionContext ctx)	Visit a parse tree produced by EK9Parser.expression().

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.phase1

Classes in org.ek9lang.compiler.phase1 that implement interfaces with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Class	Description
(package private) final class	BinaryOperatorOf	THE operator token of a binary expression (IsBinaryExpression): the coalescing token, the comparison coalescing token, the op label, or - the 'in' alternative has no 'op' label - the in token.
(package private) final class	CoalescingOperandParenthesesOrError	E08269 (Steve, D6, 2026-10-07): a coalescing operator - the Elvis ?: and the comparison coalescing family <? >? - may not be an UNPARENTHESISED operand of a DIFFERENT binary operator, nor take one as an operand.
(package private) final class	DoubleNegationOrError	E08274 (Steve, 2026-10-08, C1, Q8, Q9): a negation is never applied to a negation - not not b, ~~b, - -x, not ~b, - ~x, ~ -x and the same PARENTHESISED, not (not b), ~(~b), -(-x), -(not b), are compile errors.
(package private) final class	IsBinaryExpression	THE "is this a binary expression?" of the phase-1 operand rules: any expression alternative with both a left and a right operand.
(package private) final class	IsNegation	THE "is this a negation applied to one operand?" - word not b, ~b or unary -x.
(package private) final class	IsPrefixExpression	THE "is this a prefix expression?" of the phase-1 operand rules (BinaryExpressions): the operator comes first and there is one operand (PrefixOperandOf), and the operator is one of BinaryExpressions.PREFIX_OPERATORS - so not word not (IsWordNot).
(package private) final class	IsSignedLiteral	THE "is this a literal with its sign folded in?" - -5, -2.5, -10#GBP: not a negation - it calls nothing - but SPELT with one, so E08274 counts it when a negation is applied to it (- -5 is 5).
(package private) final class	IsWordNot	THE "is this word not applied to an operand?" - not b.
(package private) final class	NegatedOperandOf	THE operand a negation (IsNegation) is applied to, looking through parentheses (Q8): in not (not b) and -(-x) the operand of the outer negation is the inner one.
(package private) final class	NegationApplyingTo	THE negation that an expression is the operand of, looking through parentheses (not b is the operand of the ~ in ~((not b))); null when it is not the operand of a negation.
(package private) final class	NotABooleanLiteralOrError	Typically used in control expressions to check developer is not doing a while(true).
(package private) final class	NotOperandParenthesesOrError	E08273 (Steve, 2026-10-07, P5; 2026-10-08, P6): word not is never an UNPARENTHESISED operand of another operator, except and, xor and or - so neither of any other binary operator (P5) nor of a prefix operator (P6: ~not b, $ not b, #? not b, ...).
(package private) final class	PrefixOperandOf	THE single operand of a prefix expression (IsPrefixExpression) or of word not (IsWordNot), as written - parentheses included (NegatedOperandOf looks through them).
(package private) final class	RemovedCoalescingOperatorOrError	E01095 (Steve, 2026-10-21, sameness wave 2, section 4.9 b1): the comparison coalescing operators <=? and >=? were removed.

Methods in org.ek9lang.compiler.phase1 that return EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.ExpressionContext	NegatedOperandOf.apply(EK9Parser.ExpressionContext negation)
EK9Parser.ExpressionContext	NegationApplyingTo.apply(EK9Parser.ExpressionContext ctx)
EK9Parser.ExpressionContext	PrefixOperandOf.apply(EK9Parser.ExpressionContext ctx)

Methods in org.ek9lang.compiler.phase1 with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
void	CoalescingOperandParenthesesOrError.accept(EK9Parser.ExpressionContext ctx)
void	DoubleNegationOrError.accept(EK9Parser.ExpressionContext ctx)
void	NotABooleanLiteralOrError.accept(EK9Parser.ExpressionContext ctx)
void	NotOperandParenthesesOrError.accept(EK9Parser.ExpressionContext ctx)
void	RemovedCoalescingOperatorOrError.accept(EK9Parser.ExpressionContext ctx)
org.antlr.v4.runtime.Token	BinaryOperatorOf.apply(EK9Parser.ExpressionContext ctx)
EK9Parser.ExpressionContext	NegatedOperandOf.apply(EK9Parser.ExpressionContext negation)
EK9Parser.ExpressionContext	NegationApplyingTo.apply(EK9Parser.ExpressionContext ctx)
EK9Parser.ExpressionContext	PrefixOperandOf.apply(EK9Parser.ExpressionContext ctx)
void	DefinitionListener.enterExpression(EK9Parser.ExpressionContext ctx)
boolean	IsBinaryExpression.test(EK9Parser.ExpressionContext ctx)
boolean	IsNegation.test(EK9Parser.ExpressionContext ctx)
boolean	IsPrefixExpression.test(EK9Parser.ExpressionContext ctx)
boolean	IsSignedLiteral.test(EK9Parser.ExpressionContext ctx)
boolean	IsWordNot.test(EK9Parser.ExpressionContext ctx)

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.phase3

Classes in org.ek9lang.compiler.phase3 that implement interfaces with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Class	Description
(package private) final class	AccessLeftAndRightOrError	Just gets the left and right hand side of values in an expression.
(package private) final class	AccessTernaryExpressionsOrError	Just gets both of the ternary expression parts (not the control).
(package private) final class	ControlIsBooleanOrError	Checks that an expression used as a control (if/else if, while, do/while, a ternary) is a condition: a Boolean, or a type that promotes to one with '#^'.
(package private) final class	ExpressionIsBooleanResultOrError	Checks that an expression is a condition - a Boolean, or a type that promotes to one with '#^' (IsCondition, THE rule for every condition) - emitting ONLY_COMPATIBLE_WITH_BOOLEAN otherwise.
(package private) final class	ExpressionOrError	Ensures that 'expression' is now resolved and 'typed' or a not resolved error.
(package private) final class	MapOperatorText	Returns the appropriate operator text symbol for the expression.
(package private) final class	MethodSymbolSearchForExpression	Create a MethodSearch symbol for an operation that could have a single expression or two expressions.

Methods in org.ek9lang.compiler.phase3 with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
void	ControlIsBooleanOrError.accept(EK9Parser.ExpressionContext ctx)
void	ExpressionIsBooleanResultOrError.accept(EK9Parser.ExpressionContext expression, String statementWord)
void	ExpressionOrError.accept(EK9Parser.ExpressionContext ctx)
(package private) void	InjectedSetCheckOrError.accept(EK9Parser.ExpressionContext ctx)	injected?, injected ?: other.
Optional<ExprLeftAndRightData>	AccessLeftAndRightOrError.apply(EK9Parser.ExpressionContext ctx)
Optional<ExprLeftAndRightData>	AccessTernaryExpressionsOrError.apply(EK9Parser.ExpressionContext ctx)
String	MapOperatorText.apply(EK9Parser.ExpressionContext ctx)
MethodSymbolSearch	MethodSymbolSearchForExpression.apply(EK9Parser.ExpressionContext ctx)
void	ExpressionsListener.exitExpression(EK9Parser.ExpressionContext ctx)
(package private) ISymbol	RangeOrError.inRangeOf(EK9Parser.ExpressionContext ctx)	The range of x in a ... b: the start is rangeFrom and the end is right of the comparison alternative (the range form shares that level, so its end binds like any comparison operand - PRECEDENCE (4), Steve 2026-10-07).

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.phase5

Classes in org.ek9lang.compiler.phase5 that implement interfaces with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Class	Description
(package private) final class	CompoundConditionOrError	Detects tautological and contradictory compound conditions using range algebra (E08086/E08087).
(package private) final class	ConstantArithmeticOrError	Detects arithmetic expressions that always produce a constant result (E08083).
(package private) final class	ConstantCoalescingOrError	Detects coalescing expressions whose result is predetermined (E08094).
(package private) final class	ConstantComparisonOrError	Detects comparisons where both operands are literals (E08082).
(package private) final class	FlowConditionOrError	Detects conditions that are always true or always false based on data flow analysis (E08086/E08087).
(package private) final class	FormOfBooleanLogic	Predicate to determine if an expression is a Boolean logical operator (and/or) with Boolean type operands.
(package private) class	FormOfComparator	When looking to calculate complexity of methods/functions it is important to work out if parts of an expression are in some way conditional.
(package private) final class	LogicalTautologyOrError	Detects logical tautologies and contradictions (E08085).
(package private) final class	MagicLiteralInComparisonOrError	Detects bare literals used as operands in comparison, relational, matching, and range expressions (E11064).
(package private) final class	PreferStringInterpolationOrError	Detects string concatenation chains with 3 or more parts and recommends string interpolation instead (E11068).
(package private) final class	RedundantBooleanComparisonOrError	Detects comparisons of a Boolean expression with a Boolean literal (E08084).
(package private) final class	RedundantEmptyCheckOrError	Detects empty checks that are always true or always false based on data flow analysis (E08092/E08093).
(package private) final class	RedundantIsSetCheckOrError	Detects isSet checks that are always true or always false based on data flow analysis (E08088/E08089).
(package private) final class	ReturnSourceClassifier	THE return-source classifier: which ReturnSourceKind one source of a callable's returning variable is (with IsFreshValueExpression, which decides ReturnSourceKind.NEW).
(package private) final class	ReturnSourceOrigins	What a source of a callable's returning variable may BE, in terms of the callable's own inputs - THE transitive reading of D61 (Steve, 2026-10-21: follow the inner call back): the names of the incoming parameters it may be (or a view of) and ReturnSourceOrigins.RECEIVER_ORIGIN when it may be the receiver's interior.
(package private) final class	SelfComparisonOrError	Detects self-comparison expressions where both sides resolve to the same symbol (E08081).

Methods in org.ek9lang.compiler.phase5 that return EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.ExpressionContext	MutatedOnlyVariables.Deferred.initialiser()	Returns the value of the initialiser record component.

Methods in org.ek9lang.compiler.phase5 that return types with arguments of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
(package private) ConstructSafeAccessMarker<EK9Parser.ExpressionContext>	ConstructSafeAccessMarkers.forTernary()	A ternary: its control may make the first part safe.
List<EK9Parser.ExpressionContext>	MutatedOnlyVariables.ReturningCallable.sources()	Returns the value of the sources record component.

Methods in org.ek9lang.compiler.phase5 with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
void	CompoundConditionOrError.accept(EK9Parser.ExpressionContext ctx)
void	ConstantArithmeticOrError.accept(EK9Parser.ExpressionContext ctx)
void	ConstantCoalescingOrError.accept(EK9Parser.ExpressionContext ctx)
void	ConstantComparisonOrError.accept(EK9Parser.ExpressionContext ctx)
void	FlowConditionOrError.accept(EK9Parser.ExpressionContext ctx)
void	LogicalTautologyOrError.accept(EK9Parser.ExpressionContext ctx)
void	MagicLiteralInComparisonOrError.accept(EK9Parser.ExpressionContext ctx)
void	PreferStringInterpolationOrError.accept(EK9Parser.ExpressionContext ctx)
void	RedundantBooleanComparisonOrError.accept(EK9Parser.ExpressionContext ctx)
void	RedundantEmptyCheckOrError.accept(EK9Parser.ExpressionContext ctx)
void	RedundantIsSetCheckOrError.accept(EK9Parser.ExpressionContext ctx)
void	SelfComparisonOrError.accept(EK9Parser.ExpressionContext ctx)
(package private) void	RedundantIsSetCheckOrError.acceptIdentifierCondition(EK9Parser.ExpressionContext expr)	A bare identifier that is the condition (or a conjunct of the condition) of an if / else if headed by a Boolean truth guard on that very identifier: if ok <- check() then ok.
ReturnSourceKind	ReturnSourceClassifier.apply(MutatedOnlyVariables.ReturningCallable returning, EK9Parser.ExpressionContext source)	Classify one source of a callable's returning variable.
Set<String>	ReturnSourceOrigins.apply(MutatedOnlyVariables.ReturningCallable returning, EK9Parser.ExpressionContext source)	The origins of one source.
(package private) void	ObligationCensus.checkArithmetic(EK9Parser.ExpressionContext ctx)	Count a division / modulo / remainder as a DIV_BY_ZERO obligation, discharged when the divisor is provably non-zero from the narrowed flow state.
void	PreIRListener.enterExpression(EK9Parser.ExpressionContext ctx)
(package private) void	ExpressionComplexityCounter.exitCoalescing(EK9Parser.ExpressionContext ctx)	Exit a coalescing expression - calculate weighted cost and add to total.
void	PreIRListener.exitExpression(EK9Parser.ExpressionContext ctx)
void	RetractedComparatorUseOrError.exitExpression(EK9Parser.ExpressionContext ctx)
(package private) boolean	CompileTimeKnownText.isKnown(EK9Parser.ExpressionContext expression, org.antlr.v4.runtime.tree.ParseTree region)	Is expression, evaluated anywhere within region, made only from source text.
(package private) void	SafeAccessConjuncts.markProven(EK9Parser.ExpressionContext condition, IScope scopeMadeSafe)	Mark everything the top-level conjuncts of condition prove as safe in scopeMadeSafe.
boolean	FormOfBooleanLogic.test(EK9Parser.ExpressionContext ctx)
boolean	FormOfComparator.test(EK9Parser.ExpressionContext ctx)

Constructors in org.ek9lang.compiler.phase5 with parameters of type EK9Parser.ExpressionContext

Modifier	Constructor	Description
(package private)	Deferred(ParsedModule parsedModule, ISymbol variable, EK9Parser.ExpressionContext initialiser)	Creates an instance of a Deferred record class.

Constructor parameters in org.ek9lang.compiler.phase5 with type arguments of type EK9Parser.ExpressionContext

Modifier	Constructor	Description
(package private)	ReturningCallable(ParsedModule parsedModule, ScopedSymbol callable, List<EK9Parser.ExpressionContext> sources)	Creates an instance of a ReturningCallable record class.

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.phase5.callgraph

Methods in org.ek9lang.compiler.phase5.callgraph with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
void	CallGraphCollector.enterExpression(EK9Parser.ExpressionContext ctx)

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.phase5.flow

Methods in org.ek9lang.compiler.phase5.flow with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
CollectionStateValue	ConstructorStateExtractor.extractFromExpression(EK9Parser.ExpressionContext expr)	Extract a CollectionStateValue from an expression if it is a collection/container constructor or literal.
ConstantValue	LiteralExtractor.extractFromExpression(EK9Parser.ExpressionContext expr)	Extract a constant value from an expression context.
Integer	TrackedValues.integerOf(EK9Parser.ExpressionContext expr)	The integer the expression is known to hold - a literal, else a tracked integer constant - or null.
AbstractValue	TrackedValues.knownValueOf(EK9Parser.ExpressionContext expr)	The value of the expression: its literal, else its symbol's tracked value but only if that is known, else TOP.
AbstractValue	TrackedValues.trackedValueOf(EK9Parser.ExpressionContext expr)	The value of the expression: its literal, else its symbol's tracked value as it is, else TOP.

Constructor parameters in org.ek9lang.compiler.phase5.flow with type arguments of type EK9Parser.ExpressionContext

Modifier	Constructor	Description
	ConstructorStateExtractor(SymbolsAndScopes symbolsAndScopes, Ek9Types ek9Types, Predicate<EK9Parser.ExpressionContext> knownSet)	Create the extractor.

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.phase7.generator

Methods in org.ek9lang.compiler.phase7.generator with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
protected AbstractAssertExprGenerator.AssertBodyResult	AbstractAssertExprGenerator.buildAssertionBody(EK9Parser.ExpressionContext exprCtx, DebugInfo debugInfo)	Build the assertion body with proper scope management.
(package private) ConditionStatementPrelude.Evaluated	ConditionStatementPrelude.evaluate(org.antlr.v4.runtime.tree.ParseTree statement, org.antlr.v4.runtime.Token keyword, EK9Parser.ExpressionContext expression, boolean assertWindow)	Evaluate the condition of the statement.
GuardedConditionEvaluator.ConditionEvaluation	GuardedConditionEvaluator.evaluate(EK9Parser.ExpressionContext conditionExpr, EK9Parser.PreFlowStatementContext preFlowStmt, VariableDetails conditionResult, String scopeId, DebugInfo debugInfo)	Evaluates a condition expression that may have guard variables.
(package private) List<IRInstr>	BinaryOperationGenerator.processOperandExpression(EK9Parser.ExpressionContext operandExpr, VariableDetails operandDetails)	Process operand expression using exprGenerator from generators struct.
(package private) List<IRInstr>	UnaryOperationGenerator.processOperandExpression(EK9Parser.ExpressionContext operandExpr, VariableDetails operandDetails)	Process operand expression using exprGenerator from generators struct.
(package private) String	IterationSourceLowering.sourceValue(EK9Parser.ExpressionContext sourceCtx, IAggregateSymbol sourceType, DebugInfo debugInfo, List<IRInstr> instructions)	The source's value in a fresh managed temp: the enumeration instance (IterationSourceLowering.enumInstanceForIteration(IAggregateSymbol, DebugInfo, List)) or the evaluated expression.

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.phase7.support

Methods in org.ek9lang.compiler.phase7.support that return EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.ExpressionContext	ExprProcessingDetails.ctx()	Returns the value of the ctx record component.

Methods in org.ek9lang.compiler.phase7.support with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
String	BooleanCondition.asBoolean(EK9Parser.ExpressionContext condition, String conditionVariable, DebugInfo debugInfo, List<IRInstr> instructions)	The Boolean holding the condition: the evaluated variable itself, or - for a type that promotes to Boolean - the result of its _promote(), appended to instructions (scope-local, released with the scope).
String	BooleanCondition.toPrimitive(EK9Parser.ExpressionContext condition, String conditionVariable, DebugInfo debugInfo, List<IRInstr> instructions)	The primitive boolean a branch reads: the condition as a Boolean (BooleanCondition.asBoolean(EK9Parser.ExpressionContext, String, DebugInfo, List)), then _true().

Constructors in org.ek9lang.compiler.phase7.support with parameters of type EK9Parser.ExpressionContext

Modifier	Constructor	Description
	ExprProcessingDetails(EK9Parser.ExpressionContext ctx, VariableDetails variableDetails)	Creates an instance of a ExprProcessingDetails record class.

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.repair

Methods in org.ek9lang.compiler.repair that return EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.ExpressionContext	ConcatChainRenderer.ChainRendering.offender()	Returns the value of the offender record component.

Methods in org.ek9lang.compiler.repair with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
(package private) ConcatChainRenderer.ChainRendering	ConcatChainRenderer.apply(EK9Parser.ExpressionContext chain, String sourceText, Function<EK9Parser.ExpressionContext, String> typeProblem)	The chain rendered, or the first operand refused - see the class javadoc.
(package private) static ConcatChainRenderer.ChainRendering	ConcatChainRenderer.ChainRendering.refused(String kind, String reason, EK9Parser.ExpressionContext offender, String suggestedRewrite)

Method parameters in org.ek9lang.compiler.repair with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
(package private) ConcatChainRenderer.ChainRendering	ConcatChainRenderer.apply(EK9Parser.ExpressionContext chain, String sourceText, Function<EK9Parser.ExpressionContext, String> typeProblem)	The chain rendered, or the first operand refused - see the class javadoc.

Constructors in org.ek9lang.compiler.repair with parameters of type EK9Parser.ExpressionContext

Modifier	Constructor	Description
(package private)	ChainRendering(String rendered, int operandCount, int substitutionCount, String conflictKind, String reason, EK9Parser.ExpressionContext offender, String suggestedRewrite)	Creates an instance of a ChainRendering record class.

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.repair.expressions

Classes in org.ek9lang.compiler.repair.expressions that implement interfaces with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Class	Description
final class	IsAddExpression	Is this expression's outer operator a binary + with two operand expressions? THE "this is a concat chain" gate of the string-expression editors (was StringExpressionClassifier.isAddExpression).
final class	IsSingleStringLiteral	Is this expression a single string-literal primary - double-quoted or backtick interpolation? The rewriter's idempotency check and the extractor's admission gate (was StringExpressionClassifier.isSingleStringLiteral).
(package private) final class	SmallestExpression	THE walk every string-expression finder shares: the smallest EK9Parser.ExpressionContext under a root that passes a test, or null.
(package private) final class	SmallestExpression	THE walk every string-expression finder shares: the smallest EK9Parser.ExpressionContext under a root that passes a test, or null.
final class	StringLiteralOf	THE stringLit of an expression that is a single string literal (double-quoted or backtick), or null when the expression is not one (was StringExpressionClassifier.extractStringLit).
final class	TokenRangeOf	THE token-range bounds of an expression as 1-based (line, col) coordinates, [startLine, startCol, endLine, endCol], inclusive on both ends - the shape MCP-tool selection parameters expect; null when the expression has missing token data (was StringExpressionClassifier.tokenRange).
final class	WholeAddChain	THE whole + chain a + expression is part of - use it, never a private climb: + groups left to right, so "Hello " + name + "!" is ("Hello " + name) + "!", and the chain is the outermost + reached by climbing while the parent is still one.

Methods in org.ek9lang.compiler.repair.expressions that return EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.ExpressionContext	ConcatAtCursor.apply(org.antlr.v4.runtime.tree.ParseTree root, int line, int col)	The whole concat chain round the cursor, or null.
EK9Parser.ExpressionContext	ExpressionAtCursor.apply(org.antlr.v4.runtime.tree.ParseTree root, int line, int col)	The smallest expression containing the cursor, or null.
EK9Parser.ExpressionContext	ExpressionSpanningSelection.apply(org.antlr.v4.runtime.tree.ParseTree root, int startLine, int startCol, int endLine, int endCol)	The smallest expression spanning exactly the selection, or null.
EK9Parser.ExpressionContext	SmallestExpression.apply(org.antlr.v4.runtime.tree.ParseTree root, Predicate<EK9Parser.ExpressionContext> matches)
EK9Parser.ExpressionContext	StringLiteralAtCursor.apply(org.antlr.v4.runtime.tree.ParseTree root, int line, int col)	The smallest single string literal round the cursor, or null.
EK9Parser.ExpressionContext	WholeAddChain.apply(EK9Parser.ExpressionContext add)

Methods in org.ek9lang.compiler.repair.expressions with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.StringLitContext	StringLiteralOf.apply(EK9Parser.ExpressionContext expr)
int[]	TokenRangeOf.apply(EK9Parser.ExpressionContext expr)
EK9Parser.ExpressionContext	WholeAddChain.apply(EK9Parser.ExpressionContext add)
boolean	IsAddExpression.test(EK9Parser.ExpressionContext expr)
boolean	IsSingleStringLiteral.test(EK9Parser.ExpressionContext expr)

Method parameters in org.ek9lang.compiler.repair.expressions with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.ExpressionContext	SmallestExpression.apply(org.antlr.v4.runtime.tree.ParseTree root, Predicate<EK9Parser.ExpressionContext> matches)

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.support

Classes in org.ek9lang.compiler.support that implement interfaces with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Class	Description
final class	ExtractLiteralOperand	Extracts the literal an expression resolves to, or null if it is not a (possibly negated) literal.
final class	IsConditionExpression	THE rule for "is this expression a whole CONDITION": the control of an if/else if/switch head, of a while, or the expression of a require or assert.
final class	IsFreshValueExpression	THE "fresh value" predicate: true iff an expression evaluates to a NEW object - one nothing else holds a reference to.
final class	WithoutParentheses	THE expression inside any number of enclosing parentheses: base for ((base)).

Methods in org.ek9lang.compiler.support that return EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.ExpressionContext	WithoutParentheses.apply(EK9Parser.ExpressionContext expression)
EK9Parser.ExpressionContext	ReferenceAssignment.source()	Returns the value of the source record component.

Methods in org.ek9lang.compiler.support with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.LiteralContext	ExtractLiteralOperand.apply(EK9Parser.ExpressionContext expr)
EK9Parser.ExpressionContext	WithoutParentheses.apply(EK9Parser.ExpressionContext expression)
CallSymbol	OperationFactory.newOperatorCall(String operator, EK9Parser.ExpressionContext ctx, IScope scope)	Create a CallSymbol for an operator in an expression.
CallSymbol	SymbolFactory.newOperatorCall(String operator, EK9Parser.ExpressionContext ctx, IScope scope)	Create a new CallSymbol for an operator in an expression.
boolean	IsConditionExpression.test(EK9Parser.ExpressionContext ctx)	True if the expression, as a whole, is the condition of a control statement, a require or an assert.
boolean	IsFreshValueExpression.test(EK9Parser.ExpressionContext exprCtx)

Constructors in org.ek9lang.compiler.support with parameters of type EK9Parser.ExpressionContext

Modifier	Constructor	Description
	ReferenceAssignment(ISymbol target, EK9Parser.ExpressionContext source)	Creates an instance of a ReferenceAssignment record class.

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.support.retention

Classes in org.ek9lang.compiler.support.retention that implement interfaces with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Class	Description
final class	CalleeOfExpression	THE method, operator or function an expression CALLS when the whole expression is that call - a.get(k), first(), a + b, (a.get(k)) - so its value is whatever the call handed back.

Methods in org.ek9lang.compiler.support.retention with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
Optional<ScopedSymbol>	CalleeOfExpression.apply(EK9Parser.ExpressionContext expression, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	The callee of the expression.

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.support.selfreference

Classes in org.ek9lang.compiler.support.selfreference that implement interfaces with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Class	Description
(package private) final class	IsThis	The expression is this itself.

Methods in org.ek9lang.compiler.support.selfreference with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
boolean	IsThis.test(EK9Parser.ExpressionContext expression)

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.support.sharing

Classes in org.ek9lang.compiler.support.sharing that implement interfaces with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Class	Description
final class	IsCoalescingOperator	THE coalescing test: ?:, <?, >? (??, <=?/>=? keep their grammar tokens only so phase 1 can report E01096/E01095 - they never reach here).
(package private) final class	IsExistingNamedObject	A variable (never a constant: each read of one is a copy) or this/super.
final class	MayBeExistingObject	May the value of this expression BE an object that exists already - rather than a fresh one: a variable (not a constant, which is read as a copy), this/super, a call whose RETAINS says its result may be its receiver's interior or an argument (MayAlias), or a coalescing operator's result or a ternary's when EITHER operand may be (the result is one of them: the same route ObjectSharing follows for the operand itself).
final class	MayBeExistingObjectByShape	Is the expression, looking through parentheses, of a SHAPE whose value may be an object that already exists - a variable, this/super, a call, or a coalescing operator or ternary (whose result IS one of its operands) - so only MayBeExistingObject, once phase 5 has derived the RETAINS of the program's own callables, can say whether it is.
(package private) final class	Outermost	((base)) is base: climb the parentheses.
(package private) final class	ReachedByExpression	The objects an expression given to a call (or written into an object, or iterated) gives it: a name, this, what a call that makes one, a list, a Dict, a coalescing operator or a ternary holds; any other expression builds a new value from its operands.
final class	ReachOfIteration	What a for loop over iterated can reach (D66, the same reading as ReachOfCall gives a call): the value iterated - a name, this, or something no name is given to - and what it is made from.
(package private) final class	RetainedBy	THE retention walk of ObjectSharing (D61): the object an expression evaluates to (or contains) - what keeps it? The variable it is stored in, a container it is added to or put in a literal of, a call or constructor that may keep its argument, a for loop's variable, a stream's holders, or the returning variable of a construct whose value is assigned - ObjectSharing.Kind.SHARED with a nameable holder, else ObjectSharing.Kind.ESCAPES.

Methods in org.ek9lang.compiler.support.sharing that return EK9Parser.ExpressionContext

Modifier and Type	Method	Description
EK9Parser.ExpressionContext	Outermost.apply(EK9Parser.ExpressionContext expression)

Methods in org.ek9lang.compiler.support.sharing with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
void	ReachedByExpression.accept(EK9Parser.ExpressionContext expression, ReachSoFar reach)
EK9Parser.ExpressionContext	Outermost.apply(EK9Parser.ExpressionContext expression)
Reach	ReachOfIteration.apply(EK9Parser.ExpressionContext iterated, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)
List<ObjectSharing.Use>	RetainedBy.apply(EK9Parser.ExpressionContext expression, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	The object expression evaluates to (or contains) - what keeps it?
boolean	IsCoalescingOperator.test(EK9Parser.ExpressionContext binary)
boolean	IsExistingNamedObject.test(EK9Parser.ExpressionContext expression, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)
boolean	MayBeExistingObject.test(EK9Parser.ExpressionContext expression, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)
boolean	MayBeExistingObjectByShape.test(EK9Parser.ExpressionContext expression, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)

Uses of EK9Parser.ExpressionContext in org.ek9lang.compiler.symbolic

Classes in org.ek9lang.compiler.symbolic that implement interfaces with type arguments of type EK9Parser.ExpressionContext

Modifier and Type	Class	Description
final class	IntegerLiteralOperand	THE integer-literal reader for a relational operand, shared by RequirePredicateReader and SymbolicEngine's division, guard and constraint paths: the literal's value, or null when the operand is not an integer literal.

Methods in org.ek9lang.compiler.symbolic with parameters of type EK9Parser.ExpressionContext

Modifier and Type	Method	Description
Long	IntegerLiteralOperand.apply(EK9Parser.ExpressionContext expr)