- uncurry all symbol and tree types (@see UnCurryPhase) -- this includes normalizing all proper types.

• for every curried parameter list: (ps_1) ... (ps_n) ==> (ps_1, ..., ps_n)
• for every curried application: f(args_1)...(args_n) ==> f(args_1, ..., args_n)
• for every type application: f[Ts] ==> f[Ts]() unless followed by parameters
• for every use of a parameterless function: f ==> f() and q.f ==> q.f()
• for every def-parameter: x: => T ==> x: () => T
• for every use of a def-parameter: x ==> x.apply()
• for every argument to a def parameter x: => T': if argument is not a reference to a def parameter: convert argument e to (expansion of) () => e'
• for every repeated Scala parameter x: T*' --> x: Seq[T].
• for every repeated Java parameter x: T...' --> x: Array[T], except: if T is an unbounded abstract type, replace --> x: Array[Object]
• for every method defining repeated parameters annotated with @varargs, generate a synthetic Java-style vararg method
• for every argument list that corresponds to a repeated Scala parameter (a_1, ..., a_n) => (Seq(a_1, ..., a_n))
• for every argument list that corresponds to a repeated Java parameter (a_1, ..., a_n) => (Array(a_1, ..., a_n))
• for every argument list that is an escaped sequence (a_1:_*) => (a_1) (possibly converted to sequence or array, as needed)
• convert implicit method types to method types
• convert non-trivial catches in try statements to matches
• convert non-local returns to throws with enclosing try statements.
• convert try-catch expressions in contexts where there might be values on the stack to a local method and a call to it (since an exception empties the evaluation stack):

meth(x_1,..., try { x_i } catch { ..}, .. x_b0) ==> { def liftedTry$1 = try { x_i } catch { .. } meth(x_1, .., liftedTry$1(), .. ) }

• remove calls to elidable methods and replace their bodies with NOPs when elide-below requires it