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.support	Contains critical general components used in the Ek9Compiler listeners.
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	CoalescingOperandParenthesesOrError	E08269 (Steve, D6, 2026-10-07): a coalescing operator - the null coalescing ??, 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	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, ...).

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

Modifier and Type	Method	Description
(package private) static EK9Parser.ExpressionContext	BinaryExpressions.negatedOperandOf(EK9Parser.ExpressionContext negation)	What a negation 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) static EK9Parser.ExpressionContext	BinaryExpressions.negationApplyingTo(EK9Parser.ExpressionContext ctx)	The negation that ctx is the operand of, looking through parentheses (ctx is not b in ~((not b))); null when it is not the operand of a negation.
(package private) static EK9Parser.ExpressionContext	BinaryExpressions.prefixOperandOf(EK9Parser.ExpressionContext ctx)	The single operand of a prefix expression (or of word not).
(package private) static EK9Parser.ExpressionContext	BinaryExpressions.withoutParentheses(EK9Parser.ExpressionContext ctx)	The expression inside any number of enclosing parentheses: b for ((b)).

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	DefinitionListener.enterExpression(EK9Parser.ExpressionContext ctx)
(package private) static boolean	BinaryExpressions.isBinary(EK9Parser.ExpressionContext ctx)
(package private) static boolean	BinaryExpressions.isNegation(EK9Parser.ExpressionContext ctx)	A negation applied to one operand: word not b, ~b or unary -x.
(package private) static boolean	BinaryExpressions.isPrefix(EK9Parser.ExpressionContext ctx)	A prefix expression (not word not): the operator comes first and there is one operand, BinaryExpressions.prefixOperandOf(EK9Parser.ExpressionContext).
(package private) static boolean	BinaryExpressions.isSignedLiteral(EK9Parser.ExpressionContext ctx)	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) static boolean	BinaryExpressions.isWordNot(EK9Parser.ExpressionContext ctx)	Word not applied to an operand: not b.
(package private) static EK9Parser.ExpressionContext	BinaryExpressions.negatedOperandOf(EK9Parser.ExpressionContext negation)	What a negation 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) static EK9Parser.ExpressionContext	BinaryExpressions.negationApplyingTo(EK9Parser.ExpressionContext ctx)	The negation that ctx is the operand of, looking through parentheses (ctx is not b in ~((not b))); null when it is not the operand of a negation.
(package private) static org.antlr.v4.runtime.Token	BinaryExpressions.operatorOf(EK9Parser.ExpressionContext ctx)	The operator token of a binary expression.
(package private) static EK9Parser.ExpressionContext	BinaryExpressions.prefixOperandOf(EK9Parser.ExpressionContext ctx)	The single operand of a prefix expression (or of word not).
(package private) static EK9Parser.ExpressionContext	BinaryExpressions.withoutParentheses(EK9Parser.ExpressionContext ctx)	The expression inside any number of enclosing parentheses: b for ((b)).

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 '#^' (ControlIsBooleanOrError.isCondition(ISymbol, ISymbol), 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, 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	SelfComparisonOrError	Detects self-comparison expressions where both sides resolve to the same symbol (E08081).
(package private) final class	TernaryBlockSafeGenericAccessMarker	Similar to the if block check, but this is focused on the true part of the ternary expression.

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) static List<EK9Parser.ExpressionContext>	SafeAccessConjuncts.conjunctsOf(EK9Parser.ExpressionContext condition)	The top-level and conjuncts of condition, left to right, parentheses removed.
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)
void	TernaryBlockSafeGenericAccessMarker.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.
(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.
(package private) static List<EK9Parser.ExpressionContext>	SafeAccessConjuncts.conjunctsOf(EK9Parser.ExpressionContext condition)	The top-level and conjuncts of condition, left to right, parentheses removed.
void	DataRaceCheckListener.enterExpression(EK9Parser.ExpressionContext ctx)
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) void	SafeAccessConjuncts.markProven(EK9Parser.ExpressionContext condition, IScope scopeMadeSafe)	Mark everything the top-level conjuncts of condition prove as safe in scopeMadeSafe.
(package private) static ReturnSourceKind	ReturnSourceKind.of(ParsedModule parsedModule, ScopedSymbol callable, EK9Parser.ExpressionContext source)	Classify one source of a callable's returning variable.
protected void	AbstractSafeGenericAccessMarker.processExpression(EK9Parser.ExpressionContext ctx, IScope wouldBeSafeScope)	Each top-level and conjunct of the control that is an is-set check proves its subject safe in wouldBeSafeScope, whatever the other conjuncts are (SafeAccessConjuncts, decision Q3).
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.

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.
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.

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
static EK9Parser.ExpressionContext	StringExpressionClassifier.findEnclosingConcatExpression(org.antlr.v4.runtime.tree.ParseTree root, int line, int col)	Walk a parse tree looking for the smallest EK9Parser.ExpressionContext that BOTH (a) contains the cursor position and (b) is a binary + concat expression.
static EK9Parser.ExpressionContext	StringExpressionClassifier.findEnclosingStringLiteralExpression(org.antlr.v4.runtime.tree.ParseTree root, int line, int col)	Walk a parse tree looking for the smallest EK9Parser.ExpressionContext that BOTH (a) contains the cursor position and (b) is a single string literal (double-quoted or backtick interpolation).
static EK9Parser.ExpressionContext	StringExpressionClassifier.findExpressionAtCursor(org.antlr.v4.runtime.tree.ParseTree root, int line, int col)	Walk a parse tree looking for the smallest EK9Parser.ExpressionContext whose token range CONTAINS the cursor position (line, col).
static EK9Parser.ExpressionContext	StringExpressionClassifier.findSmallestEnclosingExpression(org.antlr.v4.runtime.tree.ParseTree root, int startLine, int startCol, int endLine, int endCol)	Walk a parse tree looking for the smallest EK9Parser.ExpressionContext whose source token range exactly matches the selection.
EK9Parser.ExpressionContext	StringConcatRewriter.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
static EK9Parser.StringLitContext	StringExpressionClassifier.extractStringLit(EK9Parser.ExpressionContext expr)	Extract the stringLit parse-tree node from an expression that is a single string literal (double-quoted or backtick).
static boolean	StringExpressionClassifier.isAddExpression(EK9Parser.ExpressionContext expr)	True when the expression's outer operator is binary + with two operand expressions.
static boolean	StringExpressionClassifier.isSingleStringLiteral(EK9Parser.ExpressionContext expr)	True when the expression resolves to a single string-literal primary — double-quoted or backtick interpolation.
(package private) static StringConcatRewriter.ChainRendering	StringConcatRewriter.ChainRendering.refused(String kind, String reason, EK9Parser.ExpressionContext offender, String suggestedRewrite)
(package private) static StringConcatRewriter.ChainRendering	StringConcatRewriter.renderChain(EK9Parser.ExpressionContext chain, String sourceText, Function<EK9Parser.ExpressionContext, String> typeProblem)	THE rendering of a + chain as one backtick String - shared by this tool and the E11068 repair (ConcatenationInterpolation); use it, do not re-derive the operand rules.
(package private) static ISymbol	StringConcatRewriter.resolveSymbolForTest(ParsedModule parsedModule, EK9Parser.ExpressionContext expr)	Visible for tests.
static int[]	StringExpressionClassifier.tokenRange(EK9Parser.ExpressionContext expr)	Token-range bounds of an expression as 1-based (line, col) coordinates.

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

Modifier and Type	Method	Description
(package private) static StringConcatRewriter.ChainRendering	StringConcatRewriter.renderChain(EK9Parser.ExpressionContext chain, String sourceText, Function<EK9Parser.ExpressionContext, String> typeProblem)	THE rendering of a + chain as one backtick String - shared by this tool and the E11068 repair (ConcatenationInterpolation); use it, do not re-derive the operand rules.

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.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	IsFreshValueExpression	THE "fresh value" predicate: true iff an expression evaluates to a NEW object - one nothing else holds a reference to.

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

Modifier and Type	Method	Description
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)
static Optional<ScopedSymbol>	ReturnRetention.calleeOf(EK9Parser.ExpressionContext expression, Function<org.antlr.v4.runtime.tree.ParseTree, ISymbol> recorded)	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.
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	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.symbolic

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

Modifier and Type	Method	Description
static Long	RequirePredicateReader.literalLongOf(EK9Parser.ExpressionContext expr)	THE integer-literal reader for a relational operand, shared with SymbolicEngine's division, guard and constraint paths.