superType, interfaces);
superType, Type.EmptyTypes);
    public Type createType0(Symbol clazz) {	assert types2create.contains(clazz) : Debug.show(clazz);	Type type = (Type)symbols2types.get(clazz);	if (type != null && type instanceof TypeBuilder)	    return type;	TypeBuilder staticType = null;	final Symbol owner = clazz.owner();	final String staticTypeName = owner.isClass()	    ? clazz.nameString()	    : global.primitives.getCLRClassName(clazz);	final String typeName =	    staticTypeName + (clazz.isModuleClass() ? "$" : "");	final scalac.symtab.Type classType = clazz.info();	switch (classType) {	case CompoundType(scalac.symtab.Type[] baseTypes, _):	    Type superType = null;	    Type[] interfaces = null;	    int inum = baseTypes.length;	    if (clazz.isInterface()) {		int baseIndex = 0;		if (baseTypes[0].symbol() == defs.ANY_CLASS) {		    --inum;		    baseIndex = 1;		}		interfaces = new Type[inum];		for (int i = 0; i < inum; i++) {		    assert baseTypes[i + baseIndex].symbol().isInterface();		    interfaces[i] = getType(baseTypes[i + baseIndex].symbol());		}	    } else {		superType = getType(baseTypes[0].symbol());		assert inum > 0;		interfaces = new Type[inum - 1];		for (int i = 1; i < inum; i++)		    interfaces[i - 1] = getType(baseTypes[i].symbol());	    }	    type = (TypeBuilder) symbols2types.get(clazz);	    if (type != null)		return type;	    if (owner.isPackageClass()) {  // i.e. top level class		type = msilModule.DefineType		    (typeName, translateTypeAttributes(clazz.flags, false),		     superType, interfaces);		if (clazz.isModuleClass()) {		    Symbol module = owner.members().lookup(clazz.name.toTermName());		    Symbol linkedClass = module.linkedClass(); 		    if (linkedClass == null || linkedClass.info().isError()) {			staticType = msilModule.DefineType 			    (staticTypeName, 			     translateTypeAttributes(clazz.flags, false), 			     superType, interfaces); 		    }		}	    } else {		final Type outerType = (Type) getType(owner);		// check if the type have not been created by		// the (possible) creation of the outer type		type = (TypeBuilder) symbols2types.get(clazz);		if (type != null)		    return type;		assert outerType instanceof TypeBuilder : Debug.show(clazz);		type = ((TypeBuilder)outerType).DefineNestedType		    (typeName, translateTypeAttributes(clazz.flags, true),		     superType, interfaces);	    }	    break;	default:	    global.fail("Symbol does not have a CompoundType: " +			Debug.show(clazz));	}	typeBuilders.add(type);	map(clazz, type);	if (clazz.isModuleClass() && staticType != null) {	    syms2staticTypes.put(clazz, staticType);	}	for (Scope.SymbolIterator syms = clazz.members().iterator();	     syms.hasNext(); )	    {		Symbol member = syms.next();		if (member.isMethod()) {		    createMethod(member);		    if (staticType != null) {			MethodBase sm = createMethod(staticType, member, true);			syms2staticMethods.put(member, sm);		    }		}		else if (!member.isClass() && !member.isModule()			 && !member.isType())		    createField(member);	    }	// adapted from Erasure; creates abstract method declarations	// for the interface methods for which the class doesn't provide	// implementation (requirement of the CLR)	if (clazz.isClass() && !clazz.isInterface()) {	    Set ifaces = new HashSet(getInterfacesOf(clazz));	    Symbol svper = clazz.parents()[0].symbol();	    ifaces.removeAll(getInterfacesOf(svper));	    for (Iterator i = ifaces.iterator(); i.hasNext(); ) {		Symbol iface = (Symbol)i.next();		for (Scope.SymbolIterator members = 			 iface.members().iterator();		     members.hasNext(); )		    {			Symbol method = members.next();			if (!method.isTerm() || !method.isDeferred()) continue;			Symbol overriding =			    method.overridingSymbol(clazz.info(), true);			if (overriding != method) continue;			Symbol overridden = method			    .overriddenSymbol(clazz.parents()[0], clazz, true);			if (overridden.isNone()) {			    Symbol newMethod = method.cloneSymbol(clazz);			    newMethod.flags = (newMethod.flags & ~Modifiers.JAVA)				| Modifiers.SYNTHETIC | Modifiers.DEFERRED;			    createMethod(newMethod);			}		    }	    }	}	return type;    } // createType()