More performance improvements

runtime/Go/antlr/v4/atn_config_set.go

@@ -8,62 +8,21 @@ import (
 	"fmt"
 )
 
-type ATNConfigSet interface {
-	Hash() int
-	Equals(o Collectable[ATNConfig]) bool
-	Add(ATNConfig, *DoubleDict) bool
-	AddAll([]ATNConfig) bool
-
-	GetStates() *JStore[ATNState, Comparator[ATNState]]
-	GetPredicates() []SemanticContext
-	GetItems() []ATNConfig
-
-	OptimizeConfigs(interpreter *BaseATNSimulator)
-
-	Length() int
-	IsEmpty() bool
-	Contains(ATNConfig) bool
-	ContainsFast(ATNConfig) bool
-	Clear()
-	String() string
-
-	HasSemanticContext() bool
-	SetHasSemanticContext(v bool)
-
-	ReadOnly() bool
-	SetReadOnly(bool)
-
-	GetConflictingAlts() *BitSet
-	SetConflictingAlts(*BitSet)
-
-	Alts() *BitSet
-
-	FullContext() bool
-
-	GetUniqueAlt() int
-	SetUniqueAlt(int)
-
-	GetDipsIntoOuterContext() bool
-	SetDipsIntoOuterContext(bool)
-}
-
-// BaseATNConfigSet is a specialized set of ATNConfig that tracks information
+// ATNConfigSet is a specialized set of ATNConfig that tracks information
 // about its elements and can combine similar configurations using a
 // graph-structured stack.
-type BaseATNConfigSet struct {
-
-	// TODO: Is this actually valid? JI
+type ATNConfigSet struct {
 	cachedHash int
 
-	// configLookup is used to determine whether two BaseATNConfigSets are equal. We
+	// configLookup is used to determine whether two ATNConfigSets are equal. We
 	// need all configurations with the same (s, i, _, semctx) to be equal. A key
 	// effectively doubles the number of objects associated with ATNConfigs. All
 	// keys are hashed by (s, i, _, pi), not including the context. Wiped out when
 	// read-only because a set becomes a DFA state.
-	configLookup *JStore[ATNConfig, Comparator[ATNConfig]]
+	configLookup *JStore[*ATNConfig, Comparator[*ATNConfig]]
 
 	// configs is the added elements.
-	configs []ATNConfig
+	configs []*ATNConfig
 
 	// TODO: These fields make me pretty uncomfortable, but it is nice to pack up
 	// info together because it saves re-computation. Can we track conflicts as they
@@ -72,7 +31,7 @@ type BaseATNConfigSet struct {
 
 	// dipsIntoOuterContext is used by parsers and lexers. In a lexer, it indicates
 	// we hit a pred while computing a closure operation. Do not make a DFA state
-	// from the BaseATNConfigSet in this case. TODO: How is this used by parsers?
+	// from the ATNConfigSet in this case. TODO: How is this used by parsers?
 	dipsIntoOuterContext bool
 
 	// fullCtx is whether it is part of a full context LL prediction. Used to
@@ -97,19 +56,19 @@ type BaseATNConfigSet struct {
 }
 
 // Alts returns the combined set of alts for all the configurations in this set.
-func (b *BaseATNConfigSet) Alts() *BitSet {
+func (b *ATNConfigSet) Alts() *BitSet {
 	alts := NewBitSet()
 	for _, it := range b.configs {
 		alts.add(it.GetAlt())
 	}
 	return alts
 }
 
-// NewBaseATNConfigSet creates a new BaseATNConfigSet instance.
-func NewBaseATNConfigSet(fullCtx bool) *BaseATNConfigSet {
-	return &BaseATNConfigSet{
+// NewATNConfigSet creates a new ATNConfigSet instance.
+func NewATNConfigSet(fullCtx bool) *ATNConfigSet {
+	return &ATNConfigSet{
 		cachedHash:   -1,
-		configLookup: NewJStore[ATNConfig, Comparator[ATNConfig]](aConfCompInst),
+		configLookup: NewJStore[*ATNConfig, Comparator[*ATNConfig]](aConfCompInst),
 		fullCtx:      fullCtx,
 	}
 }
@@ -120,7 +79,7 @@ func NewBaseATNConfigSet(fullCtx bool) *BaseATNConfigSet {
 //
 // We use (s,i,pi) as the key.
 // Updates dipsIntoOuterContext and hasSemanticContext when necessary.
-func (b *BaseATNConfigSet) Add(config ATNConfig, mergeCache *DoubleDict) bool {
+func (b *ATNConfigSet) Add(config *ATNConfig, mergeCache *JPCMap) bool {
 	if b.readOnly {
 		panic("set is read-only")
 	}
@@ -164,7 +123,7 @@ func (b *BaseATNConfigSet) Add(config ATNConfig, mergeCache *DoubleDict) bool {
 }
 
 // GetStates returns the set of states represented by all configurations in this config set
-func (b *BaseATNConfigSet) GetStates() *JStore[ATNState, Comparator[ATNState]] {
+func (b *ATNConfigSet) GetStates() *JStore[ATNState, Comparator[ATNState]] {
 
 	// states uses the standard comparator and Hash() provided by the ATNState instance
 	//
@@ -177,17 +136,7 @@ func (b *BaseATNConfigSet) GetStates() *JStore[ATNState, Comparator[ATNState]] {
 	return states
 }
 
-// HasSemanticContext returns true if this set contains a semantic context.
-func (b *BaseATNConfigSet) HasSemanticContext() bool {
-	return b.hasSemanticContext
-}
-
-// SetHasSemanticContext sets whether this set contains a semantic context.
-func (b *BaseATNConfigSet) SetHasSemanticContext(v bool) {
-	b.hasSemanticContext = v
-}
-
-func (b *BaseATNConfigSet) GetPredicates() []SemanticContext {
+func (b *ATNConfigSet) GetPredicates() []SemanticContext {
 	predicates := make([]SemanticContext, 0)
 
 	for i := 0; i < len(b.configs); i++ {
@@ -201,11 +150,7 @@ func (b *BaseATNConfigSet) GetPredicates() []SemanticContext {
 	return predicates
 }
 
-func (b *BaseATNConfigSet) GetItems() []ATNConfig {
-	return b.configs
-}
-
-func (b *BaseATNConfigSet) OptimizeConfigs(interpreter *BaseATNSimulator) {
+func (b *ATNConfigSet) OptimizeConfigs(interpreter *BaseATNSimulator) {
 	if b.readOnly {
 		panic("set is read-only")
 	}
@@ -221,7 +166,7 @@ func (b *BaseATNConfigSet) OptimizeConfigs(interpreter *BaseATNSimulator) {
 	}
 }
 
-func (b *BaseATNConfigSet) AddAll(coll []ATNConfig) bool {
+func (b *ATNConfigSet) AddAll(coll []*ATNConfig) bool {
 	for i := 0; i < len(coll); i++ {
 		b.Add(coll[i], nil)
 	}
@@ -235,8 +180,7 @@ func (b *BaseATNConfigSet) AddAll(coll []ATNConfig) bool {
 // only equal if they are in the same order too as Java uses ArrayList.equals(), which requires
 // the same order.
 //
-// TODO: JI - Look to change the way config set is implemented. Improve data structure if possible
-func (b *BaseATNConfigSet) Compare(bs *BaseATNConfigSet) bool {
+func (b *ATNConfigSet) Compare(bs *ATNConfigSet) bool {
 	if len(b.configs) != len(bs.configs) {
 		return false
 	}
@@ -249,14 +193,14 @@ func (b *BaseATNConfigSet) Compare(bs *BaseATNConfigSet) bool {
 	return true
 }
 
-func (b *BaseATNConfigSet) Equals(other Collectable[ATNConfig]) bool {
+func (b *ATNConfigSet) Equals(other Collectable[ATNConfig]) bool {
 	if b == other {
 		return true
-	} else if _, ok := other.(*BaseATNConfigSet); !ok {
+	} else if _, ok := other.(*ATNConfigSet); !ok {
 		return false
 	}
 
-	other2 := other.(*BaseATNConfigSet)
+	other2 := other.(*ATNConfigSet)
 	var eca bool
 	switch {
 	case b.conflictingAlts == nil && other2.conflictingAlts == nil:
@@ -273,7 +217,7 @@ func (b *BaseATNConfigSet) Equals(other Collectable[ATNConfig]) bool {
 		b.Compare(other2)
 }
 
-func (b *BaseATNConfigSet) Hash() int {
+func (b *ATNConfigSet) Hash() int {
 	if b.readOnly {
 		if b.cachedHash == -1 {
 			b.cachedHash = b.hashCodeConfigs()
@@ -285,89 +229,41 @@ func (b *BaseATNConfigSet) Hash() int {
 	return b.hashCodeConfigs()
 }
 
-func (b *BaseATNConfigSet) hashCodeConfigs() int {
+func (b *ATNConfigSet) hashCodeConfigs() int {
 	h := 1
 	for _, config := range b.configs {
 		h = 31*h + config.Hash()
 	}
 	return h
 }
 
-func (b *BaseATNConfigSet) Length() int {
-	return len(b.configs)
-}
-
-func (b *BaseATNConfigSet) IsEmpty() bool {
-	return len(b.configs) == 0
-}
-
-func (b *BaseATNConfigSet) Contains(item ATNConfig) bool {
+func (b *ATNConfigSet) Contains(item *ATNConfig) bool {
 	if b.configLookup == nil {
 		panic("not implemented for read-only sets")
 	}
 
 	return b.configLookup.Contains(item)
 }
 
-func (b *BaseATNConfigSet) ContainsFast(item ATNConfig) bool {
+func (b *ATNConfigSet) ContainsFast(item *ATNConfig) bool {
 	if b.configLookup == nil {
 		panic("not implemented for read-only sets")
 	}
 
 	return b.configLookup.Contains(item) // TODO: containsFast is not implemented for Set
 }
 
-func (b *BaseATNConfigSet) Clear() {
+func (b *ATNConfigSet) Clear() {
 	if b.readOnly {
 		panic("set is read-only")
 	}
-
-	b.configs = make([]ATNConfig, 0)
+	b.configs = make([]*ATNConfig, 0)
 	b.cachedHash = -1
-	b.configLookup = NewJStore[ATNConfig, Comparator[ATNConfig]](atnConfCompInst)
+	b.configLookup = NewJStore[*ATNConfig, Comparator[*ATNConfig]](aConfCompInst)
 }
 
-func (b *BaseATNConfigSet) FullContext() bool {
-	return b.fullCtx
-}
-
-func (b *BaseATNConfigSet) GetDipsIntoOuterContext() bool {
-	return b.dipsIntoOuterContext
-}
-
-func (b *BaseATNConfigSet) SetDipsIntoOuterContext(v bool) {
-	b.dipsIntoOuterContext = v
-}
-
-func (b *BaseATNConfigSet) GetUniqueAlt() int {
-	return b.uniqueAlt
-}
-
-func (b *BaseATNConfigSet) SetUniqueAlt(v int) {
-	b.uniqueAlt = v
-}
-
-func (b *BaseATNConfigSet) GetConflictingAlts() *BitSet {
-	return b.conflictingAlts
-}
-
-func (b *BaseATNConfigSet) SetConflictingAlts(v *BitSet) {
-	b.conflictingAlts = v
-}
-
-func (b *BaseATNConfigSet) ReadOnly() bool {
-	return b.readOnly
-}
-
-func (b *BaseATNConfigSet) SetReadOnly(readOnly bool) {
-	b.readOnly = readOnly
-
-	if readOnly {
-		b.configLookup = nil // Read only, so no need for the lookup cache
-	}
-}
+func (b *ATNConfigSet) String() string {
 
-func (b *BaseATNConfigSet) String() string {
 	s := "["
 
 	for i, c := range b.configs {
@@ -399,15 +295,13 @@ func (b *BaseATNConfigSet) String() string {
 	return s
 }
 
-type OrderedATNConfigSet struct {
-	*BaseATNConfigSet
-}
-
-func NewOrderedATNConfigSet() *OrderedATNConfigSet {
-	b := NewBaseATNConfigSet(false)
-
-	// This set uses the standard Hash() and Equals() from ATNConfig
-	b.configLookup = NewJStore[ATNConfig, Comparator[ATNConfig]](aConfEqInst)
-
-	return &OrderedATNConfigSet{BaseATNConfigSet: b}
+// NewOrderedATNConfigSet creates a config set with a slightly different Hash/Equal pair
+// for use in lexers.
+func NewOrderedATNConfigSet() *ATNConfigSet {
+	return &ATNConfigSet{
+		cachedHash: -1,
+		// This set uses the standard Hash() and Equals() from ATNConfig
+		configLookup: NewJStore[*ATNConfig, Comparator[*ATNConfig]](aConfEqInst),
+		fullCtx:      false,
+	}
 }

runtime/Go/antlr/v4/atn_simulator.go

@@ -4,7 +4,7 @@
 
 package antlr
 
-var ATNSimulatorError = NewDFAState(0x7FFFFFFF, NewBaseATNConfigSet(false))
+var ATNSimulatorError = NewDFAState(0x7FFFFFFF, NewATNConfigSet(false))
 
 type IATNSimulator interface {
 	SharedContextCache() *PredictionContextCache
@@ -24,7 +24,7 @@ func (b *BaseATNSimulator) getCachedContext(context *PredictionContext) *Predict
 	}
 
 	// TODO: Should this be guarded by a mutex?
-	visited := NewJStore[*PredictionContext, Comparator[*PredictionContext]](pContextEqInst)
+	visited := NewJMap[*PredictionContext, *PredictionContext, Comparator[*PredictionContext]](pContextEqInst)
 
 	return getCachedBasePredictionContext(context, b.sharedContextCache, visited)
 }

runtime/Go/antlr/v4/atn_state.go

@@ -78,7 +78,7 @@ type BaseATNState struct {
 	transitions []Transition
 }
 
-func NewBaseATNState() *BaseATNState {
+func NewATNState() *BaseATNState {
 	return &BaseATNState{stateNumber: ATNStateInvalidStateNumber, stateType: ATNStateInvalidType}
 }