Javac语法糖之内部类

在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$<N>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).
 */
List<VarSymbol> freevars(ClassSymbol c)  {
	// 如果类符号c所属的符号为变量或者方法时表明这是一个local class
    if ((c.owner.kind & (VAR | MTH)) != 0) {
        List<VarSymbol> 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<VarSymbol> 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<VarSymbol> 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<VarSymbol> fvs = freevarCache.get(c);
            if (fvs != null) {
                for (List<VarSymbol> 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<VarSymbol> freevars(ClassSymbol c)  {
        if ((c.owner.kind & (VAR | MTH)) != 0) {
            List<VarSymbol> 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);
}