在Javac中解语法糖主要是Lower类来完成，调用这个类的入口函数translateTopLevelClass即可。这个方法只是JavacCompiler类的desugar方法中进行了调用。
首先来看下local class本地类解语法糖，举个例子，如下：
class Outer {
class AOuter{
int temp = 0;
}
final int count1 = new Integer(1);
final int count2 = 1;
static final int count3 = new Integer(1);
public void method(final int count4) {
final int count5 = new Integer(1);
final int count6 = 1;
class Inner {
int a = count1; // 传入Outer实现对象后通过outer.count1获取
int b = count2; // 直接写为1
int c = count3; // 通过Outer.count3获取
int d = count4; // 需要构造函数传入
int e = count5; // 需要构造函数传入
int f = count6; // 直接写为1
AOuter aOuter = new AOuter();
}
}
}
对于内部类Inner来说，其实在生成class文件时也是一个独立的class文件，在处理时完全看成一个独立的类来处理，生成时的类名规则为：
和普通内部类的区别是， 普通内部类的class文件名为Outer$Inner.class 。 而定义在方法中的内部类的class文件名为Outer$Inner.class 。 N代表数字， 如1， 2， 3 等 。 在外部类第一个方法中定义的内部类， 编号为1， 同理在外部类第二个方法中定义的内部类编号为2， 在外部类中第N个方法中定义的内部类编号为N 。方中的内部类也有自己独立的class文件,其内容如下：
package com.test15;
import com.test15.Outer.AOuter;
class Outer$1Inner {
int a;
int b;
int c;
int d;
int e;
int f;
AOuter aOuter;
Outer$1Inner(Outer var1, int var2, int var3) {
this.this$0 = var1;
this.val$count4 = var2;
this.val$count5 = var3;
this.a = this.this$0.count1;
this.b = 1;
this.c = Outer.count3;
this.d = this.val$count4;
this.e = this.val$count5;
this.f = 1;
this.aOuter = new AOuter(this.this$0);
}
}
Outer的class类反编译后如下：
package com.test15;
class Outer {
final int count1 = (new Integer(1)).intValue();
final int count2 = 1;
static final int count3 = (new Integer(1)).intValue();
Outer() {
}
public void method(int var1) {
int var2 = (new Integer(1)).intValue();
class Inner {
int a;
int b;
int c;
int d;
int e;
int f;
Outer.AOuter aOuter;
Inner(int var2, int var3) {
this.val$count4 = var2;
this.val$count5 = var3;
this.a = Outer.this.count1;
this.b = 1;
this.c = Outer.count3;
this.d = this.val$count4;
this.e = this.val$count5;
this.f = 1;
this.aOuter = Outer.this.new AOuter();
}
}
}
class AOuter {
int temp = 0;
AOuter() {
}
}
}
Outer$AOuter的class文件反编译后如下：
package com.test15;
class Outer$AOuter {
int temp;
Outer$AOuter(Outer var1) {
this.this$0 = var1;
this.temp = 0;
}
}
可以看到会为Outer$1Inner合成了两个变量val2，val3，由于其它是constant variable，而非free variable。在为内部类合成变量时，需要首先收集free variable，主要是通过freevars()方法来完成，具体代码如下：
/** Return the variables accessed from within a local class, * which are declared in the local class' owner. * (in reverse order of first access). */ Listfreevars(ClassSymbol c) { // 如果类符号c所属的符号为变量或者方法时表明这是一个local class if ((c.owner.kind & (VAR | MTH)) != 0) { List fvs = freevarCache.get(c); if (fvs == null) { FreeVarCollector collector = new FreeVarCollector(c); JCClassDecl jcd = classDef(c); collector.scan(jcd); fvs = collector.fvs; freevarCache.put(c, fvs); } return fvs; } else { return List.nil(); } }
在如上的实例中，收集到的自由变量为count4与count5。
主要还是通过FreeVarCollecotr这个继承了TreeScanner类的类来完成对自由变量的收集，这个类的实现代码如下：
/** A navigator class for collecting the free variables accessed from a local class.
* There is only one case; all other cases simply traverse down the tree.
*/
class FreeVarCollector extends TreeScanner {
/** The owner of the local class.
*/
Symbol owner;
/** The local class.
*/
ClassSymbol clazz;
/** The list of owner's variables accessed from within the local class,without any duplicates.
*/
List fvs;
FreeVarCollector(ClassSymbol clazz) {
this.clazz = clazz;
this.owner = clazz.owner;
this.fvs = List.nil();
}
/** Add free variable to fvs list unless it is already there.
*/
private void addFreeVar(VarSymbol v) {
for (List l = fvs; l.nonEmpty(); l = l.tail)
if (l.head == v) return;
fvs = fvs.prepend(v);
}
/** Add all free variables of class c to fvs list
* unless they are already there.
*/
private void addFreeVars(ClassSymbol c) {
List fvs = freevarCache.get(c);
if (fvs != null) {
for (List l = fvs; l.nonEmpty(); l = l.tail) {
addFreeVar(l.head);
}
}
}
/** If tree refers to a variable in owner of local class, add it to free variables list.
*/
public void visitIdent(JCIdent tree) {
result = tree;
visitSymbol(tree.sym);
}
// where
private void visitSymbol(Symbol _sym) {
Symbol sym = _sym;
if (sym.kind == VAR || sym.kind == MTH) {
while (sym != null && sym.owner != owner){
Name name = proxyName(sym.name);
sym = proxies.lookup(name).sym;
}
if (sym != null && sym.owner == owner) {
VarSymbol v = (VarSymbol)sym;
if (v.getConstValue() == null) {
addFreeVar(v);
}
} else {
if (outerThisStack.head != null &&
outerThisStack.head != _sym)
visitSymbol(outerThisStack.head);
}
}
}
/** If tree refers to a class instance creation expression
* add all free variables of the freshly created class.
*/
public void visitNewClass(JCNewClass tree) {
ClassSymbol c = (ClassSymbol)tree.constructor.owner;
addFreeVars(c);
if (tree.encl == null &&
c.hasOuterInstance() &&
outerThisStack.head != null)
visitSymbol(outerThisStack.head);
super.visitNewClass(tree);
}
/** If tree refers to a qualified this or super expression
* for anything but the current class, add the outer this
* stack as a free variable.
*/
public void visitSelect(JCFieldAccess tree) {
if ((tree.name == names._this || tree.name == names._super) &&
tree.selected.type.tsym != clazz &&
outerThisStack.head != null)
visitSymbol(outerThisStack.head);
super.visitSelect(tree);
}
/** If tree refers to a superclass constructor call,
* add all free variables of the superclass.
*/
public void visitApply(JCMethodInvocation tree) {
if (TreeInfo.name(tree.meth) == names._super) {
addFreeVars((ClassSymbol) TreeInfo.symbol(tree.meth).owner);
Symbol constructor = TreeInfo.symbol(tree.meth);
ClassSymbol c = (ClassSymbol)constructor.owner;
if (c.hasOuterInstance() &&
tree.meth.getTag() != JCTree.SELECT &&
outerThisStack.head != null)
visitSymbol(outerThisStack.head);
}
super.visitApply(tree);
}
} // end class
/** Return the variables accessed from within a local class, which
* are declared in the local class' owner.
* (in reverse order of first access).
*/
List freevars(ClassSymbol c) {
if ((c.owner.kind & (VAR | MTH)) != 0) {
List fvs = freevarCache.get(c);
if (fvs == null) {
FreeVarCollector collector = new FreeVarCollector(c);
JCClassDecl jcd = classDef(c);
collector.scan(jcd);
fvs = collector.fvs;
freevarCache.put(c, fvs);
}
return fvs;
} else {
return List.nil();
}
}
必定上面的例子，具体代码如下：
public class Outer {
class AOuter{
int temp = 0;
}
final int count1 = new Integer(1);
final int count2 = 1;
static final int count3 = new Integer(1);
public void method(final int count4) {
final int count5 = new Integer(1);
final int count6 = 1;
class Inner {
int a = count1;
int b = count2;
int c = count3;
int d = count4;
int e = count5;
int f = count6;
AOuter aOuter = new AOuter();
}
class Inner2{
Inner x = new Inner();
}
}
}
则生成后的Inner2类的代码如下：
class Outer$1Inner2 {
/*synthetic*/ final Outer this$0;
/*synthetic*/ final int val$count4;
/*synthetic*/ final int val$count5;
Outer$1Inner2(/*synthetic*/ final Outer this$0, /*synthetic*/ final int val$count5, /*synthetic*/ final int val$count4) {
this.this$0 = this$0;
this.val$count5 = val$count5;
this.val$count4 = val$count4;
super();
}
Outer$1Inner x = new Outer$1Inner(this$0, val$count4, val$count5);
}