Deep nested structure results in "Method too large" error during scalac compilation

Hi,

I’ve got this error message

scalac: Error while emitting io/univalence/avro_serde/Main$
Method too large: io/univalence/avro_serde/Main$.main ([Ljava/lang/String;)V

For the following IDL: https://gist.github.com/fsarradin/da8049e388e39de8e34ba17d24b54457

And for this code

package io.univalence.avro_serde

import com.sksamuel.avro4s.JsonFormat
import com.sksamuel.avro4s.kafka.GenericSerde
import test.entity.Entity

object Main {
  def main(args: Array[String]): Unit = {
    val entitySerde = new GenericSerde[Entity](JsonFormat)
    println(entitySerde)
  }
}

Do you know why I got this message and how to avoid it?

I’m using

• Avro4s 4.0.0
• Scala 2.13.3
• SBT 1.3.13
• SBT-AvroHugger 2.0.0-RC22

[sksamuel]

Hi I’m having this problem as well but the above suggested method still doesn’t work. Here’s dilemma:

• We wrap all implicits in one single object AvroSchemas, and during compilation it throws Method too large: xxx/AvroSchemas$.<init> ()V

like this:

object AvroSchemas {
  implicit val gschema = AvroSchema[Goo]
  implicit val wschema = AvroSchema[Woo]
  implicit val fschema = AvroSchema[Foo]
}

• We then tried separating the implicits and put each in a different object

object gs {
  implicit val gschema = AvroSchema[Goo]
}
object ws {
  implicit val wschema = AvroSchema[Woo]
}
object fs {
  implicit val fschema = AvroSchema[Foo]
}

but then object fs is not benefiting from the above 2 smaller objects.

If try importing gs and ws into fs, then it will say ‘not used’ which will fail compilation because we don’t allow unused import.

What can we do in this case?

avro4s builds schemas using SchemaFor so you could split out the three types, and then add an implicit schema for where you need it.

object gs {
  implicit val gschema = AvroSchema[Goo]
}
object ws {
  implicit val wschema = AvroSchema[Woo]
}
object fs {
  implicit val useG = new SchemaFor[Goo] { .... }
  implicit val useW = new SchemaFor[Woo] { .... }
  implicit val fschema = AvroSchema[Foo]
}

[sksamuel]

If you split up the macro by introducing intermediate schemas it should work.

Eg, if you had

case class Goo(a: String)
case class Woo(a: Int)
case class Foo(a: Goo, b: Woo)

then you can do something like:

implicit val gschema = AvroSchema[Goo]
implicit val wschema = AvroSchema[Woo]
implicit val fschema = AvroSchema[Foo]

This should force the compiler to generate smaller macro methods.

You can try by picking 2 or 3 large nested types and pulling out the implicits. You need to do it for schemas and encoders / decoders.