CODEWITHSUNDEEP
dictionarygroovygstring
Michal Kordas
Michal Kordas

Reputation: 10925

Why I cannot get exactly the same GString as was put to map in Groovy?

With the following snippet I cannot retrieve gString from a map: 

def contents = "contents"
def gString = "$contents"

def map = [(gString): true]

assert map.size() == 1 // Passes
assert gString.hashCode() == map.keySet().first().hashCode() // Passes, same hash code
assert gString.is(map.keySet().first()) // Passes, exactly the same object
assert map[gString] // Fails

How is that possible?

What's interesting here is that map.get(map.keySet()[0]) works fine while map.get[map.keySet()[0]] does not.

Assertion message clearly shows that there's something wrong:

assert map[gString] // Fails
       |  ||
       |  |contents
       |  null
       [contents:true]

It's not the same question as Why groovy does not see some values in dictionary? First answer there suggests:

You're adding GString instances as keys in your map, then searching for them using String instances.

In this question I clearly add GString and try to retrieve GString.

Also neither Why are there different behaviors for the ways of addressing GString keys in maps? nor Groovy different results on using equals() and == on a GStringImpl have an answer for me. I do not mutate anything and I do not mix String with GString. Groovy documentation is not helpful as well.

Upvotes: 3

Views: 501

Answers (1)

Roger Glover
Roger Glover

Reputation: 3256

tl;dr: You seem to have discovered a bug in Groovy's runtime argument overloading evaluation.

Answer:

map[gString] is evaluated as map.getAt(gString) at runtime straightforwardly via Groovy's operator overloading mechanism. So far, so good, but now is where everything starts to go awry. The Java LinkedHashMap class does not have a getAt method anywhere in it's type hierarchy, so Groovy must use dynamically associated mixin methods instead (Actually that statement is sort of reversed. Groovy uses mixin methods before using the declared methods in the class hierarchy.)

So, to make a long story short, Groovy resolves map.getAt(gString) to use the category method DefaultGroovyMethods.getAt(). Easy-peasy, right? Except that this method has a large number of different argument overloads, several of which might apply, especially when you take Groovy's default argument coercion into account.

Unfortunately, instead of choosing DefaultGroovyMethods.getAt(Map<K,V>,K), which would seem to be a perfect match, Groovy chooses DefaultGroovyMethods.getAt(Object,String), which coerces the GString key argument into a String. Since the actual key is in fact a GString, the method ultimately fails to find the value.

To me the real killer is that if the argument overload resolution is performed directly from code (instead of after the operator resolution and the category method selection), then Groovy makes the right overload choice! That is to say, if you replace this expression:

map[gString]

with this expression:

DefaultGroovyMethods.getAt(map,gString)

then the argument overloading is resolved correctly, and the correct value is found and returned.

Upvotes: 3

Related Questions