tpe = (sym.kind == NONE) ? Type.localThisType : Type.ThisType(sym);
tpe = (sym.kind == NONE) ? Type.NoPrefix : Type.ThisType(sym);
    Type getType(int n) {	if (entries[n] == null) {	    int savedBp = bp;	    bp = index[n];	    int tag = bytes[bp++];	    int end = readNat() + bp;	    Type tpe;	    switch (tag) {	    case NOtpe:		tpe = Type.NoType;		break;	    case THIStpe:		Symbol sym = readSymbolRef();		tpe = (sym.kind == NONE) ? Type.localThisType		    : Type.ThisType(sym);		break;	    case SINGLEtpe:                Type prefix = readTypeRef();                Symbol symbol = readSymbolRef();		tpe = symbol.isRoot() ? symbol.thisType() : Type.singleType(prefix, symbol);                // !!! code above is usefull for the transition                // !!! after some time, replace it by the following line:		// !!! tpe = Type.singleType(readTypeRef(), readSymbolRef());		break;	    case CONSTANTtpe:		Type base = readTypeRef();		AConstant value = readConstantRef();		tpe = new Type.ConstantType(base, value);		break;	    case TYPEREFtpe:		tpe = Type.newTypeRefUnsafe( // !!!		    readTypeRef(), readSymbolRef(), readTypeRefs(end));		break;	    case COMPOUNDtpe:		Symbol[] clazzs = readSymbolRefs(end);                assert clazzs.length == 1;		Type[] parents = readTypeRefs(end);                tpe = Type.compoundType(parents, new Scope(), clazzs[0]);		break;	    case METHODtpe:		Type restype = readTypeRef();		int bp1 = bp;		Type[] argtypes = readTypeRefs(end);		int[] flags = new int[argtypes.length];		bp = bp1;		readFlags(flags);		Symbol[] params = new Symbol[argtypes.length];		for (int i = 0; i < argtypes.length; i++) {		    params[i] = new TermSymbol(			Position.NOPOS, Name.fromString("$" + i), 			Symbol.NONE, PARAM | flags[i]);		    params[i].setInfo(argtypes[i]);		}		tpe = Type.MethodType(params, restype);		break;	    case POLYtpe:		Type restype = readTypeRef();		tpe = Type.PolyType(readSymbolRefs(end), restype);		break;	    case OVERLOADEDtpe:		int bp0 = bp;		Symbol[] alts = readSymbolRefs(end);		int bp1 = bp;		Type[] alttypes = readTypeRefs(end);		assert alts.length == alttypes.length 		    : alts.length + "!=" + alttypes.length + 		    " at " + bp0 + "/" + bp1 + "/" + bp;		for (int i = 0; i < alts.length; i++)		    alttypes[i] = alttypes[i].setOwner(alts[i]);		tpe = Type.OverloadedType(alts, alttypes);		break;	    case FLAGGEDtpe:		readNat(); // skip flags		tpe = readTypeRef();		break;	    default:		throw new BadSignature(this);	    }	    entries[n] = tpe;	    bp = savedBp;	}	return (Type) entries[n];    }