feat: Refactor PredictionContexts so that it does not use an interface

Interfaces require two pointer lookups for functions and when used as
Generic, they require three. This change therefore yields a small
performance upgrade.

This change also corrects one or two copmarisons that were using pointer
comparison instead of Equals() and were bugs in the code I inherited.

Signed-off-by: Jim.Idle <jimi@idle.ws>

runtime/Go/antlr/v4/array_prediction_context.go

@@ -1,40 +1,11 @@
 package antlr
 
-import (
-	"golang.org/x/exp/slices"
-	"strconv"
-)
-
 type ArrayPredictionContext struct {
 	BasePredictionContext
 	parents      []PredictionContext
 	returnStates []int
 }
 
-func NewArrayPredictionContext(parents []PredictionContext, returnStates []int) *ArrayPredictionContext {
-	// Parent can be nil only if full ctx mode and we make an array
-	// from {@link //EMPTY} and non-empty. We merge {@link //EMPTY} by using
-	// nil parent and
-	// returnState == {@link //EmptyReturnState}.
-	hash := murmurInit(1)
-	for _, parent := range parents {
-		hash = murmurUpdate(hash, parent.Hash())
-	}
-	for _, returnState := range returnStates {
-		hash = murmurUpdate(hash, returnState)
-	}
-	hash = murmurFinish(hash, len(parents)<<1)
-
-	return &ArrayPredictionContext{
-		BasePredictionContext: BasePredictionContext{
-			cachedHash: hash,
-			pcType:     PredictionContextArray,
-		},
-		parents:      parents,
-		returnStates: returnStates,
-	}
-}
-
 func (a *ArrayPredictionContext) GetReturnStates() []int {
 	return a.returnStates
 }
@@ -61,55 +32,55 @@ func (a *ArrayPredictionContext) getReturnState(index int) int {
 	return a.returnStates[index]
 }
 
-// Equals is the default comparison function for ArrayPredictionContext when no specialized
-// implementation is needed for a collection
-func (a *ArrayPredictionContext) Equals(o Collectable[PredictionContext]) bool {
-	if a == o {
-		return true
-	}
-	other, ok := o.(*ArrayPredictionContext)
-	if !ok {
-		return false
-	}
-	if a.cachedHash != other.Hash() {
-		return false // can't be same if hash is different
-	}
-	
-	// Must compare the actual array elements and not just the array address
-	// TODO: The hash hashes in all the return states anyway, to we maybe don't need to compare them here?
-	return slices.Equal(a.returnStates, other.returnStates) &&
-		slices.EqualFunc(a.parents, other.parents, func(x, y PredictionContext) bool {
-			return x.Equals(y)
-		})
-}
+//// Equals is the default comparison function for ArrayPredictionContext when no specialized
+//// implementation is needed for a collection
+//func (a *ArrayPredictionContext) Equals(o Collectable[*PredictionContext]) bool {
+//	if a == o {
+//		return true
+//	}
+//	other, ok := o.(*ArrayPredictionContext)
+//	if !ok {
+//		return false
+//	}
+//	if a.cachedHash != other.Hash() {
+//		return false // can't be same if hash is different
+//	}
+//
+//	// Must compare the actual array elements and not just the array address
+//	// TODO: The hash hashes in all the return states anyway, to we maybe don't need to compare them here?
+//	return slices.Equal(a.returnStates, other.returnStates) &&
+//		slices.EqualFunc(a.parents, other.parents, func(x, y *PredictionContext) bool {
+//			return x.Equals(y)
+//		})
+//}
 
 // Hash is the default hash function for ArrayPredictionContext when no specialized
 // implementation is needed for a collection
 func (a *ArrayPredictionContext) Hash() int {
 	return a.BasePredictionContext.cachedHash
 }
 
-func (a *ArrayPredictionContext) String() string {
-	if a.isEmpty() {
-		return "[]"
-	}
-	
-	s := "["
-	for i := 0; i < len(a.returnStates); i++ {
-		if i > 0 {
-			s = s + ", "
-		}
-		if a.returnStates[i] == BasePredictionContextEmptyReturnState {
-			s = s + "$"
-			continue
-		}
-		s = s + strconv.Itoa(a.returnStates[i])
-		if a.parents[i] != nil {
-			s = s + " " + a.parents[i].String()
-		} else {
-			s = s + "nil"
-		}
-	}
-	
-	return s + "]"
-}
+//func (a *ArrayPredictionContext) String() string {
+//	if a.isEmpty() {
+//		return "[]"
+//	}
+//
+//	s := "["
+//	for i := 0; i < len(a.returnStates); i++ {
+//		if i > 0 {
+//			s = s + ", "
+//		}
+//		if a.returnStates[i] == BasePredictionContextEmptyReturnState {
+//			s = s + "$"
+//			continue
+//		}
+//		s = s + strconv.Itoa(a.returnStates[i])
+//		if a.parents[i] != nil {
+//			s = s + " " + a.parents[i].String()
+//		} else {
+//			s = s + "nil"
+//		}
+//	}
+//
+//	return s + "]"
+//}

runtime/Go/antlr/v4/atn_config.go

@@ -29,9 +29,9 @@ type ATNConfig interface {
 	GetSemanticContext() SemanticContext
 
 	// GetContext returns the rule invocation stack associated with this configuration
-	GetContext() PredictionContext
+	GetContext() *PredictionContext
 	// SetContext sets the rule invocation stack associated with this configuration
-	SetContext(PredictionContext)
+	SetContext(*PredictionContext)
 
 	// GetReachesIntoOuterContext returns the count of references to an outer context from this configuration
 	GetReachesIntoOuterContext() int
@@ -52,7 +52,7 @@ type BaseATNConfig struct {
 	precedenceFilterSuppressed bool
 	state                      ATNState
 	alt                        int
-	context                    PredictionContext
+	context                    *PredictionContext
 	semanticContext            SemanticContext
 	reachesIntoOuterContext    int
 }
@@ -69,12 +69,12 @@ func NewBaseATNConfig7(old *BaseATNConfig) ATNConfig { // TODO: Dup - maybe dele
 }
 
 // NewBaseATNConfig6 creates a new BaseATNConfig instance given a state, alt and context only
-func NewBaseATNConfig6(state ATNState, alt int, context PredictionContext) *BaseATNConfig {
+func NewBaseATNConfig6(state ATNState, alt int, context *PredictionContext) *BaseATNConfig {
 	return NewBaseATNConfig5(state, alt, context, SemanticContextNone)
 }
 
 // NewBaseATNConfig5 creates a new BaseATNConfig instance given a state, alt, context and semantic context
-func NewBaseATNConfig5(state ATNState, alt int, context PredictionContext, semanticContext SemanticContext) *BaseATNConfig {
+func NewBaseATNConfig5(state ATNState, alt int, context *PredictionContext, semanticContext SemanticContext) *BaseATNConfig {
 	if semanticContext == nil {
 		panic("semanticContext cannot be nil") // TODO: Necessary?
 	}
@@ -98,13 +98,13 @@ func NewBaseATNConfig2(c ATNConfig, semanticContext SemanticContext) *BaseATNCon
 }
 
 // NewBaseATNConfig1 creates a new BaseATNConfig instance given an existing config, a state, and a context only
-func NewBaseATNConfig1(c ATNConfig, state ATNState, context PredictionContext) *BaseATNConfig {
+func NewBaseATNConfig1(c ATNConfig, state ATNState, context *PredictionContext) *BaseATNConfig {
 	return NewBaseATNConfig(c, state, context, c.GetSemanticContext())
 }
 
 // NewBaseATNConfig creates a new BaseATNConfig instance given an existing config, a state, a context and a semantic context, other 'constructors'
 // are just wrappers around this one.
-func NewBaseATNConfig(c ATNConfig, state ATNState, context PredictionContext, semanticContext SemanticContext) *BaseATNConfig {
+func NewBaseATNConfig(c ATNConfig, state ATNState, context *PredictionContext, semanticContext SemanticContext) *BaseATNConfig {
 	if semanticContext == nil {
 		panic("semanticContext cannot be nil") // TODO: Remove this - probably put here for some bug that is now fixed
 	}
@@ -115,7 +115,7 @@ func NewBaseATNConfig(c ATNConfig, state ATNState, context PredictionContext, se
 	return b
 }
 
-func (b *BaseATNConfig) InitBaseATNConfig(c ATNConfig, state ATNState, alt int, context PredictionContext, semanticContext SemanticContext) {
+func (b *BaseATNConfig) InitBaseATNConfig(c ATNConfig, state ATNState, alt int, context *PredictionContext, semanticContext SemanticContext) {
 
 	b.state = state
 	b.alt = alt
@@ -144,12 +144,12 @@ func (b *BaseATNConfig) GetAlt() int {
 }
 
 // SetContext sets the rule invocation stack associated with this configuration
-func (b *BaseATNConfig) SetContext(v PredictionContext) {
+func (b *BaseATNConfig) SetContext(v *PredictionContext) {
 	b.context = v
 }
 
 // GetContext returns the rule invocation stack associated with this configuration
-func (b *BaseATNConfig) GetContext() PredictionContext {
+func (b *BaseATNConfig) GetContext() *PredictionContext {
 	return b.context
 }
 
@@ -248,7 +248,7 @@ type LexerATNConfig struct {
 	passedThroughNonGreedyDecision bool
 }
 
-func NewLexerATNConfig6(state ATNState, alt int, context PredictionContext) *LexerATNConfig {
+func NewLexerATNConfig6(state ATNState, alt int, context *PredictionContext) *LexerATNConfig {
 
 	return &LexerATNConfig{
 		BaseATNConfig: BaseATNConfig{
@@ -260,7 +260,7 @@ func NewLexerATNConfig6(state ATNState, alt int, context PredictionContext) *Lex
 	}
 }
 
-func NewLexerATNConfig5(state ATNState, alt int, context PredictionContext, lexerActionExecutor *LexerActionExecutor) *LexerATNConfig {
+func NewLexerATNConfig5(state ATNState, alt int, context *PredictionContext, lexerActionExecutor *LexerActionExecutor) *LexerATNConfig {
 	return &LexerATNConfig{
 		BaseATNConfig: BaseATNConfig{
 			state:           state,
@@ -291,7 +291,7 @@ func NewLexerATNConfig3(c *LexerATNConfig, state ATNState, lexerActionExecutor *
 	return lac
 }
 
-func NewLexerATNConfig2(c *LexerATNConfig, state ATNState, context PredictionContext) *LexerATNConfig {
+func NewLexerATNConfig2(c *LexerATNConfig, state ATNState, context *PredictionContext) *LexerATNConfig {
 	lac := &LexerATNConfig{
 		lexerActionExecutor:            c.lexerActionExecutor,
 		passedThroughNonGreedyDecision: checkNonGreedyDecision(c, state),
@@ -301,7 +301,7 @@ func NewLexerATNConfig2(c *LexerATNConfig, state ATNState, context PredictionCon
 }
 
 //goland:noinspection GoUnusedExportedFunction
-func NewLexerATNConfig1(state ATNState, alt int, context PredictionContext) *LexerATNConfig {
+func NewLexerATNConfig1(state ATNState, alt int, context *PredictionContext) *LexerATNConfig {
 	lac := &LexerATNConfig{
 		BaseATNConfig: BaseATNConfig{
 			state:           state,

runtime/Go/antlr/v4/atn_simulator.go

@@ -18,12 +18,13 @@ type BaseATNSimulator struct {
 	decisionToDFA      []*DFA
 }
 
-func (b *BaseATNSimulator) getCachedContext(context PredictionContext) PredictionContext {
+func (b *BaseATNSimulator) getCachedContext(context *PredictionContext) *PredictionContext {
 	if b.sharedContextCache == nil {
 		return context
 	}
 
-	visited := NewJStore[PredictionContext, Comparator[PredictionContext]](pContextEqInst)
+	// TODO: Should this be guarded by a mutex?
+	visited := NewJStore[*PredictionContext, Comparator[*PredictionContext]](pContextEqInst)
 
 	return getCachedBasePredictionContext(context, b.sharedContextCache, visited)
 }

runtime/Go/antlr/v4/atn_state.go

@@ -78,9 +78,9 @@ type BaseATNState struct {
 	transitions []Transition
 }
 
-//func NewBaseATNState() *BaseATNState {
-//	return &BaseATNState{stateNumber: ATNStateInvalidStateNumber, stateType: ATNStateInvalidType}
-//}
+func NewBaseATNState() *BaseATNState {
+	return &BaseATNState{stateNumber: ATNStateInvalidStateNumber, stateType: ATNStateInvalidType}
+}
 
 func (as *BaseATNState) GetRuleIndex() int {
 	return as.ruleIndex

runtime/Go/antlr/v4/base_prediction_context.go

@@ -16,9 +16,9 @@ func (b *BasePredictionContext) Equals(_ Collectable[PredictionContext]) bool {
 	return false
 }
 
-func (b *BasePredictionContext) GetParent(i int) PredictionContext {
-	return nil
-}
+//func (b *BasePredictionContext) GetParent(i int) PredictionContext {
+//	return nil
+//}
 
 func (b *BasePredictionContext) getReturnState(i int) int {
 	return 0

runtime/Go/antlr/v4/comparators.go

@@ -29,7 +29,7 @@ var (
 	dfaStateEqInst  = &ObjEqComparator[*DFAState]{}
 	semctxEqInst    = &ObjEqComparator[SemanticContext]{}
 	atnAltCfgEqInst = &ATNAltConfigComparator[ATNConfig]{}
-	pContextEqInst  = &ObjEqComparator[PredictionContext]{}
+	pContextEqInst  = &ObjEqComparator[*PredictionContext]{}
 )
 
 // Equals2 delegates to the Equals() method of type T

runtime/Go/antlr/v4/empty_prediction_context.go

@@ -15,18 +15,7 @@ type EmptyPredictionContext struct {
 	BaseSingletonPredictionContext
 }
 
-func NewEmptyPredictionContext() *EmptyPredictionContext {
-	return &EmptyPredictionContext{
-		BaseSingletonPredictionContext: BaseSingletonPredictionContext{
-			BasePredictionContext: BasePredictionContext{
-				cachedHash: calculateEmptyHash(),
-				pcType:     PredictionContextEmpty,
-			},
-			parentCtx:   nil,
-			returnState: BasePredictionContextEmptyReturnState,
-		},
-	}
-}
+
 func (e *EmptyPredictionContext) length() int {
 	return 1
 }
@@ -35,9 +24,9 @@ func (e *EmptyPredictionContext) isEmpty() bool {
 	return true
 }
 
-func (e *EmptyPredictionContext) GetParent(_ int) PredictionContext {
-	return nil
-}
+//func (e *EmptyPredictionContext) GetParent(_ int) PredictionContext {
+//	return nil
+//}
 
 func (e *EmptyPredictionContext) getReturnState(_ int) int {
 	return e.returnState