diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/ParserExec/ListLabelsOnRuleRefStartOfAlt.txt b/runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/ParserExec/ListLabelsOnRuleRefStartOfAlt.txt
index c9dca5ecab..ac6963e588 100644
--- a/runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/ParserExec/ListLabelsOnRuleRefStartOfAlt.txt
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/ParserExec/ListLabelsOnRuleRefStartOfAlt.txt
@@ -30,5 +30,4 @@ expression
 a and b
 
 [skip]
-Go
 Cpp
\ No newline at end of file
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Go.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Go.test.stg
index fba2da58f8..f7c1240d7d 100644
--- a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Go.test.stg
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Go.test.stg
@@ -18,7 +18,16 @@ AppendStr(a,b) ::= "<a> + <b>"
 
 Concat(a,b) ::= "<a><b>"
 
-AssertIsList(v) ::= "TODO!!"
+AssertIsList(v) ::= <<
+// A noddy range over the list will not compile if it is not getting a slice
+// however, Go will not compile the generated code if the slice vs single value is wrong.
+// Makes the Java based tests suite work though.
+j1__ := make([]interface{}, len(<v>))
+j2__ := <v>
+for j3__ := range j2__ {
+   j1__[j3__] = j2__[j3__]
+}
+>>
 
 AssignLocal(s, v) ::= "<s> = <v>;"
 
diff --git a/runtime/Go/antlr/prediction_context.go b/runtime/Go/antlr/prediction_context.go
index 72d24c3260..4fcad69a9c 100644
--- a/runtime/Go/antlr/prediction_context.go
+++ b/runtime/Go/antlr/prediction_context.go
@@ -376,11 +376,20 @@ func predictionContextFromRuleContext(a *ATN, outerContext RuleContext) Predicti
 }
 
 func merge(a, b PredictionContext, rootIsWildcard bool, mergeCache *DoubleDict) PredictionContext {
-	// share same graph if both same
-	if a == b {
+
+	// Share same graph if both same
+	//
+	if a == b || a.Equals(b) {
 		return a
 	}
 
+	// In Java, EmptyPredictionContext inherits from SingletonPredictionContext, and so the test
+	// in java for SingletonPredictionContext will succeed and a new ArrayPredictionContext will be created
+	// from it.
+	// In go, EmptyPredictionContext does not equate to SingletonPredictionContext and so that conversion
+	// will fail. We need to test for both Empty and Singleton and create an ArrayPredictionContext from
+	// either of them.
+
 	ac, ok1 := a.(*BaseSingletonPredictionContext)
 	bc, ok2 := b.(*BaseSingletonPredictionContext)
 
@@ -397,14 +406,30 @@ func merge(a, b PredictionContext, rootIsWildcard bool, mergeCache *DoubleDict)
 			return b
 		}
 	}
-	// convert singleton so both are arrays to normalize
-	if _, ok := a.(*BaseSingletonPredictionContext); ok {
-		a = NewArrayPredictionContext([]PredictionContext{a.GetParent(0)}, []int{a.getReturnState(0)})
+
+	// Convert Singleton or Empty so both are arrays to normalize - We should not use the existing parameters
+	// here.
+	//
+	// TODO: I think that maybe the Prediction Context structs should be redone as there is a chance we will see this mess again - maybe redo the logic here
+
+	var arp, arb *ArrayPredictionContext
+	var ok bool
+	if arp, ok = a.(*ArrayPredictionContext); ok {
+	} else if _, ok = a.(*BaseSingletonPredictionContext); ok {
+		arp = NewArrayPredictionContext([]PredictionContext{a.GetParent(0)}, []int{a.getReturnState(0)})
+	} else if _, ok = a.(*EmptyPredictionContext); ok {
+		arp = NewArrayPredictionContext([]PredictionContext{}, []int{})
 	}
-	if _, ok := b.(*BaseSingletonPredictionContext); ok {
-		b = NewArrayPredictionContext([]PredictionContext{b.GetParent(0)}, []int{b.getReturnState(0)})
+
+	if arb, ok = b.(*ArrayPredictionContext); ok {
+	} else if _, ok = b.(*BaseSingletonPredictionContext); ok {
+		arb = NewArrayPredictionContext([]PredictionContext{b.GetParent(0)}, []int{b.getReturnState(0)})
+	} else if _, ok = b.(*EmptyPredictionContext); ok {
+		arb = NewArrayPredictionContext([]PredictionContext{}, []int{})
 	}
-	return mergeArrays(a.(*ArrayPredictionContext), b.(*ArrayPredictionContext), rootIsWildcard, mergeCache)
+
+	// Both arp and arb
+	return mergeArrays(arp, arb, rootIsWildcard, mergeCache)
 }
 
 // Merge two {@link SingletonBasePredictionContext} instances.
@@ -677,6 +702,7 @@ func mergeArrays(a, b *ArrayPredictionContext, rootIsWildcard bool, mergeCache *
 
 	// if we created same array as a or b, return that instead
 	// TODO: track whether this is possible above during merge sort for speed
+	// TODO: In go, I do not think we can just do M == xx as M is a brand new allocation. This could be causing allocation problems
 	if M == a {
 		if mergeCache != nil {
 			mergeCache.set(a.Hash(), b.Hash(), a)
diff --git a/tool/resources/org/antlr/v4/tool/templates/codegen/Go/Go.stg b/tool/resources/org/antlr/v4/tool/templates/codegen/Go/Go.stg
index 15df5efbf4..f33a0ee832 100644
--- a/tool/resources/org/antlr/v4/tool/templates/codegen/Go/Go.stg
+++ b/tool/resources/org/antlr/v4/tool/templates/codegen/Go/Go.stg
@@ -879,7 +879,7 @@ QRetValueRef(a) ::= "<ctx(a)>.Get<a.dict;format={cap}>().Get<a.escapedName;forma
 /** How to translate $tokenLabel */
 TokenRef(t) ::= "<ctx(t)>.Get<t.escapedName;format={cap}>()"
 LabelRef(t) ::= "<ctx(t)>.Get<t.escapedName;format={cap}>()"
-ListLabelRef(t) ::= "<ctx(t)>.Get<ListLabelName(t.escapedName);format={cap}>"
+ListLabelRef(t) ::= "<ctx(t)>.Get<t.escapedName;format={cap}>()"
 
 SetAttr(s, rhsChunks) ::= "<ctx(s)>.Set<s.escapedName; format={cap}>(<rhsChunks>)"