LAZYPARENTS_CLASS = getJVMClass("scala.runtime.types.LazyParents");
    public Definitions(Global global) {        // make definitions accessible earlier to other components        global.definitions = this;        // create attributed tree typer        atyper = new ATreeTyper(global, this);        // the root class        ROOT_CLASS = ClassSymbol.newRootClass(global);        // the java, java.lang and scala packages        JAVA = getModule("java");        JAVALANG = getModule("java.lang");        SCALA = getModule("scala");        // the top and bottom classes        Symbol SCALA_CLASS = SCALA.moduleClass();        ANY_CLASS = newClass(SCALA_CLASS, Names.Any, 0);        ANYVAL_CLASS = getClass("scala.AnyVal");        ANYREF_CLASS = newAlias(SCALA_CLASS, Names.AnyRef, 0);        ALLREF_CLASS = newClass(SCALA_CLASS, Names.AllRef, Modifiers.ABSTRACT | Modifiers.FINAL);        ALL_CLASS = newClass(SCALA_CLASS, Names.All, Modifiers.ABSTRACT | Modifiers.FINAL);        final boolean forMSIL = global.target == Global.TARGET_MSIL;        // the java classes        OBJECT_CLASS = getClass(forMSIL ? "System.Object" : "java.lang.Object");	STRING_CLASS = getClass(forMSIL ? "System.String" : "java.lang.String");        THROWABLE_CLASS =            getClass(forMSIL ? "System.Exception" : "java.lang.Throwable");	SERIALIZABLE_CLASS = getClass("java.io.Serializable");        // the scala value classes        UNIT_CLASS = getClass("scala.Unit");        BOOLEAN_CLASS = getClass("scala.Boolean");        BYTE_CLASS = getClass("scala.Byte");        SHORT_CLASS = getClass("scala.Short");        CHAR_CLASS = getClass("scala.Char");        INT_CLASS = getClass("scala.Int");        LONG_CLASS = getClass("scala.Long");        FLOAT_CLASS = getClass("scala.Float");        DOUBLE_CLASS = getClass("scala.Double");        // the scala reference classes        SCALAOBJECT_CLASS = getClass("scala.ScalaObject");        ATTRIBUTE_CLASS = getClass("scala.Attribute");        REF_CLASS = getClass("scala.Ref");        for (int i = 1; i < TUPLE_COUNT; i++) {            TUPLE_CLASS[i] = getClass("scala.Tuple" + i);            TUPLE_FIELD[i] = new Symbol[i];        }        for (int i = 0; i < FUNCTION_COUNT; i++)            FUNCTION_CLASS[i] = getClass("scala.Function" + i);        PARTIALFUNCTION_CLASS = getClass("scala.PartialFunction");        ITERABLE_CLASS = getClass("scala.Iterable");        ITERATOR_CLASS = getClass("scala.Iterator");        SEQ_CLASS = getClass("scala.Seq");        LIST_CLASS = getClass("scala.List");        ARRAY_CLASS = getClass("scala.Array");        TYPE_CLASS = getJVMClass("scala.Type");        CLASSTYPE_CLASS = getJVMClass("scala.runtime.types.ClassType");        JAVACLASSTYPE_CLASS = getJVMClass("scala.runtime.types.JavaClassType");        JAVAREFARRAYTYPE_CLASS = getJVMClass("scala.runtime.types.JavaRefArrayType");        SCALACLASSTYPE_CLASS = getJVMClass("scala.runtime.types.ScalaClassType");        SINGLETYPE_CLASS = getJVMClass("scala.runtime.types.SingleType");        TYPECONSTRUCTOR_CLASS = getJVMClass("scala.runtime.types.TypeConstructor");        COMPOUNDTYPE_CLASS = getJVMClass("scala.runtime.types.CompoundType");        PREDEF = getModule("scala.Predef");        CONSOLE = getModule("scala.Console");        MATCHERROR = getModule("scala.MatchError");        // initialize generated classes and aliases        initClass(ANY_CLASS, Type.EMPTY_ARRAY);        initAlias(ANYREF_CLASS, OBJECT_TYPE());        initClass(ALLREF_CLASS, new Type[]{ANYREF_TYPE()});        initClass(ALL_CLASS, new Type[]{ANY_TYPE()});        // create type symbols        void_TYPE    = newTypeMethod(Names.Unit   ,UNIT_TYPE());        boolean_TYPE = newTypeMethod(Names.Boolean,BOOLEAN_TYPE());        byte_TYPE    = newTypeMethod(Names.Byte   ,BYTE_TYPE());        short_TYPE   = newTypeMethod(Names.Short  ,SHORT_TYPE());        char_TYPE    = newTypeMethod(Names.Char   ,CHAR_TYPE());        int_TYPE     = newTypeMethod(Names.Int    ,INT_TYPE());        long_TYPE    = newTypeMethod(Names.Long   ,LONG_TYPE());        float_TYPE   = newTypeMethod(Names.Float  ,FLOAT_TYPE());        double_TYPE  = newTypeMethod(Names.Double ,DOUBLE_TYPE());        array_TYPE   = newTypeMethod(Names.Array  ,ARRAY_TYPE(ANYREF_TYPE()));        // add members to scala.Any        ANY_EQEQ     = newMethod(ANY_CLASS,Names.EQEQ        ,Modifiers.FINAL);        ANY_BANGEQ   = newMethod(ANY_CLASS,Names.BANGEQ      ,Modifiers.FINAL);        ANY_EQUALS   = newMethod(ANY_CLASS,Names.equals      ,0);        ANY_HASHCODE = newMethod(ANY_CLASS,Names.hashCode    ,0);        ANY_TOSTRING = newMethod(ANY_CLASS,Names.toString    ,0);        // ANY_PLUS  = newMethod(ANY_CLASS,Names.PLUS        ,Modifiers.FINAL);        ANY_IS       = newMethod(ANY_CLASS,Names.isInstanceOf,Modifiers.FINAL);        ANY_IS_ERASED= newMethod(ANY_CLASS,Names.isInstanceOfE,Modifiers.FINAL);        ANY_AS       = newMethod(ANY_CLASS,Names.asInstanceOf,Modifiers.FINAL);        ANY_AS_ERASED= newMethod(ANY_CLASS,Names.asInstanceOfE,Modifiers.FINAL);        ANY_MATCH    = newMethod(ANY_CLASS,Names._match      ,Modifiers.FINAL);        initMethod(ANY_EQEQ    , new Type[]{ANY_TYPE()}   , boolean_TYPE());        initMethod(ANY_BANGEQ  , new Type[]{ANY_TYPE()}   , boolean_TYPE());        initMethod(ANY_EQUALS  , new Type[]{ANY_TYPE()}   , boolean_TYPE());        initMethod(ANY_HASHCODE, new Type[]{}             , int_TYPE());        initMethod(ANY_TOSTRING, new Type[]{}             , STRING_TYPE());        // initMethod(ANY_PLUS , new Type[]{STRING_TYPE()}, STRING_TYPE());        Symbol[] ANY_IS_TPARAMS = {newTParam(ANY_IS, 0, ANY_TYPE())};        ANY_IS.setInfo(Type.PolyType(ANY_IS_TPARAMS, boolean_TYPE()));        Symbol[] ANY_IS_ERASED_TPARAMS =            {newTParam(ANY_IS_ERASED, 0, ANY_TYPE())};        ANY_IS_ERASED.setInfo(Type.PolyType(ANY_IS_ERASED_TPARAMS,                                            boolean_TYPE()));        Symbol[] ANY_AS_TPARAMS = {newTParam(ANY_AS, 0, ANY_TYPE())};        ANY_AS.setInfo(Type.PolyType(ANY_AS_TPARAMS,ANY_AS_TPARAMS[0].type()));        Symbol[] ANY_AS_ERASED_TPARAMS =            {newTParam(ANY_AS_ERASED, 0, ANY_TYPE())};        ANY_AS_ERASED.setInfo(Type.PolyType(ANY_AS_ERASED_TPARAMS,                                            ANY_AS_ERASED_TPARAMS[0].type()));        Symbol[] ANY_MATCH_TPARAMS = {            newTParam(ANY_MATCH, 0, ANY_TYPE()),            newTParam(ANY_MATCH, 1, ANY_TYPE())};        Symbol[] ANY_MATCH_VPARAMS = {            newVParam(ANY_MATCH, 0, FUNCTION_TYPE(                new Type[]{ANY_MATCH_TPARAMS[0].type()},                ANY_MATCH_TPARAMS[1].type()))};        ANY_MATCH.setInfo(            Type.PolyType(                ANY_MATCH_TPARAMS,                Type.MethodType(                    ANY_MATCH_VPARAMS,                    ANY_MATCH_TPARAMS[1].type())));        // add members to java.lang.Object        OBJECT_EQ =            newMethod(OBJECT_CLASS, Names.eq, Modifiers.FINAL);        OBJECT_NE =            newMethod(OBJECT_CLASS, Names.ne, Modifiers.FINAL);        OBJECT_SYNCHRONIZED =            newMethod(OBJECT_CLASS, Names.synchronized_, Modifiers.FINAL);        initMethod(OBJECT_EQ, new Type[]{ANYREF_TYPE()}, boolean_TYPE());        initMethod(OBJECT_NE, new Type[]{ANYREF_TYPE()}, boolean_TYPE());        Symbol OBJECT_SYNCHRONIZED_TPARAM =            newTParam(OBJECT_SYNCHRONIZED,0,ANY_TYPE());        Symbol OBJECT_SYNCHRONIZED_VPARAM =            newVParam(OBJECT_SYNCHRONIZED,0,OBJECT_SYNCHRONIZED_TPARAM.type());        OBJECT_SYNCHRONIZED.setInfo(            Type.PolyType(                new Symbol[] {OBJECT_SYNCHRONIZED_TPARAM},                Type.MethodType(                    new Symbol[] {OBJECT_SYNCHRONIZED_VPARAM},                    OBJECT_SYNCHRONIZED_TPARAM.type())));	if (forMSIL) {	    Symbol WAIT0 = newMethod(OBJECT_CLASS, Names.wait, Modifiers.FINAL);	    initMethod(WAIT0, Type.EMPTY_ARRAY, UNIT_TYPE());	    Symbol WAIT1 = newMethod(OBJECT_CLASS, Names.wait, Modifiers.FINAL);	    initMethod(WAIT1, new Type[]{LONG_TYPE()}, UNIT_TYPE());	    Symbol WAIT2 = newMethod(OBJECT_CLASS, Names.wait, Modifiers.FINAL);	    initMethod(WAIT2, new Type[]{LONG_TYPE(), INT_TYPE()}, UNIT_TYPE());	    Symbol NOTIFY =		newMethod(OBJECT_CLASS, Names.notify, Modifiers.FINAL);	    initMethod(NOTIFY, Type.EMPTY_ARRAY, UNIT_TYPE());	    Symbol NOTIFY_ALL =		newMethod(OBJECT_CLASS, Names.notifyAll, Modifiers.FINAL);	    initMethod(NOTIFY_ALL, Type.EMPTY_ARRAY, UNIT_TYPE());	    Symbol JLOA = newAlias(JAVALANG, Names.Object, 0);	    initAlias(JLOA, OBJECT_TYPE());	}        // add members to java.lang.String        STRING_PLUS = newMethod(STRING_CLASS, Names.PLUS, Modifiers.FINAL);        initMethod(STRING_PLUS, new Type[]{ANY_TYPE()}, STRING_TYPE());	if (forMSIL) {	    Symbol s = newMethod(STRING_CLASS, Name.fromString("length"), 0);	    initMethod(s, Type.EMPTY_ARRAY, INT_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("compareTo"), 0);	    initMethod(s, new Type[] {STRING_TYPE()}, INT_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("charAt"), 0);	    initMethod(s, new Type[] {INT_TYPE()}, CHAR_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("concat"), 0);	    initMethod(s, new Type[] {STRING_TYPE()}, STRING_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("indexOf"), 0);	    initMethod(s, new Type[] {INT_TYPE()}, INT_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("indexOf"), 0);	    initMethod(s, new Type[] {INT_TYPE(), INT_TYPE()}, INT_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("indexOf"), 0);	    initMethod(s, new Type[] {STRING_TYPE()}, INT_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("indexOf"), 0);	    initMethod(s, new Type[] {STRING_TYPE(), INT_TYPE()}, INT_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("lastIndexOf"), 0);	    initMethod(s, new Type[] {INT_TYPE()}, INT_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("lastIndexOf"), 0);	    initMethod(s, new Type[] {INT_TYPE(), INT_TYPE()}, INT_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("lastIndexOf"), 0);	    initMethod(s, new Type[] {STRING_TYPE()}, INT_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("lastIndexOf"), 0);	    initMethod(s, new Type[] {STRING_TYPE(), INT_TYPE()}, INT_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("toLowerCase"), 0);	    initMethod(s, Type.EMPTY_ARRAY, STRING_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("toUpperCase"), 0);	    initMethod(s, Type.EMPTY_ARRAY, STRING_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("startsWith"), 0);	    initMethod(s, new Type[]{STRING_TYPE()}, BOOLEAN_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("endsWith"), 0);	    initMethod(s, new Type[]{STRING_TYPE()}, BOOLEAN_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("substring"), 0);	    initMethod(s, new Type[]{INT_TYPE()}, STRING_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("substring"), 0);	    initMethod(s, new Type[]{INT_TYPE(), INT_TYPE()}, STRING_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("intern"), 0);	    initMethod(s, Type.EMPTY_ARRAY, STRING_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("replace"), 0);	    initMethod(s, new Type[]{CHAR_TYPE(), CHAR_TYPE()}, STRING_TYPE());	    s = newMethod(STRING_CLASS, Name.fromString("toCharArray"), 0);	    initMethod(s, Type.EMPTY_ARRAY, array_TYPE(CHAR_TYPE()));	    Symbol JLSA = newAlias(JAVALANG, Names.String, 0);	    initAlias(JLSA, STRING_TYPE());	}        // add members to java.lang.Throwable        THROWABLE_THROW =            newMethod(THROWABLE_CLASS, Names.throw_, Modifiers.FINAL);        THROWABLE_THROW.setInfo(Type.PolyType(Symbol.EMPTY_ARRAY, ALL_TYPE()));        // create global values        PATTERN_WILDCARD = Symbol.NONE.newTerm(            Position.NOPOS, 0, Names.PATTERN_WILDCARD);        PATTERN_WILDCARD.setInfo(ALL_TYPE());        // initialize unboxed types in class Type        Type.initializeUnboxedTypes(this);    }