org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ModuleEnvironment.java - jdt/eclipse.jdt.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2016 IBM Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * This is an implementation of an early-draft specification developed under the Java
  * Community Process (JCP) and is made available for testing and evaluation purposes
  * only. The code is not compatible with any specification of the JCP.
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.lookup;

 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.Set;

 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.ast.ExportReference;
 import org.eclipse.jdt.internal.compiler.ast.ModuleDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.ModuleReference;
 import org.eclipse.jdt.internal.compiler.ast.TypeReference;
 import org.eclipse.jdt.internal.compiler.env.IModule;
 import org.eclipse.jdt.internal.compiler.env.IModuleLocation;
 import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
 import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
 import org.eclipse.jdt.internal.compiler.util.JRTUtil;

 public abstract class ModuleEnvironment implements INameEnvironment {
 	/*
 	 * Keeps track of packages mapped to modules
 	 * Knows how to get modules
 	 * Understands modules
 	 * Understand module dependencies and restrictions
 	 * Given a ModuleDeclaration, creates an IModule
 	 * TODO: This should kick-in only when source level is >= 9
 	 */
 	public static final char[] UNNAMED = "UNNAMED".toCharArray(); //$NON-NLS-1$
 	public static final IModule UNNAMED_MODULE = new IModule() {
 		@Override
 		public char[][] uses() {
 			return null;
 		}
 		@Override
 		public IModuleReference[] requires() {
 			return null;
 		}
 		@Override
 		public IService[] provides() {
 			return null;
 		}
 		@Override
 		public char[] name() {
 			return UNNAMED;
 		}
 		@Override
 		public IPackageExport[] exports() {
 			return null;
 		}
 		@Override
 		public String toString() {
 			return new String(UNNAMED);
 		}
 	};
 	public static IModule[] UNNAMED_MODULE_ARRAY = new IModule[]{UNNAMED_MODULE};
 	private HashMap<String, IModule> modulesCache = null;
 	private static HashMap<IModuleLocation, IModule> ModuleLocationMap = new HashMap<>();

 	public ModuleEnvironment() {
 		this.modulesCache = new HashMap<>();
 	}

 	public NameEnvironmentAnswer findType(char[][] compoundTypeName, char[] client) {
 		NameEnvironmentAnswer answer = findType(compoundTypeName, getVisibleModules(client));
 		return answer;
 	}

 	public NameEnvironmentAnswer findType(char[] typeName, char[][] packageName, char[] client) {
 		NameEnvironmentAnswer answer = findType(typeName, packageName, getVisibleModules(client));
 		char[] module = null;
 		if(answer == null || (module = answer.moduleName()) == null ||
 				CharOperation.equals(module, JRTUtil.JAVA_BASE_CHAR)) {
 			return answer;
 		}
 		return returnAnswerAfterValidation(packageName, answer, client);
 	}

 	protected NameEnvironmentAnswer returnAnswerAfterValidation(char[][] packageName, NameEnvironmentAnswer answer, char[] client) {
 		if (isPackageVisible(CharOperation.concatWith(packageName, '.'), answer.moduleName(), client)) {
 			return answer;
 		}
 		return null;
 	}

 	public boolean isPackage(char[][] parentPackageName, char[] packageName, char[] client) {
 		return isPackage(parentPackageName, packageName, getVisibleModules(client));
 	}

 	public abstract NameEnvironmentAnswer findType(char[][] compoundTypeName, IModule[] modules);

 	public abstract NameEnvironmentAnswer findType(char[] typeName, char[][] packageName, IModule[] modules);

 	public abstract boolean isPackage(char[][] parentPackageName, char[] packageName, IModule[] module);

 //	public abstract IModule getModule(String name);
 //	{
 ////		IModule mod = this.modulesCache.get(name);
 ////		if (mod == null) {
 ////
 ////		}
 ////		return mod;
 //		for ()
 //	}

 	public boolean isPackageVisible(char[] packageName, char[] sourceName, char[] clientName) {
 		boolean clientIsUnnamed = clientName == null || clientName == UNNAMED;
 		if (clientIsUnnamed)
 			return true; // Unnamed module can read every module
 		if (sourceName == null || sourceName == UNNAMED)
 			return clientIsUnnamed; // Unnamed module cannot be read by any named module

 		if (CharOperation.equals(sourceName, clientName))
 			return true;

 		IModule source = getModule(sourceName);
 		IModule client = getModule(clientName);
 		if (client != null) {
 			IModule.IModuleReference[] requires = client.requires();
 			if (requires != null && requires.length > 0) {
 				for (IModule.IModuleReference ref : requires) {
 					IModule refModule = getModule(ref.name());
 					if (refModule == null)
 						continue;
 					if (refModule == source && isPackageExportedTo(refModule, packageName, client)) {
 						return true;
 					}
 					Set<IModule> set = new LinkedHashSet<>();
 					collectAllVisibleModules(refModule, set, true);
 					IModule[] targets = set.toArray(new IModule[set.size()]);
 					for (IModule iModule : targets) {
 						if (iModule == source && isPackageExportedTo(iModule, packageName, client)) {
 							return true;
 						}
 					}
 				}
 			}
 			return false;
 		}
 		return true;
 	}

 	private boolean isPackageExportedTo(IModule module, char[] pack, IModule client) {
 		IModule.IPackageExport[] exports = module.exports();
 		if (exports != null && exports.length > 0) {
 			for (IModule.IPackageExport iPackageExport : exports) {
 				if (CharOperation.equals(iPackageExport.name(), pack)) {
 					char[][] exportedTo = iPackageExport.exportedTo();
 					if (exportedTo == null || exportedTo.length == 0) {
 						return true;
 					}
 					for (char[] cs : exportedTo) {
 						if (CharOperation.equals(cs, client.name())) {
 							return true;
 						}
 					}

 				}
 			}
 		}
 		return false;
 	}

 	public IModule[] getVisibleModules(char[] mod) {
 		IModule[] targets = null;
 		if (mod != null && !CharOperation.equals(mod, UNNAMED)) {
 			Set<IModule> set = new LinkedHashSet<>();
 			IModule client = getModule(JRTUtil.JAVA_BASE.toCharArray());
 			if (client != null) set.add(client);
 			client = getModule(mod);
 			if (client != null) {
 				set.add(client);
 				collectAllVisibleModules(client, set, false);
 				targets = set.toArray(new IModule[set.size()]);
 			}
 		} else {
 			return UNNAMED_MODULE_ARRAY;
 		}
 		return targets;
 	}

 	private void collectAllVisibleModules(IModule module, Set<IModule> targets, boolean onlyPublic) {
 		if (module != null) {
 			IModule.IModuleReference[] requires = module.requires();
 			if (requires != null && requires.length > 0) {
 				for (IModule.IModuleReference ref : requires) {
 					IModule refModule = getModule(ref.name());
 					if (refModule != null) {
 						if (!onlyPublic || ref.isPublic()) {
 						targets.add(refModule);
 						collectAllVisibleModules(refModule, targets, true);
 						}
 					}
 				}
 			}
 		}
 	}
 	/**
 	 * Returns the module with the given name from the name environment.
 	 *
 	 * @param name the name of the module to lookup
 	 * @return the module with the given name
 	 */
 //	public IModule getModule(final char[] name) {
 ////		if (name == null) return null;
 ////		String mod = new String(name);
 ////		IModule module = this.modulesCache.get(mod);
 ////		return module;
 //		return name == null ? null : getModule(CharOperation.charToString(name));
 //	}
 	/**
 	 * Accepts the given module to be served later on requests. If
 	 * any older copies of module already present, they will be
 	 * overwritten by the new one.
 	 *
 	 * @param mod the module to be stored in memory
 	 */
 	public void acceptModule(IModule mod, IModuleLocation location) {
 		IModule existing = ModuleEnvironment.ModuleLocationMap.get(location);
 		if (existing != null) {
 			if (existing.equals(mod))
 				return;
 			else {
 				// Report problem and ignore the duplicate
 			}
 		}
 		String name = new String(mod.name());
 		this.modulesCache.put(name, mod);
 		ModuleEnvironment.ModuleLocationMap.put(location, mod);
 	}

 	@Override
 	public IModule getModule(IModuleLocation location) {
 		IModule module = ModuleEnvironment.ModuleLocationMap.get(location);
 		if (module == null)
 			return null;
 		String modName = new String(module.name());
 		if (this.modulesCache.get(modName) == null) {
 			this.modulesCache.put(modName, module);
 		}
 		return module;
 	}
 	public static Module createModule(ModuleDeclaration module) {
 		Module mod = new Module();
 		mod.name = module.moduleName;
 		if (module.requiresCount > 0) {
 			ModuleReference[] refs = module.requires;
 			mod.requires = new ModuleReferenceImpl[refs.length];
 			for (int i = 0; i < refs.length; i++) {
 				mod.requires[i] = new ModuleReferenceImpl();
 				mod.requires[i].name = CharOperation.concatWith(refs[i].tokens, '.');
 				mod.requires[i].isPublic = refs[i].isPublic();
 			}
 		} else {
 			mod.requires = new ModuleReferenceImpl[0];
 		}
 		if (module.exportsCount > 0) {
 			ExportReference[] refs = module.exports;
 			mod.exports = new PackageExport[refs.length];
 			for (int i = 0; i < refs.length; i++) {
 				PackageExport exp = createPackageExport(refs, i);
 				mod.exports[i] = exp;
 			}
 		} else {
 			mod.exports = new PackageExport[0];
 		}
 		if (module.usesCount > 0) {
 			TypeReference[] uses = module.uses;
 			mod.uses = new char[uses.length][];
 			for(int i = 0; i < uses.length; i++) {
 				mod.uses[i] = CharOperation.concatWith(uses[i].getTypeName(), '.');
 			}
 		}
 		if (module.servicesCount > 0) {
 			TypeReference[] services = module.interfaces;
 			TypeReference[] with = module.implementations;
 			mod.provides = new Service[module.servicesCount];
 			for (int i = 0; i < module.servicesCount; i++) {
 				mod.provides[i] = createService(services[i], with[i]);
 			}
 		}
 		return mod;
 	}

 	private static PackageExport createPackageExport(ExportReference[] refs, int i) {
 		ExportReference ref = refs[i];
 		PackageExport exp = new PackageExport();
 		exp.pack = CharOperation.concatWith(ref.tokens, '.');
 		ModuleReference[] imp = ref.targets;
 		if (imp != null) {
 			exp.exportedTo = new char[imp.length][];
 			for(int j = 0; j < imp.length; j++) {
 				exp.exportedTo = imp[j].tokens;
 			}
 		}
 		return exp;
 	}
 	private static Service createService(TypeReference service, TypeReference with) {
 		Service ser = new Service();
 		ser.provides = CharOperation.concatWith(service.getTypeName(), '.');
 		ser.with = CharOperation.concatWith(with.getTypeName(), '.');
 		return ser;
 	}
 	static class Module implements IModule {
 		char[] name;
 		ModuleReferenceImpl[] requires;
 		PackageExport[] exports;
 		char[][] uses;
 		Service[] provides;
 		@Override
 		public char[] name() {
 			return this.name;
 		}
 		@Override
 		public IModule.IModuleReference[] requires() {
 			return this.requires;
 		}
 		@Override
 		public IPackageExport[] exports() {
 			return this.exports;
 		}
 		@Override
 		public char[][] uses() {
 			return this.uses;
 		}
 		@Override
 		public IService[] provides() {
 			return this.provides();
 		}
 		public boolean equals(Object o) {
 			if (this == o)
 				return true;
 			if (!(o instanceof IModule))
 				return false;
 			IModule mod = (IModule) o;
 			if (!CharOperation.equals(this.name, mod.name()))
 				return false;
 			return Arrays.equals(this.requires, mod.requires());
 		}
 		@Override
 		public int hashCode() {
 			int result = 17;
 			int c = this.name.hashCode();
 			result = 31 * result + c;
 			c =  Arrays.hashCode(this.requires);
 			result = 31 * result + c;
 			return result;
 		}
 		public String toString() {
 			StringBuffer buffer = new StringBuffer(getClass().getName());
 			toStringContent(buffer);
 			return buffer.toString();
 		}
 		protected void toStringContent(StringBuffer buffer) {
 			buffer.append("\nmodule "); //$NON-NLS-1$
 			buffer.append(this.name).append(' ');
 			buffer.append('{').append('\n');
 			if (this.requires != null) {
 				for(int i = 0; i < this.requires.length; i++) {
 					buffer.append("\trequires "); //$NON-NLS-1$
 					if (this.requires[i].isPublic) {
 						buffer.append(" public "); //$NON-NLS-1$
 					}
 					buffer.append(this.requires[i].name);
 					buffer.append(';').append('\n');
 				}
 			}
 			if (this.exports != null) {
 				buffer.append('\n');
 				for(int i = 0; i < this.exports.length; i++) {
 					buffer.append("\texports "); //$NON-NLS-1$
 					buffer.append(this.exports[i].toString());
 				}
 			}
 			if (this.uses != null) {
 				buffer.append('\n');
 				for (char[] cs : this.uses) {
 					buffer.append(cs);
 					buffer.append(';').append('\n');
 				}
 			}
 			if (this.provides != null) {
 				buffer.append('\n');
 				for(Service ser : this.provides) {
 					buffer.append(ser.toString());
 				}
 			}
 			buffer.append('\n').append('}').toString();
 		}
 	}
 	static class ModuleReferenceImpl implements IModule.IModuleReference {
 		char[] name;
 		boolean isPublic = false;
 		@Override
 		public char[] name() {
 			return this.name;
 		}
 		@Override
 		public boolean isPublic() {
 			return this.isPublic;
 		}
 		public boolean equals(Object o) {
 			if (this == o)
 				return true;
 			if (!(o instanceof IModule.IModuleReference))
 				return false;
 			IModule.IModuleReference mod = (IModule.IModuleReference) o;
 			if (this.isPublic != mod.isPublic())
 				return false;
 			return CharOperation.equals(this.name, mod.name(), false);
 		}
 		@Override
 		public int hashCode() {
 			return this.name.hashCode();
 		}
 	}
 	static class PackageExport implements IModule.IPackageExport {
 		char[] pack;
 		char[][] exportedTo;
 		@Override
 		public char[] name() {
 			return this.pack;
 		}

 		@Override
 		public char[][] exportedTo() {
 			return this.exportedTo;
 		}
 		public String toString() {
 			StringBuffer buffer = new StringBuffer();
 			buffer.append(this.pack);
 			if (this.exportedTo != null) {
 				for (char[] cs : this.exportedTo) {
 					buffer.append(cs);
 				}
 			}
 			buffer.append(';');
 			return buffer.toString();
 		}
 	}
 	static class Service implements IModule.IService {
 		char[] provides;
 		char[] with;
 		@Override
 		public char[] name() {
 			return this.provides;
 		}

 		@Override
 		public char[] with() {
 			return this.with;
 		}
 		public String toString() {
 			StringBuffer buffer = new StringBuffer();
 			buffer.append("provides"); //$NON-NLS-1$
 			buffer.append(this.provides);
 			buffer.append(" with "); //$NON-NLS-1$
 			buffer.append(this.with);
 			buffer.append(';');
 			return buffer.toString();
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2016 IBM Corporation.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* This is an implementation of an early-draft specification developed under the Java
	* Community Process (JCP) and is made available for testing and evaluation purposes
	* only. The code is not compatible with any specification of the JCP.
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.internal.compiler.lookup;

	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.LinkedHashSet;
	import java.util.Set;

	import org.eclipse.jdt.core.compiler.CharOperation;
	import org.eclipse.jdt.internal.compiler.ast.ExportReference;
	import org.eclipse.jdt.internal.compiler.ast.ModuleDeclaration;
	import org.eclipse.jdt.internal.compiler.ast.ModuleReference;
	import org.eclipse.jdt.internal.compiler.ast.TypeReference;
	import org.eclipse.jdt.internal.compiler.env.IModule;
	import org.eclipse.jdt.internal.compiler.env.IModuleLocation;
	import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
	import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
	import org.eclipse.jdt.internal.compiler.util.JRTUtil;

	public abstract class ModuleEnvironment implements INameEnvironment {
	/*
	* Keeps track of packages mapped to modules
	* Knows how to get modules
	* Understands modules
	* Understand module dependencies and restrictions
	* Given a ModuleDeclaration, creates an IModule
	* TODO: This should kick-in only when source level is >= 9
	*/
	public static final char[] UNNAMED = "UNNAMED".toCharArray(); //$NON-NLS-1$
	public static final IModule UNNAMED_MODULE = new IModule() {
	@Override
	public char[][] uses() {
	return null;
	}
	@Override
	public IModuleReference[] requires() {
	return null;
	}
	@Override
	public IService[] provides() {
	return null;
	}
	@Override
	public char[] name() {
	return UNNAMED;
	}
	@Override
	public IPackageExport[] exports() {
	return null;
	}
	@Override
	public String toString() {
	return new String(UNNAMED);
	}
	};
	public static IModule[] UNNAMED_MODULE_ARRAY = new IModule[]{UNNAMED_MODULE};
	private HashMap<String, IModule> modulesCache = null;
	private static HashMap<IModuleLocation, IModule> ModuleLocationMap = new HashMap<>();

	public ModuleEnvironment() {
	this.modulesCache = new HashMap<>();
	}

	public NameEnvironmentAnswer findType(char[][] compoundTypeName, char[] client) {
	NameEnvironmentAnswer answer = findType(compoundTypeName, getVisibleModules(client));
	return answer;
	}

	public NameEnvironmentAnswer findType(char[] typeName, char[][] packageName, char[] client) {
	NameEnvironmentAnswer answer = findType(typeName, packageName, getVisibleModules(client));
	char[] module = null;
	if(answer == null \|\| (module = answer.moduleName()) == null \|\|
	CharOperation.equals(module, JRTUtil.JAVA_BASE_CHAR)) {
	return answer;
	}
	return returnAnswerAfterValidation(packageName, answer, client);
	}

	protected NameEnvironmentAnswer returnAnswerAfterValidation(char[][] packageName, NameEnvironmentAnswer answer, char[] client) {
	if (isPackageVisible(CharOperation.concatWith(packageName, '.'), answer.moduleName(), client)) {
	return answer;
	}
	return null;
	}

	public boolean isPackage(char[][] parentPackageName, char[] packageName, char[] client) {
	return isPackage(parentPackageName, packageName, getVisibleModules(client));
	}

	public abstract NameEnvironmentAnswer findType(char[][] compoundTypeName, IModule[] modules);

	public abstract NameEnvironmentAnswer findType(char[] typeName, char[][] packageName, IModule[] modules);

	public abstract boolean isPackage(char[][] parentPackageName, char[] packageName, IModule[] module);

	// public abstract IModule getModule(String name);
	// {
	//// IModule mod = this.modulesCache.get(name);
	//// if (mod == null) {
	////
	//// }
	//// return mod;
	// for ()
	// }

	public boolean isPackageVisible(char[] packageName, char[] sourceName, char[] clientName) {
	boolean clientIsUnnamed = clientName == null \|\| clientName == UNNAMED;
	if (clientIsUnnamed)
	return true; // Unnamed module can read every module
	if (sourceName == null \|\| sourceName == UNNAMED)
	return clientIsUnnamed; // Unnamed module cannot be read by any named module

	if (CharOperation.equals(sourceName, clientName))
	return true;

	IModule source = getModule(sourceName);
	IModule client = getModule(clientName);
	if (client != null) {
	IModule.IModuleReference[] requires = client.requires();
	if (requires != null && requires.length > 0) {
	for (IModule.IModuleReference ref : requires) {
	IModule refModule = getModule(ref.name());
	if (refModule == null)
	continue;
	if (refModule == source && isPackageExportedTo(refModule, packageName, client)) {
	return true;
	}
	Set<IModule> set = new LinkedHashSet<>();
	collectAllVisibleModules(refModule, set, true);
	IModule[] targets = set.toArray(new IModule[set.size()]);
	for (IModule iModule : targets) {
	if (iModule == source && isPackageExportedTo(iModule, packageName, client)) {
	return true;
	}
	}
	}
	}
	return false;
	}
	return true;
	}

	private boolean isPackageExportedTo(IModule module, char[] pack, IModule client) {
	IModule.IPackageExport[] exports = module.exports();
	if (exports != null && exports.length > 0) {
	for (IModule.IPackageExport iPackageExport : exports) {
	if (CharOperation.equals(iPackageExport.name(), pack)) {
	char[][] exportedTo = iPackageExport.exportedTo();
	if (exportedTo == null \|\| exportedTo.length == 0) {
	return true;
	}
	for (char[] cs : exportedTo) {
	if (CharOperation.equals(cs, client.name())) {
	return true;
	}
	}

	}
	}
	}
	return false;
	}

	public IModule[] getVisibleModules(char[] mod) {
	IModule[] targets = null;
	if (mod != null && !CharOperation.equals(mod, UNNAMED)) {
	Set<IModule> set = new LinkedHashSet<>();
	IModule client = getModule(JRTUtil.JAVA_BASE.toCharArray());
	if (client != null) set.add(client);
	client = getModule(mod);
	if (client != null) {
	set.add(client);
	collectAllVisibleModules(client, set, false);
	targets = set.toArray(new IModule[set.size()]);
	}
	} else {
	return UNNAMED_MODULE_ARRAY;
	}
	return targets;
	}

	private void collectAllVisibleModules(IModule module, Set<IModule> targets, boolean onlyPublic) {
	if (module != null) {
	IModule.IModuleReference[] requires = module.requires();
	if (requires != null && requires.length > 0) {
	for (IModule.IModuleReference ref : requires) {
	IModule refModule = getModule(ref.name());
	if (refModule != null) {
	if (!onlyPublic \|\| ref.isPublic()) {
	targets.add(refModule);
	collectAllVisibleModules(refModule, targets, true);
	}
	}
	}
	}
	}
	}
	/**
	* Returns the module with the given name from the name environment.
	*
	* @param name the name of the module to lookup
	* @return the module with the given name
	*/
	// public IModule getModule(final char[] name) {
	//// if (name == null) return null;
	//// String mod = new String(name);
	//// IModule module = this.modulesCache.get(mod);
	//// return module;
	// return name == null ? null : getModule(CharOperation.charToString(name));
	// }
	/**
	* Accepts the given module to be served later on requests. If
	* any older copies of module already present, they will be
	* overwritten by the new one.
	*
	* @param mod the module to be stored in memory
	*/
	public void acceptModule(IModule mod, IModuleLocation location) {
	IModule existing = ModuleEnvironment.ModuleLocationMap.get(location);
	if (existing != null) {
	if (existing.equals(mod))
	return;
	else {
	// Report problem and ignore the duplicate
	}
	}
	String name = new String(mod.name());
	this.modulesCache.put(name, mod);
	ModuleEnvironment.ModuleLocationMap.put(location, mod);
	}

	@Override
	public IModule getModule(IModuleLocation location) {
	IModule module = ModuleEnvironment.ModuleLocationMap.get(location);
	if (module == null)
	return null;
	String modName = new String(module.name());
	if (this.modulesCache.get(modName) == null) {
	this.modulesCache.put(modName, module);
	}
	return module;
	}
	public static Module createModule(ModuleDeclaration module) {
	Module mod = new Module();
	mod.name = module.moduleName;
	if (module.requiresCount > 0) {
	ModuleReference[] refs = module.requires;
	mod.requires = new ModuleReferenceImpl[refs.length];
	for (int i = 0; i < refs.length; i++) {
	mod.requires[i] = new ModuleReferenceImpl();
	mod.requires[i].name = CharOperation.concatWith(refs[i].tokens, '.');
	mod.requires[i].isPublic = refs[i].isPublic();
	}
	} else {
	mod.requires = new ModuleReferenceImpl[0];
	}
	if (module.exportsCount > 0) {
	ExportReference[] refs = module.exports;
	mod.exports = new PackageExport[refs.length];
	for (int i = 0; i < refs.length; i++) {
	PackageExport exp = createPackageExport(refs, i);
	mod.exports[i] = exp;
	}
	} else {
	mod.exports = new PackageExport[0];
	}
	if (module.usesCount > 0) {
	TypeReference[] uses = module.uses;
	mod.uses = new char[uses.length][];
	for(int i = 0; i < uses.length; i++) {
	mod.uses[i] = CharOperation.concatWith(uses[i].getTypeName(), '.');
	}
	}
	if (module.servicesCount > 0) {
	TypeReference[] services = module.interfaces;
	TypeReference[] with = module.implementations;
	mod.provides = new Service[module.servicesCount];
	for (int i = 0; i < module.servicesCount; i++) {
	mod.provides[i] = createService(services[i], with[i]);
	}
	}
	return mod;
	}

	private static PackageExport createPackageExport(ExportReference[] refs, int i) {
	ExportReference ref = refs[i];
	PackageExport exp = new PackageExport();
	exp.pack = CharOperation.concatWith(ref.tokens, '.');
	ModuleReference[] imp = ref.targets;
	if (imp != null) {
	exp.exportedTo = new char[imp.length][];
	for(int j = 0; j < imp.length; j++) {
	exp.exportedTo = imp[j].tokens;
	}
	}
	return exp;
	}
	private static Service createService(TypeReference service, TypeReference with) {
	Service ser = new Service();
	ser.provides = CharOperation.concatWith(service.getTypeName(), '.');
	ser.with = CharOperation.concatWith(with.getTypeName(), '.');
	return ser;
	}
	static class Module implements IModule {
	char[] name;
	ModuleReferenceImpl[] requires;
	PackageExport[] exports;
	char[][] uses;
	Service[] provides;
	@Override
	public char[] name() {
	return this.name;
	}
	@Override
	public IModule.IModuleReference[] requires() {
	return this.requires;
	}
	@Override
	public IPackageExport[] exports() {
	return this.exports;
	}
	@Override
	public char[][] uses() {
	return this.uses;
	}
	@Override
	public IService[] provides() {
	return this.provides();
	}
	public boolean equals(Object o) {
	if (this == o)
	return true;
	if (!(o instanceof IModule))
	return false;
	IModule mod = (IModule) o;
	if (!CharOperation.equals(this.name, mod.name()))
	return false;
	return Arrays.equals(this.requires, mod.requires());
	}
	@Override
	public int hashCode() {
	int result = 17;
	int c = this.name.hashCode();
	result = 31 * result + c;
	c = Arrays.hashCode(this.requires);
	result = 31 * result + c;
	return result;
	}
	public String toString() {
	StringBuffer buffer = new StringBuffer(getClass().getName());
	toStringContent(buffer);
	return buffer.toString();
	}
	protected void toStringContent(StringBuffer buffer) {
	buffer.append("\nmodule "); //$NON-NLS-1$
	buffer.append(this.name).append(' ');
	buffer.append('{').append('\n');
	if (this.requires != null) {
	for(int i = 0; i < this.requires.length; i++) {
	buffer.append("\trequires "); //$NON-NLS-1$
	if (this.requires[i].isPublic) {
	buffer.append(" public "); //$NON-NLS-1$
	}
	buffer.append(this.requires[i].name);
	buffer.append(';').append('\n');
	}
	}
	if (this.exports != null) {
	buffer.append('\n');
	for(int i = 0; i < this.exports.length; i++) {
	buffer.append("\texports "); //$NON-NLS-1$
	buffer.append(this.exports[i].toString());
	}
	}
	if (this.uses != null) {
	buffer.append('\n');
	for (char[] cs : this.uses) {
	buffer.append(cs);
	buffer.append(';').append('\n');
	}
	}
	if (this.provides != null) {
	buffer.append('\n');
	for(Service ser : this.provides) {
	buffer.append(ser.toString());
	}
	}
	buffer.append('\n').append('}').toString();
	}
	}
	static class ModuleReferenceImpl implements IModule.IModuleReference {
	char[] name;
	boolean isPublic = false;
	@Override
	public char[] name() {
	return this.name;
	}
	@Override
	public boolean isPublic() {
	return this.isPublic;
	}
	public boolean equals(Object o) {
	if (this == o)
	return true;
	if (!(o instanceof IModule.IModuleReference))
	return false;
	IModule.IModuleReference mod = (IModule.IModuleReference) o;
	if (this.isPublic != mod.isPublic())
	return false;
	return CharOperation.equals(this.name, mod.name(), false);
	}
	@Override
	public int hashCode() {
	return this.name.hashCode();
	}
	}
	static class PackageExport implements IModule.IPackageExport {
	char[] pack;
	char[][] exportedTo;
	@Override
	public char[] name() {
	return this.pack;
	}

	@Override
	public char[][] exportedTo() {
	return this.exportedTo;
	}
	public String toString() {
	StringBuffer buffer = new StringBuffer();
	buffer.append(this.pack);
	if (this.exportedTo != null) {
	for (char[] cs : this.exportedTo) {
	buffer.append(cs);
	}
	}
	buffer.append(';');
	return buffer.toString();
	}
	}
	static class Service implements IModule.IService {
	char[] provides;
	char[] with;
	@Override
	public char[] name() {
	return this.provides;
	}

	@Override
	public char[] with() {
	return this.with;
	}
	public String toString() {
	StringBuffer buffer = new StringBuffer();
	buffer.append("provides"); //$NON-NLS-1$
	buffer.append(this.provides);
	buffer.append(" with "); //$NON-NLS-1$
	buffer.append(this.with);
	buffer.append(';');
	return buffer.toString();
	}
	}
	}