Does ImmutableMap.Builder have a limit?

I have a class that looks something like this:

public enum Animal {
   BEAR,
   SHEEP,
   LION;

   private static final Map<String, Animal> MAPPING = new ImmutableMap.Builder<String, Animal>()
      .put("BLACK_BEAR", BEAR)
      .put("WHITE_BEAR", BEAR)
      ...
      .put("African Lion", LION)
      .build()
}

About 1500 map entries.

I try to build my application and I get the following error:

    [javac] An annotation processor threw an uncaught exception.
    [javac] Consult the following stack trace for details.
    [javac] java.lang.StackOverflowError
    [javac] 	at lombok.javac.JavacAST.buildTree(JavacAST.java:200)
    [javac] 	at lombok.javac.JavacAST.buildTree(JavacAST.java:67)
    [javac] 	at lombok.core.AST.buildWithField0(AST.java:386)
    [javac] 	at lombok.core.AST.buildWithField(AST.java:284)
    [javac] 	at lombok.javac.JavacAST.drill(JavacAST.java:374)
    [javac] 	at lombok.javac.JavacAST.buildStatementOrExpression(JavacAST.java:340)
    [javac] 	at lombok.javac.JavacAST.buildTree(JavacAST.java:200)
    [javac] 	at lombok.javac.JavacAST.buildTree(JavacAST.java:67)
    [javac] 	at lombok.core.AST.buildWithField0(AST.java:386)
    [javac] 	at lombok.core.AST.buildWithField(AST.java:284)
    [javac] 	at lombok.javac.JavacAST.drill(JavacAST.java:374)
    [javac] 	at lombok.javac.JavacAST.buildStatementOrExpression(JavacAST.java:340)
    [javac] 	at lombok.javac.JavacAST.buildTree(JavacAST.java:200)
    [javac] 	at lombok.javac.JavacAST.buildTree(JavacAST.java:67)
    [javac] 	at lombok.core.AST.buildWithField0(AST.java:386)
    [javac] 	at lombok.core.AST.buildWithField(AST.java:284)
    [javac] 	at lombok.javac.JavacAST.drill(JavacAST.java:374)
    [javac] 	at lombok.javac.JavacAST.buildStatementOrExpression(JavacAST.java:340)
    [javac] 	at lombok.javac.JavacAST.buildTree(JavacAST.java:200)
    [javac] 	at lombok.javac.JavacAST.buildTree(JavacAST.java:67)
    [javac] 	at lombok.core.AST.buildWithField0(AST.java:386)
    [javac] 	at lombok.core.AST.buildWithField(AST.java:284)

I tried reducing the size of the map to 15ish and it builds fine. Is there a limit to the size we can harcode a static immutable map? I didn't see any limitation in the documentation. What could the issue be?

It's not ImmutableBuilder; it's the fact that your source file is now such a gigantic pile of AST nodes that lombok's processing ends up taking too much memory, which, I guess, given that javac can handle it, is technically a bug in lombok. In other words, the compiler can't manage to turn your java file into a class file, but if it could, it would work fine*.

I would in general consider any source file that tries to define that much data in source as a code smell.

I suggest you take whatever data this is and put it in a text file.

Put this text file together with your source files; if you use maven / the more or less standard source dir structure, you'd have, say:

src/main/java/com/foo/yourpkg/Animal.java
src/main/resources/com/foo/yourpkg/AnimalData.txt

which will automatically result in the txt file being in the same place as your class file is, even in jars. Then, to read it, from within your animal file:

public enum Animal {

    private static final Map<String, Animal> MAPPING;
    static {
        try {
            Map<String, String> example = new HashMap<String, String>();
            try (var in = Animal.class.getResourceAsStream("AnimalData.txt")) {
                BufferedReader br = new BufferedReader(new InputStreamReader(
                  in, StandardCharsets.UTF_8));

                for (String line = br.readLine(); line != null; line = br.readLine()) {
                    String[] p = line.split("\t", 2);
                    map.put(p[0], p[1]);
                }
            }
            MAPPING = Collections.unmodifiableMap(map);
        } catch (IOException e) {
            throw new InternalError("data corrupted");
        }
    }
}

This hypothetical example would require you to put tab-separated string pairs in the text file. You can use this example and adjust it to your needs.

DISCLAIMER: I'm a core contributor of lombok, but this is about as low a priority as I can imagine, and we have plenty of bug reports to dig through before we'd get to 'out of memory issues if you try to do a 1500-size immutablemap builder in source'.

*) Possibly; class files have limits too, it's possible if you remove lombok or add memory, that the compiler will in a later phase still end up refusing to compile this code because it would blow past the 64k bytecode limit on your initialization.

I agree with @rzwitserloot above, but there are some things you could try:

1. Just increase your stack size by adding -Xss4m (or higher) to the jvm that's running your build.
2. edit As the enum itself is small, you could do this:

package org.example;

import java.util.HashMap;
import java.util.Map;

public enum Animal {
    BEAR("white bear", "black bear", "brown bear"),
    DOG("mongrel", "cross"),
    CAT("blah3");

    private final String[] blah1;

    private static final Map<String, Animal> MAPPING = new HashMap<>();

    static {
        for (Animal animal: Animal.values()) {
            for (String tag : animal.blah1) {
                MAPPING.put(tag, animal);
            }
        }
    }

    Animal(String... blah1) {
        this.blah1 = blah1;
    }


    public static void main(String... s) {
        String animal = "black bear";
        System.out.println(" A " + animal + " is a " + MAPPING.get(animal));
    }
}