scalacompiler-constructionscalac

What is the order of the scala compiler phases?


I want to sharpen my picture of the phases of scala compilation. I know that certain things have to happen in the compiler, but don't really know the order in which they happen and how the order should affect my programming.

Am I right in saying that the following things are the full list of what the compiler does?

If so, what is the order that it does these phases? How does this order affect the programmer, especially the type-level programmer?


Solution

  • You see the phases, their order and explanation by using scalac -Xshow-phases.

    In 2.11, use -Xshow-phases -Ydebug to show both enabled and disabled phases.

    Here is how it's for 2.10.0:

     » scalac -Xshow-phases
    
                 phase name  id  description
                 ----------  --  -----------
                     parser   1  parse source into ASTs, perform simple desugaring
                      namer   2  resolve names, attach symbols to named trees
             packageobjects   3  load package objects
                      typer   4  the meat and potatoes: type the trees
                     patmat   5  translate match expressions
             superaccessors   6  add super accessors in traits and nested classes
                 extmethods   7  add extension methods for inline classes
                    pickler   8  serialize symbol tables
                  refchecks   9  reference/override checking, translate nested objects
               selectiveanf  10  
               selectivecps  11  
                    uncurry  12  uncurry, translate function values to anonymous classes
                  tailcalls  13  replace tail calls by jumps
                 specialize  14  @specialized-driven class and method specialization
              explicitouter  15  this refs to outer pointers, translate patterns
                    erasure  16  erase types, add interfaces for traits
                posterasure  17  clean up erased inline classes
                   lazyvals  18  allocate bitmaps, translate lazy vals into lazified defs
                 lambdalift  19  move nested functions to top level
               constructors  20  move field definitions into constructors
                    flatten  21  eliminate inner classes
                      mixin  22  mixin composition
                    cleanup  23  platform-specific cleanups, generate reflective calls
                      icode  24  generate portable intermediate code
                    inliner  25  optimization: do inlining
    inlineExceptionHandlers  26  optimization: inline exception handlers
                   closelim  27  optimization: eliminate uncalled closures
                        dce  28  optimization: eliminate dead code
                        jvm  29  generate JVM bytecode
                   terminal  30  The last phase in the compiler chain