Create a (source) name for a class symbol s.

Create a (source) name for the class symbol s with a prefix determined by the class symbol in.

If s represents a package object pkg3, then the returned name will be pkg1.pkg2.pkg3.package. If s represents a class Foo nested in package object pkg3 then the returned name is pkg1.pkg2.pk3.Foo.

Note that some objects with special access rights are encoded in names (like qualified privates private[qualifier]). In order to get the right original names, we need to use unexpandedName.

Create a String (source) name for a class symbol s.

Given a class symbol cls, construct a name representing this constructor. For a class:

a.b.Foo

this is:

a;b;Foo;init;

The prefix is important to avoid name hashing all constructors together (see #97), the weird format is necessary to avoid scalac or zinc trying to interpret this name (in particular we should not use '.' and we should not use '<init>'), we use ';' because it is one of the few characters that cannot appear in a valid JVM name.

Return the enclosing class or the module class if it's a module.

Creates a flat (binary) name for a class symbol s.

Return true if symbol shall be ignored, false otherwise.

Return true if type shall be ignored, false otherwise.

Return true if name is empty, false otherwise.

Mangle a JVM symbol name in a format better suited for internal uses by sbt.

Returns true if given tree contains macro attchment. In such case calls func on tree from attachment.

If given tree contains object tree attachment calls func on tree from attachment.

Registers only non-local generated classes in the callback by extracting information about its names and using the names to generate class file paths.

Mimics the previous logic that was present in Analyzer, despite the fact that now we construct the names that the compiler will give to every non-local class independently of genbcode.

Why do we do this? The motivation is that we want to run the incremental algorithm independently of the compiler pipeline. This independence enables us to:

1. Offload the incremental compiler logic out of the primary pipeline and run the incremental phases concurrently. 2. Know before the compilation is completed whether another compilation will or will not be required. This is important to make incremental compilation work with pipelining and enables further optimizations; for example, we can start subsequent incremental compilations before (!) the initial compilation is done. This can buy us ~30-40% faster incremental compiler iterations.

This method only takes care of non-local classes because local classes have no relevance in the correctness of the algorithm and can be registered after genbcode. Local classes are only used to construct the relations of products and to produce the list of generated files + stamps, but names referring to local classes **never** show up in the name hashes of classes' APIs, hence never considered for name hashing.

As local class files are owned by other classes that change whenever they change, we could most likely live without adding their class files to the products relation and registering their stamps. However, to be on the safe side, we will continue to register the local products in Analyzer.

Define common error messages for error reporting and assertions.