Replace Class by IService for service registration.

Change-Id: I9516cb37e2838b03203432ed758027f9739ed30d

42 files changed, 827 insertions, 686 deletions

diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ILookupEngine.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ILookupEngine.java
index 95e4fc707..9fb5b686f 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ILookupEngine.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ILookupEngine.java
@@ -10,7 +10,6 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.runtime;
 
-import java.lang.reflect.Method;
 import java.util.Set;
 
 import org.eclipse.acceleo.query.validation.type.IType;
@@ -81,33 +80,21 @@ public interface ILookupEngine {
 	Set<IService> getServices(Set<IType> receiverTypes);
 
 	/**
-	 * Tells if a given {@link Method} is considered as a service to provide when querying.
+	 * Gets the {@link Set} of registered {@link IService}.
 	 * 
-	 * @param instance
-	 *            the instance {@link Object} if any, <code>null</code> otherwise
-	 * @param method
-	 *            the {@link Method} to check
-	 * @return <code>true</code> if a given {@link Method} is considered as a service to provide when
-	 *         querying, <code>false</code> otherwise
-	 */
-	boolean isServiceMethod(Object instance, Method method);
-
-	/**
-	 * Tells if the given {@link Class} is already registered.
-	 * 
-	 * @param cls
-	 *            the {@link Class} to check.
-	 * @return <code>true</code> if the given {@link Class} is already registered, <code>false</code>
-	 *         otherwise
+	 * @return the {@link Set} of registered {@link IService}
+	 * @since 4.1
 	 */
-	boolean isRegisteredService(Class<?> cls);
+	Set<IService> getRegisteredServices();
 
 	/**
-	 * Returns the set of registered {@link IService}s.
+	 * Tells if the given {@link IService} is registered.
 	 * 
-	 * @return The set of registered {@link IService}s.
-	 * @since 4.0.0
+	 * @param service
+	 *            the {@link IService} to check
+	 * @return <code>true</code> if the given {@link IService} is registered, <code>false</code> otherwise
+	 * @since 4.1
 	 */
-	Set<IService> getRegisteredServices();
+	boolean isRegisteredService(IService service);
 
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironment.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironment.java
index e1d2c2af0..e584e7679 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironment.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironment.java
@@ -21,52 +21,35 @@ import org.eclipse.emf.ecore.EPackage;
 public interface IQueryEnvironment extends IReadOnlyQueryEnvironment {
 
 	/**
-	 * Register a set of services. The specified {@link Class} must have a default constructor with no
-	 * parameters. Any public, non void, instance method in the specified class will be registered as a
-	 * service. Services can be called directly from Acceleo Query Language expressions. if several services
-	 * with the same name and signature are registered, the latest registered service among all the identical
-	 * services is used. This allows to override services in the language. Overriding services can be done
-	 * either by introducing a new class with a service that exists in another registered class or by
-	 * registering a subclass of an registered service class. In that later case, the sub-class will replace
-	 * the existing service class.
+	 * Registers the given {@link IService}.
 	 * 
-	 * @param services
-	 *            the service package to be registered.
+	 * @param service
+	 *            the {@link IService} to register.
 	 * @return the {@link ServiceRegistrationResult}
-	 * @throws InvalidAcceleoPackageException
-	 *             if the specified class has no default constructor
-	 */
-	ServiceRegistrationResult registerServicePackage(Class<?> services) throws InvalidAcceleoPackageException;
-
-	/**
-	 * registers a set of services from the given instance.
-	 * 
-	 * @param instance
-	 *            the instance to register
-	 * @return the {@link ServiceRegistrationResult}
-	 * @throws InvalidAcceleoPackageException
-	 *             if the specified class has no default constructor
 	 * @since 4.1
 	 */
-	ServiceRegistrationResult registerServiceInstance(Object instance) throws InvalidAcceleoPackageException;
+	ServiceRegistrationResult registerService(IService service);
 
 	/**
-	 * Tells if the given {@link Class} is already registered.
+	 * Removes the given {@link IService} from {@link IQueryEnvironment#registerService(IService) registered}
+	 * {@link IService}.
 	 * 
-	 * @param services
-	 *            the service package to check
-	 * @return <code>true</code> if the given {@link Class} is already registered, <code>false</code>
-	 *         otherwise
+	 * @param service
+	 *            the {@link IService} to remove
+	 * @since 4.1
 	 */
-	boolean isRegisteredServicePackage(Class<?> services);
+	void removeService(IService service);
 
 	/**
-	 * Removes the given {@link Class} from registered the service package.
+	 * Tells if the given {@link IService} is {@link IQueryEnvironment#registerService(IService) registered}.
 	 * 
-	 * @param services
-	 *            the service package to be removed
+	 * @param service
+	 *            the {@link IService} to check
+	 * @return <code>true</code> if the given {@link IService} is
+	 *         {@link IQueryEnvironment#registerService(IService) registered}, <code>false</code> otherwise
+	 * @since 4.1
 	 */
-	void removeServicePackage(Class<?> services);
+	boolean isRegisteredService(IService service);
 
 	/**
 	 * Registers a new {@link EPackage} that can be referred during evaluation and validation.
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironmentListener.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironmentListener.java
index 736badc6c..471c964bc 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironmentListener.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IQueryEnvironmentListener.java
@@ -22,23 +22,23 @@ import org.eclipse.emf.ecore.EPackage;
 public interface IQueryEnvironmentListener {
 
 	/**
-	 * Notifies a call to {@link IQueryEnvironment#registerServicePackage(Class)}.
+	 * Notifies a call to {@link IQueryEnvironment#registerService(IService)}.
 	 * 
 	 * @param result
 	 *            the {@link ServiceRegistrationResult} to be returned by
-	 *            {@link IQueryEnvironment#registerServicePackage(Class)}
-	 * @param services
-	 *            the registered {@link Class} services
+	 *            {@link IQueryEnvironment#registerService(IService)}
+	 * @param service
+	 *            the registered {@link IService}
 	 */
-	void servicePackageRegistered(ServiceRegistrationResult result, Class<?> services);
+	void serviceRegistered(ServiceRegistrationResult result, IService service);
 
 	/**
-	 * Notifies a call to {@link IQueryEnvironment#removeServicePackage(Class)}.
+	 * Notifies a call to {@link IQueryEnvironment#removeService(IService)}.
 	 * 
-	 * @param services
-	 *            the removed {@link Class} services
+	 * @param service
+	 *            the removed {@link IService}
 	 */
-	void servicePackageRemoved(Class<?> services);
+	void serviceRemoved(IService service);
 
 	/**
 	 * Notifies a call to {@link IQueryEnvironment#registerEPackage(EPackage)}.
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IServiceProvider.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IServiceProvider.java
index 7ef646c2a..9622c8804 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IServiceProvider.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/IServiceProvider.java
@@ -13,7 +13,7 @@ package org.eclipse.acceleo.query.runtime;
 import java.util.List;
 
 /**
- * Interface that can be implemented by service {@link Class} to provides its own {@link IService}.
+ * Interface that can be implemented to provides its own {@link IService}.
  * 
  * @author <a href="mailto:yvan.lussaud@obeo.fr">Yvan Lussaud</a>
  */
@@ -25,10 +25,7 @@ public interface IServiceProvider {
 	 * @param queryEnvironment
 	 *            the {@link IReadOnlyQueryEnvironment}
 	 * @return services offered by this class
-	 * @throws InvalidAcceleoPackageException
-	 *             if the specified class doesn't follow the acceleo package rules.
 	 */
-	List<IService> getServices(IReadOnlyQueryEnvironment queryEnvironment)
-			throws InvalidAcceleoPackageException;
+	List<IService> getServices(IReadOnlyQueryEnvironment queryEnvironment);
 
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/InvalidAcceleoPackageException.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/InvalidAcceleoPackageException.java
deleted file mode 100644
index 24f0455a5..000000000
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/InvalidAcceleoPackageException.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2015 Obeo.
- * 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
- * 
- * Contributors:
- *     Obeo - initial API and implementation
- *******************************************************************************/
-package org.eclipse.acceleo.query.runtime;
-
-/**
- * Exception thrown when an invalid package is registered.
- * 
- * @author <a href="mailto:romain.guider@obeo.fr">Romain Guider</a>
- */
-public class InvalidAcceleoPackageException extends Exception {
-
-	/**
-	 * Generated serial UID.
-	 */
-	private static final long serialVersionUID = -6398441984048705917L;
-
-	/**
-	 * Creates a new {@link InvalidAcceleoPackageException} instance.
-	 */
-	public InvalidAcceleoPackageException() {
-	}
-
-	/**
-	 * Creates a new {@link InvalidAcceleoPackageException} instance.
-	 * 
-	 * @param message
-	 *            the message to be printed in the stack trace.
-	 */
-	public InvalidAcceleoPackageException(String message) {
-		super(message);
-	}
-
-	/**
-	 * Creates a new {@link InvalidAcceleoPackageException} instance.
-	 * 
-	 * @param cause
-	 *            the exception that's embedded in this instance.
-	 */
-	public InvalidAcceleoPackageException(Throwable cause) {
-		super(cause);
-	}
-
-	/**
-	 * Creates a new {@link InvalidAcceleoPackageException} instance.
-	 * 
-	 * @param cause
-	 *            the exception that's embedded in this instance.
-	 * @param message
-	 *            the message to be printed in the stack trace.
-	 */
-	public InvalidAcceleoPackageException(String message, Throwable cause) {
-		super(message, cause);
-	}
-
-}
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/Query.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/Query.java
index 97a670377..89059d622 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/Query.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/Query.java
@@ -10,6 +10,8 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.runtime;
 
+import java.util.Set;
+
 import org.eclipse.acceleo.query.runtime.impl.QueryEnvironment;
 import org.eclipse.acceleo.query.services.AnyServices;
 import org.eclipse.acceleo.query.services.BooleanServices;
@@ -61,20 +63,24 @@ public final class Query {
 			IRootEObjectProvider rootProvider) {
 		final IQueryEnvironment env = newEnvironment();
 
-		try {
-			env.registerServiceInstance(new AnyServices(env));
-			env.registerServiceInstance(new EObjectServices(env, xRefProvider, rootProvider));
-			env.registerServiceInstance(new XPathServices(env));
-			env.registerServicePackage(ComparableServices.class);
-			env.registerServicePackage(NumberServices.class);
-			env.registerServicePackage(StringServices.class);
-			env.registerServicePackage(BooleanServices.class);
-			env.registerServicePackage(CollectionServices.class);
-			env.registerServicePackage(ResourceServices.class);
-		} catch (InvalidAcceleoPackageException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
+		Set<IService> services = ServiceUtils.getServices(env, new AnyServices(env));
+		ServiceUtils.registerServices(env, services);
+		services = ServiceUtils.getServices(env, new EObjectServices(env, xRefProvider, rootProvider));
+		ServiceUtils.registerServices(env, services);
+		services = ServiceUtils.getServices(env, new XPathServices(env));
+		ServiceUtils.registerServices(env, services);
+		services = ServiceUtils.getServices(env, ComparableServices.class);
+		ServiceUtils.registerServices(env, services);
+		services = ServiceUtils.getServices(env, NumberServices.class);
+		ServiceUtils.registerServices(env, services);
+		services = ServiceUtils.getServices(env, StringServices.class);
+		ServiceUtils.registerServices(env, services);
+		services = ServiceUtils.getServices(env, BooleanServices.class);
+		ServiceUtils.registerServices(env, services);
+		services = ServiceUtils.getServices(env, CollectionServices.class);
+		ServiceUtils.registerServices(env, services);
+		services = ServiceUtils.getServices(env, ResourceServices.class);
+		ServiceUtils.registerServices(env, services);
 
 		return env;
 	}
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ServiceUtils.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ServiceUtils.java
new file mode 100644
index 000000000..43370ce9f
--- /dev/null
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/ServiceUtils.java
@@ -0,0 +1,181 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Obeo.
+ * 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
+ * 
+ * Contributors:
+ *     Obeo - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.acceleo.query.runtime;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+import org.eclipse.acceleo.query.runtime.impl.JavaMethodService;
+
+/**
+ * Utility for {@link IService}.
+ * 
+ * @author <a href="mailto:yvan.lussaud@obeo.fr">Yvan Lussaud</a>
+ * @since 4.1
+ */
+public final class ServiceUtils {
+
+	/**
+	 * Constructor.
+	 */
+	private ServiceUtils() {
+		// nothing to do here
+	}
+
+	/**
+	 * Gets the {@link Set} of {@link IService} for the given {@link Class}. If the class can't be
+	 * instantiated only static {@link Method} will be used to produce {@link IService}.
+	 * 
+	 * @param queryEnvironment
+	 *            the {@link IReadOnlyQueryEnvironment}
+	 * @param cls
+	 *            the {@link Class}
+	 * @return the {@link Set} of {@link IService} for the given {@link Class}
+	 */
+	public static Set<IService> getServices(IReadOnlyQueryEnvironment queryEnvironment, Class<?> cls) {
+		final Set<IService> result = new LinkedHashSet<IService>();
+
+		Object instance = null;
+		try {
+			Constructor<?> cstr = null;
+			cstr = cls.getConstructor(new Class[] {});
+			instance = cstr.newInstance(new Object[] {});
+		} catch (NoSuchMethodException e) {
+			// we will go without instance and register only static methods
+		} catch (SecurityException e) {
+			// we will go without instance and register only static methods
+		} catch (InstantiationException e) {
+			// we will go without instance and register only static methods
+		} catch (IllegalAccessException e) {
+			// we will go without instance and register only static methods
+		} catch (IllegalArgumentException e) {
+			// we will go without instance and register only static methods
+		} catch (InvocationTargetException e) {
+			// we will go without instance and register only static methods
+		}
+		result.addAll(getServicesFromInstance(queryEnvironment, cls, instance));
+
+		return result;
+	}
+
+	/**
+	 * Gets the {@link Set} of {@link IService} for the given {@link Object instance}.
+	 * 
+	 * @param queryEnvironment
+	 *            the {@link IReadOnlyQueryEnvironment}
+	 * @param instance
+	 *            the {@link Object instance}
+	 * @return the {@link Set} of {@link IService} for the given {@link Object instance}
+	 */
+	public static Set<IService> getServices(IReadOnlyQueryEnvironment queryEnvironment, Object instance) {
+		return getServicesFromInstance(queryEnvironment, instance.getClass(), instance);
+	}
+
+	/**
+	 * Gets {@link IService} from the given instance and {@link Method} array.
+	 * 
+	 * @param queryEnvironment
+	 *            the {@link IReadOnlyQueryEnvironment}
+	 * @param cls
+	 *            the services {@link Class}
+	 * @param instance
+	 *            the instance
+	 * @return the {@link ServiceRegistrationResult}
+	 */
+	private static Set<IService> getServicesFromInstance(IReadOnlyQueryEnvironment queryEnvironment,
+			Class<?> cls, Object instance) {
+		final Set<IService> result = new LinkedHashSet<IService>();
+
+		if (instance instanceof IServiceProvider) {
+			result.addAll(((IServiceProvider)instance).getServices(queryEnvironment));
+		} else {
+			Method[] methods = cls.getMethods();
+			for (Method method : methods) {
+				if (isServiceMethod(instance, method)) {
+					final IService service = new JavaMethodService(method, instance);
+					result.add(service);
+				}
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Tells if a given {@link Method} is considered as a {@link IService}. {@link Object} methods are not
+	 * considered and only <code>static</code> {@link Method} are considered if the given instance if
+	 * <code>null</code>.
+	 * 
+	 * @param instance
+	 *            the instance {@link Object} if any, <code>null</code> otherwise
+	 * @param method
+	 *            the {@link Method} to check
+	 * @return <code>true</code> if a given {@link Method} is considered as a {@link IService},
+	 *         <code>false</code> otherwise
+	 */
+	public static boolean isServiceMethod(Object instance, Method method) {
+		final boolean result;
+
+		if (method.getDeclaringClass() == Object.class) {
+			// We do not register java.lang.Object method as
+			// having an expression calling the 'wait' or the notify service
+			// could yield problems that are difficult to track down.
+			result = false;
+		} else if (instance != null || Modifier.isStatic(method.getModifiers())) {
+			// If we have no instance, only consider static methods.
+			// Otherwise, any method with at least one parameter can be a service
+			result = method.getParameterTypes().length > 0;
+		} else {
+			result = false;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Registers a {@link Set} of {@link IService} to the given {@link IQueryEnvironment}.
+	 * 
+	 * @param queryEnvironment
+	 *            the {@link IQueryEnvironment}
+	 * @param services
+	 *            the {@link Set} of {@link IService}
+	 * @return the {@link ServiceRegistrationResult}
+	 */
+	public static ServiceRegistrationResult registerServices(IQueryEnvironment queryEnvironment,
+			Set<IService> services) {
+		final ServiceRegistrationResult result = new ServiceRegistrationResult();
+
+		for (IService service : services) {
+			result.merge(queryEnvironment.registerService(service));
+		}
+
+		return result;
+	}
+
+	/**
+	 * Removes a {@link Set} of {@link IService} from the given {@link IQueryEnvironment}.
+	 * 
+	 * @param queryEnvironment
+	 *            the {@link IQueryEnvironment}
+	 * @param services
+	 *            the {@link Set} of {@link IService}
+	 */
+	public static void removeServices(IQueryEnvironment queryEnvironment, Set<IService> services) {
+		for (IService service : services) {
+			queryEnvironment.removeService(service);
+		}
+	}
+
+}
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractService.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractService.java
index 6df0e0abf..1004f340e 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractService.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractService.java
@@ -87,7 +87,7 @@ public abstract class AbstractService implements IService {
 	 *      org.eclipse.acceleo.query.validation.type.IType[])
 	 */
 	public boolean matches(IReadOnlyQueryEnvironment queryEnvironment, IType[] argumentTypes) {
-		assert getNumberOfParameters() != argumentTypes.length;
+		assert getNumberOfParameters() == argumentTypes.length;
 
 		boolean result = true;
 
@@ -183,4 +183,14 @@ public abstract class AbstractService implements IService {
 		return builder.append(')').toString();
 	}
 
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @see java.lang.Object#toString()
+	 */
+	@Override
+	public String toString() {
+		return getLongSignature();
+	}
+
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractServiceProvider.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractServiceProvider.java
index 7489237dc..abc051fc4 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractServiceProvider.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/AbstractServiceProvider.java
@@ -14,11 +14,10 @@ import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.eclipse.acceleo.query.runtime.ILookupEngine;
 import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment;
 import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.IServiceProvider;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 
 /**
  * {@link IServiceProvider} scanning its own public methods to create {@link IService}.
@@ -39,8 +38,7 @@ public abstract class AbstractServiceProvider implements IServiceProvider {
 	private List<IService> services;
 
 	@Override
-	public List<IService> getServices(IReadOnlyQueryEnvironment queryEnvironment)
-			throws InvalidAcceleoPackageException {
+	public List<IService> getServices(IReadOnlyQueryEnvironment queryEnvironment) {
 		try {
 			if (services == null) {
 				final Method getServicesMethod = getClass().getMethod("getServices",
@@ -48,8 +46,7 @@ public abstract class AbstractServiceProvider implements IServiceProvider {
 				services = new ArrayList<IService>();
 				final Method[] methods = this.getClass().getMethods();
 				for (Method method : methods) {
-					if (queryEnvironment.getLookupEngine().isServiceMethod(this, method)
-							&& !getServicesMethod.equals(method)) {
+					if (ServiceUtils.isServiceMethod(this, method) && !getServicesMethod.equals(method)) {
 						final IService service = getService(method);
 						if (service != null) {
 							services.add(service);
@@ -57,20 +54,17 @@ public abstract class AbstractServiceProvider implements IServiceProvider {
 					}
 				}
 			}
-		} catch (IllegalArgumentException e) {
-			throw new InvalidAcceleoPackageException(ILookupEngine.INSTANTIATION_PROBLEM_MSG
-					+ getClass().getCanonicalName(), e);
 		} catch (NoSuchMethodException e) {
-			throw new InvalidAcceleoPackageException(WRONG_IMPLEMENTATION, e);
+			throw new IllegalStateException(WRONG_IMPLEMENTATION, e);
 		} catch (SecurityException e) {
-			throw new InvalidAcceleoPackageException(WRONG_IMPLEMENTATION, e);
+			throw new IllegalStateException(WRONG_IMPLEMENTATION, e);
 		}
 
 		return services;
 	}
 
 	/**
-	 * Gets an {@link IService} from the given {@link Method}.
+	 * Gets an {@link IService} for the given {@link Method}.
 	 * 
 	 * @param method
 	 *            the {@link Method}
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/JavaMethodService.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/JavaMethodService.java
index 4fab8b7f0..75ff64a7e 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/JavaMethodService.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/JavaMethodService.java
@@ -204,4 +204,24 @@ public class JavaMethodService extends AbstractService {
 		return method.toString();
 	}
 
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @see java.lang.Object#equals(java.lang.Object)
+	 */
+	@Override
+	public boolean equals(Object obj) {
+		return obj instanceof JavaMethodService && ((JavaMethodService)obj).getMethod().equals(getMethod());
+	}
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @see java.lang.Object#hashCode()
+	 */
+	@Override
+	public int hashCode() {
+		return getMethod().hashCode();
+	}
+
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryEnvironment.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryEnvironment.java
index 255cff080..7130975d0 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryEnvironment.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/impl/QueryEnvironment.java
@@ -16,7 +16,7 @@ import java.util.List;
 
 import org.eclipse.acceleo.query.runtime.IQueryEnvironment;
 import org.eclipse.acceleo.query.runtime.IQueryEnvironmentListener;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
+import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.ServiceRegistrationResult;
 import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine;
 import org.eclipse.emf.ecore.EClassifier;
@@ -54,13 +54,12 @@ public class QueryEnvironment implements IQueryEnvironment {
 	}
 
 	@Override
-	public ServiceRegistrationResult registerServicePackage(Class<?> services)
-			throws InvalidAcceleoPackageException {
-		final ServiceRegistrationResult result = lookupEngine.registerServices(services);
+	public ServiceRegistrationResult registerService(IService service) {
+		final ServiceRegistrationResult result = lookupEngine.registerService(service);
 
 		if (!result.getRegistered().isEmpty()) {
 			for (IQueryEnvironmentListener listener : getListeners()) {
-				listener.servicePackageRegistered(result, services);
+				listener.serviceRegistered(result, service);
 			}
 		}
 
@@ -69,39 +68,15 @@ public class QueryEnvironment implements IQueryEnvironment {
 
 	/**
 	 * {@inheritDoc}
-	 * 
-	 * @see org.eclipse.acceleo.query.runtime.IQueryEnvironment#registerServiceInstance(java.lang.Object)
-	 */
-	@Override
-	public ServiceRegistrationResult registerServiceInstance(Object instance)
-			throws InvalidAcceleoPackageException {
-		final ServiceRegistrationResult result = lookupEngine.registerServiceInstance(instance);
-
-		if (!result.getRegistered().isEmpty()) {
-			for (IQueryEnvironmentListener listener : getListeners()) {
-				listener.servicePackageRegistered(result, instance.getClass());
-			}
-		}
-
-		return result;
-	}
-
-	@Override
-	public boolean isRegisteredServicePackage(Class<?> cls) {
-		return lookupEngine.isRegisteredService(cls);
-	}
-
-	/**
-	 * {@inheritDoc}
 	 *
-	 * @see org.eclipse.acceleo.query.runtime.IQueryEnvironment#removeServicePackage(java.lang.Class)
+	 * @see org.eclipse.acceleo.query.runtime.IQueryEnvironment#removeService(org.eclipse.acceleo.query.runtime.IService)
 	 */
 	@Override
-	public void removeServicePackage(Class<?> services) {
-		final Class<?> removedClass = lookupEngine.removeServices(services);
-		if (removedClass != null) {
+	public void removeService(IService service) {
+		final IService removedService = lookupEngine.removeService(service);
+		if (removedService != null) {
 			for (IQueryEnvironmentListener listener : getListeners()) {
-				listener.servicePackageRemoved(removedClass);
+				listener.serviceRemoved(removedService);
 			}
 		}
 	}
@@ -207,4 +182,14 @@ public class QueryEnvironment implements IQueryEnvironment {
 		return result;
 	}
 
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @see org.eclipse.acceleo.query.runtime.IQueryEnvironment#isRegisteredService(org.eclipse.acceleo.query.runtime.IService)
+	 */
+	@Override
+	public boolean isRegisteredService(IService service) {
+		return lookupEngine.isRegisteredService(service);
+	}
+
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/BasicLookupEngine.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/BasicLookupEngine.java
index 47d907229..77d720f1f 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/BasicLookupEngine.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/BasicLookupEngine.java
@@ -10,24 +10,14 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.runtime.lookup.basic;
 
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Set;
 
 import org.eclipse.acceleo.query.runtime.ILookupEngine;
 import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment;
 import org.eclipse.acceleo.query.runtime.IService;
-import org.eclipse.acceleo.query.runtime.IServiceProvider;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
 import org.eclipse.acceleo.query.runtime.ServiceRegistrationResult;
-import org.eclipse.acceleo.query.runtime.impl.JavaMethodService;
 import org.eclipse.acceleo.query.validation.type.IType;
 
 /**
@@ -38,31 +28,16 @@ import org.eclipse.acceleo.query.validation.type.IType;
 public class BasicLookupEngine implements ILookupEngine {
 
 	/**
-	 * Message used when a service cannot be instantiated.
-	 */
-	private static final String INSTANTIATION_PROBLEM_MSG = "Couldn't instantiate class ";
-
-	/**
-	 * Message used when a service doesn't have a zero-argument constructor.
-	 */
-	private static final String PACKAGE_PROBLEM_MSG = "No zero argument constructor found in class ";
-
-	/**
 	 * The {@link IReadOnlyQueryEnvironment}.
 	 */
 	protected IReadOnlyQueryEnvironment queryEnvironment;
 
 	/**
-	 * Maps of multimethods : maps the arity to maps that maps service names to their IService list.
+	 * The {@link ServiceStore}.
 	 */
 	private final ServiceStore services;
 
 	/**
-	 * Mapping from a {@link Class} to its {@link IService}.
-	 */
-	private final Map<Class<?>, Set<IService>> classToServices = new LinkedHashMap<Class<?>, Set<IService>>();
-
-	/**
 	 * Constructor.
 	 * 
 	 * @param queryEnvironment
@@ -89,11 +64,7 @@ public class BasicLookupEngine implements ILookupEngine {
 	 * @see org.eclipse.acceleo.query.runtime.ILookupEngine#getRegisteredServices()
 	 */
 	public Set<IService> getRegisteredServices() {
-		Set<IService> result = new LinkedHashSet<IService>();
-
-		for (Entry<Class<?>, Set<IService>> entry : classToServices.entrySet()) {
-			result.addAll(new LinkedHashSet<IService>(entry.getValue()));
-		}
+		Set<IService> result = services.getServices();
 
 		return result;
 	}
@@ -119,199 +90,28 @@ public class BasicLookupEngine implements ILookupEngine {
 		}
 	}
 
-	@Override
-	public boolean isServiceMethod(Object instance, Method method) {
-		// We do not register java.lang.Object method as
-		// having an expression calling the 'wait' or the notify service
-		// could yield problems that are difficult to track down.
-		return method.getDeclaringClass() != Object.class
-				&& (instance != null || Modifier.isStatic(method.getModifiers()))
-				&& method.getParameterTypes().length > 0;
-	}
-
-	/**
-	 * Registers a new set of services provided by the given {@link IServiceProvider}.
-	 * 
-	 * @param provider
-	 *            the {@link IServiceProvider} to register
-	 * @return the {@link ServiceRegistrationResult}
-	 * @throws InvalidAcceleoPackageException
-	 *             if the specified class doesn't follow the acceleo package rules.
-	 */
-	private ServiceRegistrationResult registerServices(IServiceProvider provider)
-			throws InvalidAcceleoPackageException {
-		final ServiceRegistrationResult result = new ServiceRegistrationResult();
-
-		for (IService service : provider.getServices(queryEnvironment)) {
-			result.merge(registerService(provider.getClass(), service));
-		}
-
-		return result;
-	}
-
-	/**
-	 * Registers a new set of services.
-	 * 
-	 * @param newServices
-	 *            the {@link Class} containing the methods to register can't be <code>null</code>
-	 * @return the {@link ServiceRegistrationResult}
-	 * @throws InvalidAcceleoPackageException
-	 *             if the specified {@link Class} doesn't follow the acceleo package rules
-	 */
-	public ServiceRegistrationResult registerServices(Class<?> newServices)
-			throws InvalidAcceleoPackageException {
-		final ServiceRegistrationResult result = new ServiceRegistrationResult();
-
-		if (newServices == null) {
-			throw new NullPointerException("the service class can't be null");
-		} else if (!isRegisteredService(newServices)) {
-			try {
-				Constructor<?> cstr = null;
-				Object instance = null;
-				try {
-					cstr = newServices.getConstructor(new Class[] {});
-					instance = cstr.newInstance(new Object[] {});
-				} catch (NoSuchMethodException e) {
-					// we will go without instance and register only static methods
-				}
-				result.merge(registerServiceInstance(newServices, instance));
-			} catch (SecurityException e) {
-				throw new InvalidAcceleoPackageException(
-						PACKAGE_PROBLEM_MSG + newServices.getCanonicalName(), e);
-			} catch (InstantiationException e) {
-				throw new InvalidAcceleoPackageException(INSTANTIATION_PROBLEM_MSG
-						+ newServices.getCanonicalName(), e);
-			} catch (IllegalAccessException e) {
-				throw new InvalidAcceleoPackageException(INSTANTIATION_PROBLEM_MSG
-						+ newServices.getCanonicalName(), e);
-			} catch (IllegalArgumentException e) {
-				throw new InvalidAcceleoPackageException(INSTANTIATION_PROBLEM_MSG
-						+ newServices.getCanonicalName(), e);
-			} catch (InvocationTargetException e) {
-				throw new InvalidAcceleoPackageException(INSTANTIATION_PROBLEM_MSG
-						+ newServices.getCanonicalName(), e);
-			}
-		}
-
-		return result;
-	}
-
 	/**
-	 * Registers a new set of services from a given instance.
-	 * 
-	 * @param instance
-	 *            the instance
-	 * @return the {@link ServiceRegistrationResult}
-	 * @throws InvalidAcceleoPackageException
-	 *             if the specified class doesn't follow the acceleo package rules.
-	 * @throws IllegalAccessException
-	 *             if invocation to set the cross referencer fails
-	 * @throws InvocationTargetException
-	 *             if invocation to set the cross referencer fails
-	 */
-	public ServiceRegistrationResult registerServiceInstance(Object instance)
-			throws InvalidAcceleoPackageException {
-		return registerServiceInstance(instance.getClass(), instance);
-	}
-
-	/**
-	 * Registers a new set of services from a given instance.
-	 * 
-	 * @param newServices
-	 *            the service {@link Class}
-	 * @param instance
-	 *            the service instance
-	 * @return the {@link ServiceRegistrationResult}
-	 * @throws InvalidAcceleoPackageException
-	 *             if the specified class doesn't follow the acceleo package rules.
-	 */
-	private ServiceRegistrationResult registerServiceInstance(Class<?> newServices, Object instance)
-			throws InvalidAcceleoPackageException {
-		final ServiceRegistrationResult result = new ServiceRegistrationResult();
-
-		if (!isRegisteredService(newServices)) {
-			if (instance instanceof IServiceProvider) {
-				result.merge(registerServices((IServiceProvider)instance));
-			} else {
-				Method[] methods = newServices.getMethods();
-				result.merge(getServicesFromInstance(newServices, instance, methods));
-			}
-		}
-
-		return result;
-	}
-
-	@Override
-	public boolean isRegisteredService(Class<?> cls) {
-		return classToServices.containsKey(cls);
-	}
-
-	/**
-	 * Removes {@link IService} related to the given {@link Class}.
-	 * 
-	 * @param servicesClass
-	 *            the {@link Class} to unregister.
-	 * @return the removed {@link Class} if any, <code>null</code> otherwise
-	 */
-	public Class<?> removeServices(Class<?> servicesClass) {
-		final Class<?> result;
-
-		final Set<IService> servicesSet = classToServices.remove(servicesClass);
-		if (servicesSet != null) {
-			result = servicesClass;
-			for (IService service : servicesSet) {
-				services.remove(service);
-			}
-		} else {
-			result = null;
-		}
-
-		return result;
-	}
-
-	/**
-	 * Gets {@link IService} from the given instance and {@link Method} array.
+	 * Registers the given {@link IService}.
 	 * 
-	 * @param newServices
-	 *            the services {@link Class}
-	 * @param instance
-	 *            the instance
-	 * @param methods
-	 *            the array of {@link Method}
+	 * @param service
+	 *            the {@link IService} to register
 	 * @return the {@link ServiceRegistrationResult}
 	 */
-	private ServiceRegistrationResult getServicesFromInstance(Class<?> newServices, Object instance,
-			Method[] methods) {
-		final ServiceRegistrationResult result = new ServiceRegistrationResult();
-
-		for (Method method : methods) {
-			if (isServiceMethod(instance, method)) {
-				final IService service = new JavaMethodService(method, instance);
-				result.merge(registerService(newServices, service));
-			}
-		}
+	public ServiceRegistrationResult registerService(IService service) {
+		final ServiceRegistrationResult result = services.add(service);
 
 		return result;
 	}
 
 	/**
-	 * Registers the given {@link IService}.
+	 * Removes the given {@link IService}.
 	 * 
-	 * @param newServices
-	 *            the services {@link Class}
 	 * @param service
-	 *            the {@link IService} to register
-	 * @return the {@link ServiceRegistrationResult}
+	 *            the {@link IService} to remove.
+	 * @return the removed {@link IService} if any, <code>null</code> otherwise
 	 */
-	private ServiceRegistrationResult registerService(Class<?> newServices, IService service) {
-		final ServiceRegistrationResult result = services.add(service);
-
-		Set<IService> servicesSet = classToServices.get(newServices);
-		if (servicesSet == null) {
-			servicesSet = new LinkedHashSet<IService>();
-			classToServices.put(newServices, servicesSet);
-		}
-		servicesSet.add(service);
+	public IService removeService(IService service) {
+		final IService result = services.remove(service);
 
 		return result;
 	}
@@ -320,13 +120,12 @@ public class BasicLookupEngine implements ILookupEngine {
 	public Set<IService> getServices(Set<IType> receiverTypes) {
 		final Set<IService> result = new LinkedHashSet<IService>();
 
+		final Set<IService> storedServices = services.getServices();
 		for (IType type : receiverTypes) {
 			if (type != null) {
-				for (Set<IService> servicesSet : classToServices.values()) {
-					for (IService service : servicesSet) {
-						if (service.getParameterTypes(queryEnvironment).get(0).isAssignableFrom(type)) {
-							result.add(service);
-						}
+				for (IService service : storedServices) {
+					if (service.getParameterTypes(queryEnvironment).get(0).isAssignableFrom(type)) {
+						result.add(service);
 					}
 				}
 			}
@@ -335,4 +134,14 @@ public class BasicLookupEngine implements ILookupEngine {
 		return result;
 	}
 
+	/**
+	 * {@inheritDoc}
+	 *
+	 * @see org.eclipse.acceleo.query.runtime.ILookupEngine#isRegisteredService(org.eclipse.acceleo.query.runtime.IService)
+	 */
+	@Override
+	public boolean isRegisteredService(IService service) {
+		return services.isRegistered(service);
+	}
+
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/CacheLookupEngine.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/CacheLookupEngine.java
index a339021a8..f7bb2154b 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/CacheLookupEngine.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/CacheLookupEngine.java
@@ -15,7 +15,6 @@ import java.util.Map;
 
 import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment;
 import org.eclipse.acceleo.query.runtime.IService;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
 import org.eclipse.acceleo.query.runtime.ServiceRegistrationResult;
 import org.eclipse.acceleo.query.runtime.impl.JavaMethodService;
 import org.eclipse.acceleo.query.validation.type.IType;
@@ -67,10 +66,9 @@ public class CacheLookupEngine extends BasicLookupEngine {
 	}
 
 	@Override
-	public ServiceRegistrationResult registerServices(Class<?> newServices)
-			throws InvalidAcceleoPackageException {
+	public ServiceRegistrationResult registerService(IService service) {
 		cache.clear();
-		return super.registerServices(newServices);
+		return super.registerService(service);
 	}
 
 	@Override
@@ -156,9 +154,9 @@ public class CacheLookupEngine extends BasicLookupEngine {
 	}
 
 	@Override
-	public Class<?> removeServices(Class<?> servicesClass) {
+	public IService removeService(IService service) {
 		cache.clear();
-		return super.removeServices(servicesClass);
+		return super.removeService(service);
 	}
 
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/ServiceStore.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/ServiceStore.java
index 10a802ff5..9d1acd99f 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/ServiceStore.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/runtime/lookup/basic/ServiceStore.java
@@ -12,8 +12,10 @@ package org.eclipse.acceleo.query.runtime.lookup.basic;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment;
 import org.eclipse.acceleo.query.runtime.IService;
@@ -114,19 +116,34 @@ public class ServiceStore {
 	 * 
 	 * @param service
 	 *            the {@link IService} to remove
+	 * @return the removed {@link IService} if any, <code>null</code> otherwise
 	 */
-	public void remove(IService service) {
+	public IService remove(IService service) {
+		final IService result;
+
+		if (service == null) {
+			return null;
+		}
+
 		final int argc = service.getNumberOfParameters();
 		final Map<String, List<IService>> argcServices = services.get(argc);
-		final String serviceName = service.getName();
-		final List<IService> servicesList = argcServices.get(serviceName);
-		servicesList.remove(service);
-		if (servicesList.isEmpty()) {
-			argcServices.remove(serviceName);
-			if (argcServices.isEmpty()) {
-				services.remove(argc);
+		if (argcServices != null) {
+			final String serviceName = service.getName();
+			final List<IService> servicesList = argcServices.get(serviceName);
+			if (servicesList != null && servicesList.remove(service)) {
+				result = service;
+				if (servicesList.isEmpty() && argcServices.remove(serviceName) != null
+						&& argcServices.isEmpty()) {
+					services.remove(argc);
+				}
+			} else {
+				result = null;
 			}
+		} else {
+			result = null;
 		}
+
+		return result;
 	}
 
 	/**
@@ -161,9 +178,47 @@ public class ServiceStore {
 				}
 			}
 		}
-		result.getRegistered().add(service);
-		multiService.add(service);
+
+		if (!multiService.contains(service)) {
+			result.getRegistered().add(service);
+			multiService.add(service);
+		}
 
 		return result;
 	}
+
+	/**
+	 * Gets the {@link Set} of {@link ServiceStore#add(IService) stored} {@link IService}.
+	 * 
+	 * @return the {@link Set} of {@link ServiceStore#add(IService) stored} {@link IService}
+	 */
+	public Set<IService> getServices() {
+		final Set<IService> result = new LinkedHashSet<IService>();
+
+		for (Map<String, List<IService>> byArgC : services.values()) {
+			for (List<IService> byName : byArgC.values()) {
+				result.addAll(byName);
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Tells if the given {@link IService} is registered.
+	 * 
+	 * @param service
+	 *            the {@link IService} to check
+	 * @return <code>true</code> if the given {@link IService} is registered, <code>false</code> otherwise
+	 */
+	public boolean isRegistered(IService service) {
+		if (service == null) {
+			return false;
+		}
+
+		final List<IService> multiService = getMultiService(service.getName(), service
+				.getNumberOfParameters());
+
+		return multiService != null && multiService.contains(service);
+	}
 }
diff --git a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/AnyServices.java b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/AnyServices.java
index 4cc5f0103..d346c0e66 100644
--- a/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/AnyServices.java
+++ b/query/plugins/org.eclipse.acceleo.query/src/org/eclipse/acceleo/query/services/AnyServices.java
@@ -325,9 +325,8 @@ public class AnyServices extends AbstractServiceProvider {
 	 * 
 	 * @param type
 	 *            the {@link EClassifier} to check
-	 * @return the registered {@link Class} if any.
 	 * @throws IllegalArgumentException
-	 *             if the type is not registered
+	 *             if the {@link EClassifier} is not registered
 	 */
 	private void checkRegistered(EClassifier type) throws IllegalArgumentException {
 		if (!queryEnvironment.getEPackageProvider().isRegistered(type)) {
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/BuildTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/BuildTest.java
index 2f4e21fbe..bc9ff02ae 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/BuildTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/BuildTest.java
@@ -48,7 +48,6 @@ import org.eclipse.acceleo.query.ast.VariableDeclaration;
 import org.eclipse.acceleo.query.runtime.IQueryBuilderEngine;
 import org.eclipse.acceleo.query.runtime.IQueryBuilderEngine.AstResult;
 import org.eclipse.acceleo.query.runtime.IQueryEnvironment;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
 import org.eclipse.acceleo.query.runtime.Query;
 import org.eclipse.acceleo.query.runtime.impl.QueryBuilderEngine;
 import org.eclipse.acceleo.query.tests.anydsl.AnydslPackage;
@@ -68,7 +67,7 @@ public class BuildTest {
 	IQueryEnvironment queryEnvironment;
 
 	@Before
-	public void setup() throws InvalidAcceleoPackageException {
+	public void setup() {
 		queryEnvironment = Query.newEnvironmentWithDefaultServices(null);
 		queryEnvironment.registerEPackage(EcorePackage.eINSTANCE);
 		queryEnvironment.registerEPackage(AnydslPackage.eINSTANCE);
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionCheck.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionCheck.java
index f6f6a5664..6de46e29d 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionCheck.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionCheck.java
@@ -10,8 +10,6 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.parser.tests;
 
-import static org.junit.Assert.assertTrue;
-
 import com.google.common.collect.Iterators;
 
 import java.util.HashMap;
@@ -22,6 +20,8 @@ import java.util.Map;
 import java.util.Set;
 
 import org.eclipse.acceleo.query.runtime.IQueryEnvironment;
+import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.impl.QueryCompletionEngine;
 import org.eclipse.acceleo.query.tests.Setup;
 import org.eclipse.acceleo.query.tests.UnitTestModels;
@@ -34,6 +34,8 @@ import org.eclipse.acceleo.query.validation.type.IType;
 import org.junit.Before;
 import org.junit.Test;
 
+import static org.junit.Assert.assertTrue;
+
 public class CompletionCheck {
 	private UnitTestModels qmodels;
 
@@ -72,7 +74,9 @@ public class CompletionCheck {
 			QueryCompletionEngine completionEngine = new QueryCompletionEngine(queryEnvironment);
 
 			for (String classToImport : next.getClassesToImport()) {
-				queryEnvironment.registerServicePackage(Class.forName(classToImport));
+				final Set<IService> services = ServiceUtils.getServices(queryEnvironment, Class
+						.forName(classToImport));
+				ServiceUtils.registerServices(queryEnvironment, services);
 			}
 
 			Map<String, Set<IType>> variableTypes = new HashMap<String, Set<IType>>();
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java
index 387ddcb5e..e00fcd72c 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/CompletionTest.java
@@ -21,7 +21,6 @@ import org.eclipse.acceleo.query.runtime.ICompletionProposal;
 import org.eclipse.acceleo.query.runtime.ICompletionResult;
 import org.eclipse.acceleo.query.runtime.IQueryEnvironment;
 import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
 import org.eclipse.acceleo.query.runtime.Query;
 import org.eclipse.acceleo.query.runtime.impl.BasicFilter;
 import org.eclipse.acceleo.query.runtime.impl.QueryCompletionEngine;
@@ -63,7 +62,7 @@ public class CompletionTest {
 	Map<String, Set<IType>> variableTypes = new LinkedHashMap<String, Set<IType>>();
 
 	@Before
-	public void setup() throws InvalidAcceleoPackageException {
+	public void setup() {
 		queryEnvironment = Query.newEnvironmentWithDefaultServices(null);
 		queryEnvironment.registerEPackage(EcorePackage.eINSTANCE);
 		queryEnvironment.registerEPackage(AnydslPackage.eINSTANCE);
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/EvaluationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/EvaluationTest.java
index f56f6bf6b..49a0e1887 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/EvaluationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/EvaluationTest.java
@@ -24,8 +24,9 @@ import nooperationreflection.NooperationreflectionPackage;
 import org.eclipse.acceleo.query.runtime.EvaluationResult;
 import org.eclipse.acceleo.query.runtime.IQueryBuilderEngine;
 import org.eclipse.acceleo.query.runtime.IQueryEnvironment;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
+import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.Query;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.impl.QueryBuilderEngine;
 import org.eclipse.acceleo.query.runtime.impl.QueryEvaluationEngine;
 import org.eclipse.acceleo.query.tests.anydsl.AnydslPackage;
@@ -61,13 +62,14 @@ public class EvaluationTest {
 	IQueryBuilderEngine builder;
 
 	@Before
-	public void setup() throws InvalidAcceleoPackageException {
+	public void setup() {
 		queryEnvironment = Query.newEnvironmentWithDefaultServices(null);
 		queryEnvironment.registerEPackage(EcorePackage.eINSTANCE);
 		queryEnvironment.registerEPackage(AnydslPackage.eINSTANCE);
 		queryEnvironment.registerEPackage(RootPackage.eINSTANCE);
 		queryEnvironment.registerEPackage(NooperationreflectionPackage.eINSTANCE);
-		queryEnvironment.registerServicePackage(EObjectServices.class);
+		final Set<IService> services = ServiceUtils.getServices(queryEnvironment, EObjectServices.class);
+		ServiceUtils.registerServices(queryEnvironment, services);
 		engine = new QueryEvaluationEngine(queryEnvironment);
 		builder = new QueryBuilderEngine(queryEnvironment);
 	}
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationInferrenceTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationInferrenceTest.java
index a0f5820dd..8601f97b3 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationInferrenceTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationInferrenceTest.java
@@ -20,7 +20,6 @@ import org.eclipse.acceleo.query.ast.Conditional;
 import org.eclipse.acceleo.query.ast.Expression;
 import org.eclipse.acceleo.query.runtime.IQueryEnvironment;
 import org.eclipse.acceleo.query.runtime.IValidationResult;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
 import org.eclipse.acceleo.query.runtime.Query;
 import org.eclipse.acceleo.query.runtime.ValidationMessageLevel;
 import org.eclipse.acceleo.query.runtime.impl.QueryValidationEngine;
@@ -148,7 +147,7 @@ public class ValidationInferrenceTest {
 	}
 
 	@Before
-	public void setup() throws InvalidAcceleoPackageException {
+	public void setup() {
 		queryEnvironment = Query.newEnvironmentWithDefaultServices(null);
 		queryEnvironment.registerEPackage(ePackage);
 		engine = new QueryValidationEngine(queryEnvironment);
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationTest.java
index ed6183d57..4d89cd3b6 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/parser/tests/ValidationTest.java
@@ -24,10 +24,11 @@ import org.eclipse.acceleo.query.ast.Conditional;
 import org.eclipse.acceleo.query.ast.Expression;
 import org.eclipse.acceleo.query.ast.Lambda;
 import org.eclipse.acceleo.query.runtime.IQueryEnvironment;
+import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.IValidationMessage;
 import org.eclipse.acceleo.query.runtime.IValidationResult;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
 import org.eclipse.acceleo.query.runtime.Query;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.ValidationMessageLevel;
 import org.eclipse.acceleo.query.runtime.impl.QueryValidationEngine;
 import org.eclipse.acceleo.query.tests.anydsl.AnydslPackage;
@@ -61,11 +62,12 @@ public class ValidationTest {
 	Map<String, Set<IType>> variableTypes = new LinkedHashMap<String, Set<IType>>();
 
 	@Before
-	public void setup() throws InvalidAcceleoPackageException {
+	public void setup() {
 		queryEnvironment = Query.newEnvironmentWithDefaultServices(null);
 		queryEnvironment.registerEPackage(EcorePackage.eINSTANCE);
 		queryEnvironment.registerEPackage(AnydslPackage.eINSTANCE);
-		queryEnvironment.registerServicePackage(EObjectServices.class);
+		final Set<IService> services = ServiceUtils.getServices(queryEnvironment, EObjectServices.class);
+		ServiceUtils.registerServices(queryEnvironment, services);
 		engine = new QueryValidationEngine(queryEnvironment);
 
 		variableTypes.clear();
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupCrossReferencerTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupCrossReferencerTest.java
index 80c4a1d35..34ac4b49a 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupCrossReferencerTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupCrossReferencerTest.java
@@ -10,8 +10,11 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.runtime.servicelookup;
 
+import java.util.Set;
+
 import org.eclipse.acceleo.query.runtime.ILookupEngine;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
+import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.impl.JavaMethodService;
 import org.eclipse.acceleo.query.services.tests.AbstractEngineInitializationWithCrossReferencer;
 import org.eclipse.acceleo.query.validation.type.ClassType;
@@ -36,11 +39,10 @@ public class BasicLookupCrossReferencerTest extends AbstractEngineInitialization
 
 		setQueryEnvironnementWithCrossReferencer(eClass);
 		engine = queryEnvironment.getLookupEngine();
-		try {
-			queryEnvironment.registerServiceInstance(new CrossReferencerClass(crossReferencer));
-		} catch (InvalidAcceleoPackageException e) {
-			throw new UnsupportedOperationException("shouldn't happen.", e);
-		}
+
+		final Set<IService> services = ServiceUtils.getServices(queryEnvironment, new CrossReferencerClass(
+				crossReferencer));
+		ServiceUtils.registerServices(queryEnvironment, services);
 	}
 
 	/**
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupTest.java
index 58a366e4d..68cf9302b 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/servicelookup/BasicLookupTest.java
@@ -10,9 +10,12 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.runtime.servicelookup;
 
+import java.util.Set;
+
 import org.eclipse.acceleo.query.runtime.IQueryEnvironment;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
+import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.Query;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 
 public class BasicLookupTest extends AbtractServiceLookupTest {
 
@@ -25,11 +28,8 @@ public class BasicLookupTest extends AbtractServiceLookupTest {
 	IQueryEnvironment getQueryEnvironment() {
 		final IQueryEnvironment queryEnvironment = Query.newEnvironmentWithDefaultServices(null);
 
-		try {
-			queryEnvironment.registerServicePackage(ServicesClass.class);
-		} catch (InvalidAcceleoPackageException e) {
-			throw new UnsupportedOperationException("shouldn't happen.", e);
-		}
+		final Set<IService> services = ServiceUtils.getServices(queryEnvironment, ServicesClass.class);
+		ServiceUtils.registerServices(queryEnvironment, services);
 
 		return queryEnvironment;
 	}
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServiceStatusTests.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServiceStatusTests.java
index 09955e144..ab9aeadfe 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServiceStatusTests.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServiceStatusTests.java
@@ -13,10 +13,12 @@ package org.eclipse.acceleo.query.runtime.test;
 import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 
 import org.eclipse.acceleo.query.runtime.AcceleoQueryEvaluationException;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
+import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.Query;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.impl.EvaluationServices;
 import org.eclipse.acceleo.query.runtime.impl.QueryEnvironment;
 import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine;
@@ -56,12 +58,9 @@ public class EvaluationServiceStatusTests {
 	public void setup() {
 		queryEnvironment = (QueryEnvironment)Query.newEnvironmentWithDefaultServices(null);
 		engine = queryEnvironment.getLookupEngine();
-		try {
-			engine.registerServices(TestServiceDefinition.class);
-		} catch (InvalidAcceleoPackageException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
+		final Set<IService> servicesToRegister = ServiceUtils.getServices(queryEnvironment,
+				TestServiceDefinition.class);
+		ServiceUtils.registerServices(queryEnvironment, servicesToRegister);
 		variables = new HashMap<String, Object>();
 		variables.put("x", 1);
 		variables.put("y", 2);
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServicesTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServicesTest.java
index a0143526e..b64d87004 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServicesTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/EvaluationServicesTest.java
@@ -30,8 +30,9 @@ import java.util.Set;
 import org.eclipse.acceleo.query.runtime.AcceleoQueryEvaluationException;
 import org.eclipse.acceleo.query.runtime.ILookupEngine;
 import org.eclipse.acceleo.query.runtime.IQueryEnvironment;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
+import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.Query;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.impl.EvaluationServices;
 import org.eclipse.acceleo.query.runtime.impl.Nothing;
 import org.eclipse.acceleo.query.tests.Setup;
@@ -77,9 +78,11 @@ public class EvaluationServicesTest {
 	}
 
 	@Before
-	public void setup() throws InvalidAcceleoPackageException {
+	public void setup() {
 		queryEnvironment = Query.newEnvironmentWithDefaultServices(null);
-		queryEnvironment.registerServicePackage(TestServiceDefinition.class);
+		final Set<IService> servicesToRegister = ServiceUtils.getServices(queryEnvironment,
+				TestServiceDefinition.class);
+		ServiceUtils.registerServices(queryEnvironment, servicesToRegister);
 		variables = new HashMap<String, Object>();
 		variables.put("x", 1);
 		variables.put("y", 2);
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/ShortcutEvaluationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/ShortcutEvaluationTest.java
index 8629a2335..42066098d 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/ShortcutEvaluationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/runtime/test/ShortcutEvaluationTest.java
@@ -13,14 +13,16 @@ package org.eclipse.acceleo.query.runtime.test;
 import com.google.common.collect.Maps;
 
 import java.util.HashMap;
+import java.util.Set;
 
 import org.eclipse.acceleo.query.runtime.IQueryBuilderEngine;
 import org.eclipse.acceleo.query.runtime.IQueryEnvironment;
 import org.eclipse.acceleo.query.runtime.IQueryEvaluationEngine;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
+import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.Query;
 import org.eclipse.acceleo.query.runtime.QueryEvaluation;
 import org.eclipse.acceleo.query.runtime.QueryParsing;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.servicelookup.ServicesCountCalls;
 import org.eclipse.emf.ecore.EcorePackage;
 import org.junit.Before;
@@ -37,11 +39,12 @@ public class ShortcutEvaluationTest {
 	private HashMap<String, Object> variables;
 
 	@Before
-	public void setUp() throws InvalidAcceleoPackageException {
-		IQueryEnvironment env = Query.newEnvironmentWithDefaultServices(null);
-		env.registerServicePackage(ServicesCountCalls.class);
-		parser = QueryParsing.newBuilder(env);
-		evaluator = QueryEvaluation.newEngine(env);
+	public void setUp() {
+		IQueryEnvironment queryEnvironment = Query.newEnvironmentWithDefaultServices(null);
+		final Set<IService> services = ServiceUtils.getServices(queryEnvironment, ServicesCountCalls.class);
+		ServiceUtils.registerServices(queryEnvironment, services);
+		parser = QueryParsing.newBuilder(queryEnvironment);
+		evaluator = QueryEvaluation.newEngine(queryEnvironment);
 		variables = Maps.newHashMap();
 		variables.put("self", EcorePackage.eINSTANCE);
 		evaluator.eval(parser.build("self.reset()"), variables);
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesTest.java
index 925e156fb..4ffe0448a 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesTest.java
@@ -13,7 +13,10 @@ package org.eclipse.acceleo.query.services.tests;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
 
+import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.impl.Nothing;
 import org.eclipse.acceleo.query.services.AnyServices;
 import org.eclipse.acceleo.query.tests.anydsl.AnydslPackage;
@@ -39,7 +42,9 @@ public class AnyServicesTest extends AbstractServicesTest {
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServiceInstance(new AnyServices(getQueryEnvironment()));
+		final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(), new AnyServices(
+				getQueryEnvironment()));
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 		any = new AnyServices(getQueryEnvironment());
 	}
 
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesValidationTest.java
index 9c635d4dc..e1a94aad7 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesValidationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/AnyServicesValidationTest.java
@@ -18,6 +18,7 @@ import java.util.Map;
 import java.util.Set;
 
 import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.services.AnyServices;
 import org.eclipse.acceleo.query.validation.type.ClassType;
 import org.eclipse.acceleo.query.validation.type.EClassifierType;
@@ -35,7 +36,9 @@ public class AnyServicesValidationTest extends AbstractServicesValidationTest {
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServiceInstance(new AnyServices(getQueryEnvironment()));
+		final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(), new AnyServices(
+				getQueryEnvironment()));
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 	}
 
 	@Test
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesTest.java
index 0b862845d..2b99d992c 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesTest.java
@@ -11,7 +11,10 @@
 package org.eclipse.acceleo.query.services.tests;
 
 import java.lang.reflect.InvocationTargetException;
+import java.util.Set;
 
+import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.services.BooleanServices;
 import org.junit.Test;
 
@@ -20,7 +23,8 @@ public class BooleanServicesTest extends AbstractServicesTest {
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServicePackage(BooleanServices.class);
+		final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(), BooleanServices.class);
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 	}
 
 	@Test(expected = java.lang.NullPointerException.class)
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesValidationTest.java
index 166e8f54e..2d8ac1dc6 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesValidationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/BooleanServicesValidationTest.java
@@ -10,6 +10,10 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.services.tests;
 
+import java.util.Set;
+
+import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.services.BooleanServices;
 import org.eclipse.acceleo.query.validation.type.IType;
 import org.junit.Test;
@@ -19,7 +23,8 @@ public class BooleanServicesValidationTest extends AbstractServicesValidationTes
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServicePackage(BooleanServices.class);
+		final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(), BooleanServices.class);
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 	}
 
 	@Test
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/CollectionServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/CollectionServicesValidationTest.java
index e1139a2a8..3300691ee 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/CollectionServicesValidationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/CollectionServicesValidationTest.java
@@ -10,6 +10,10 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.services.tests;
 
+import java.util.Set;
+
+import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.services.CollectionServices;
 import org.eclipse.acceleo.query.validation.type.IType;
 import org.eclipse.acceleo.query.validation.type.NothingType;
@@ -24,7 +28,9 @@ public class CollectionServicesValidationTest extends AbstractServicesValidation
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServicePackage(CollectionServices.class);
+		final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(),
+				CollectionServices.class);
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 	}
 
 	@Test
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ComparableServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ComparableServicesValidationTest.java
index 0b70cb217..b7864378b 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ComparableServicesValidationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ComparableServicesValidationTest.java
@@ -10,6 +10,10 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.services.tests;
 
+import java.util.Set;
+
+import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.services.ComparableServices;
 import org.eclipse.acceleo.query.validation.type.IType;
 import org.junit.Test;
@@ -19,7 +23,9 @@ public class ComparableServicesValidationTest extends AbstractServicesValidation
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServicePackage(ComparableServices.class);
+		final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(),
+				ComparableServices.class);
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 	}
 
 	@Test
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesValidationTest.java
index b34ab0310..15f2e430d 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesValidationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/EObjectServicesValidationTest.java
@@ -18,7 +18,8 @@ import java.util.Set;
 import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.Query;
 import org.eclipse.acceleo.query.runtime.RootEObjectProvider;
-import org.eclipse.acceleo.query.services.XPathServices;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
+import org.eclipse.acceleo.query.services.EObjectServices;
 import org.eclipse.acceleo.query.tests.anydsl.AnydslPackage;
 import org.eclipse.acceleo.query.validation.type.EClassifierLiteralType;
 import org.eclipse.acceleo.query.validation.type.EClassifierType;
@@ -44,7 +45,8 @@ public class EObjectServicesValidationTest extends AbstractServicesValidationTes
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServiceInstance(new XPathServices(getQueryEnvironment()));
+		final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(), EObjectServices.class);
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 	}
 
 	@Test
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesTest.java
index 221dd2f69..7e494d594 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesTest.java
@@ -11,7 +11,10 @@
 package org.eclipse.acceleo.query.services.tests;
 
 import java.lang.reflect.InvocationTargetException;
+import java.util.Set;
 
+import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.services.NumberServices;
 import org.junit.Test;
 
@@ -26,7 +29,9 @@ public class NumberServicesTest extends AbstractServicesTest {
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServicePackage(NumberServices.class);
+		final Set<IService> servicesToRegister = ServiceUtils.getServices(getQueryEnvironment(),
+				NumberServices.class);
+		ServiceUtils.registerServices(getQueryEnvironment(), servicesToRegister);
 		numServices = new NumberServices();
 	}
 
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesValidationTest.java
index d1c032a3d..b09efec89 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesValidationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/NumberServicesValidationTest.java
@@ -10,6 +10,10 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.services.tests;
 
+import java.util.Set;
+
+import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.services.NumberServices;
 import org.eclipse.acceleo.query.validation.type.IType;
 import org.junit.Test;
@@ -19,7 +23,8 @@ public class NumberServicesValidationTest extends AbstractServicesValidationTest
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServicePackage(NumberServices.class);
+		final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(), NumberServices.class);
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 	}
 
 	@Test
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ResourceServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ResourceServicesValidationTest.java
index 9962e8392..98b615a62 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ResourceServicesValidationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/ResourceServicesValidationTest.java
@@ -18,6 +18,7 @@ import java.util.Map;
 import java.util.Set;
 
 import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.services.ResourceServices;
 import org.eclipse.acceleo.query.validation.type.ClassType;
 import org.eclipse.acceleo.query.validation.type.EClassifierLiteralType;
@@ -39,7 +40,9 @@ public class ResourceServicesValidationTest extends AbstractServicesTest {
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServicePackage(ResourceServices.class);
+		final Set<IService> services = ServiceUtils
+				.getServices(getQueryEnvironment(), ResourceServices.class);
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 	}
 
 	@Test
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/StringServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/StringServicesValidationTest.java
index 20923939d..fbd2a772b 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/StringServicesValidationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/StringServicesValidationTest.java
@@ -10,6 +10,10 @@
  *******************************************************************************/
 package org.eclipse.acceleo.query.services.tests;
 
+import java.util.Set;
+
+import org.eclipse.acceleo.query.runtime.IService;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.services.StringServices;
 import org.eclipse.acceleo.query.validation.type.IType;
 import org.junit.Test;
@@ -19,7 +23,8 @@ public class StringServicesValidationTest extends AbstractServicesValidationTest
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServicePackage(StringServices.class);
+		final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(), StringServices.class);
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 	}
 
 	@Test
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/XPathServicesValidationTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/XPathServicesValidationTest.java
index 43e54e996..fad44e584 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/XPathServicesValidationTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/services/tests/XPathServicesValidationTest.java
@@ -12,9 +12,11 @@ package org.eclipse.acceleo.query.services.tests;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
 
 import org.eclipse.acceleo.query.runtime.IService;
-import org.eclipse.acceleo.query.services.EObjectServices;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
+import org.eclipse.acceleo.query.services.XPathServices;
 import org.eclipse.acceleo.query.validation.type.EClassifierLiteralType;
 import org.eclipse.acceleo.query.validation.type.EClassifierType;
 import org.eclipse.acceleo.query.validation.type.IType;
@@ -37,7 +39,8 @@ public class XPathServicesValidationTest extends AbstractServicesValidationTest
 	@Override
 	public void before() throws Exception {
 		super.before();
-		getQueryEnvironment().registerServicePackage(EObjectServices.class);
+		final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(), XPathServices.class);
+		ServiceUtils.registerServices(getQueryEnvironment(), services);
 	}
 
 	@Test
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/AcceleoQueryInterpreter.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/AcceleoQueryInterpreter.java
index 7c48d17dd..2a41772fc 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/AcceleoQueryInterpreter.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/AcceleoQueryInterpreter.java
@@ -22,9 +22,10 @@ import org.eclipse.acceleo.query.parser.AstEvaluator;
 import org.eclipse.acceleo.query.parser.AstValidator;
 import org.eclipse.acceleo.query.runtime.IQueryBuilderEngine;
 import org.eclipse.acceleo.query.runtime.IQueryBuilderEngine.AstResult;
+import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.IValidationMessage;
 import org.eclipse.acceleo.query.runtime.IValidationResult;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.impl.QueryBuilderEngine;
 import org.eclipse.acceleo.query.services.tests.AbstractEngineInitializationWithCrossReferencer;
 import org.eclipse.acceleo.query.tests.anydsl.AnydslPackage;
@@ -96,11 +97,11 @@ public class AcceleoQueryInterpreter extends AbstractEngineInitializationWithCro
 
 		for (String classToImport : q.getClassesToImport()) {
 			try {
-				queryEnvironment.registerServicePackage(Class.forName(classToImport));
+				final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(), Class
+						.forName(classToImport));
+				ServiceUtils.registerServices(queryEnvironment, services);
 			} catch (ClassNotFoundException e) {
 				logger.log(Level.WARNING, "couldn't register class " + classToImport, e);
-			} catch (InvalidAcceleoPackageException e) {
-				logger.log(Level.WARNING, "couldn't register class " + classToImport, e);
 			}
 		}
 		variables = Maps.newHashMap();
@@ -147,11 +148,11 @@ public class AcceleoQueryInterpreter extends AbstractEngineInitializationWithCro
 	public QueryValidationResult validateQuery(Query q) {
 		for (String classToImport : q.getClassesToImport()) {
 			try {
-				queryEnvironment.registerServicePackage(Class.forName(classToImport));
+				final Set<IService> services = ServiceUtils.getServices(getQueryEnvironment(), Class
+						.forName(classToImport));
+				ServiceUtils.registerServices(queryEnvironment, services);
 			} catch (ClassNotFoundException e) {
 				logger.log(Level.WARNING, "couldn't register class " + classToImport, e);
-			} catch (InvalidAcceleoPackageException e) {
-				logger.log(Level.WARNING, "couldn't register class " + classToImport, e);
 			}
 		}
 		Map<String, Set<IType>> variableTypes = Maps.newHashMap();
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/impl/QueryEnvironmentTests.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/impl/QueryEnvironmentTests.java
index 199a2d1e7..d73a0c265 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/impl/QueryEnvironmentTests.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/impl/QueryEnvironmentTests.java
@@ -11,11 +11,14 @@
 package org.eclipse.acceleo.query.tests.runtime.impl;
 
 import java.util.List;
+import java.util.Set;
 
 import org.eclipse.acceleo.query.runtime.IQueryEnvironmentListener;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
+import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.ServiceRegistrationResult;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.impl.QueryEnvironment;
+import org.eclipse.acceleo.query.tests.runtime.lookup.basic.MethodHolder;
 import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EcorePackage;
@@ -45,24 +48,13 @@ public class QueryEnvironmentTests {
 
 		public int customClassMappingRegistered;
 
-		/**
-		 * {@inheritDoc}
-		 *
-		 * @see org.eclipse.acceleo.query.runtime.IQueryEnvironmentListener#servicePackageRegistered(org.eclipse.acceleo.query.runtime.ServiceRegistrationResult,
-		 *      java.lang.Class)
-		 */
 		@Override
-		public void servicePackageRegistered(ServiceRegistrationResult result, Class<?> services) {
+		public void serviceRegistered(ServiceRegistrationResult result, IService service) {
 			servicePackageRegistered++;
 		}
 
-		/**
-		 * {@inheritDoc}
-		 *
-		 * @see org.eclipse.acceleo.query.runtime.IQueryEnvironmentListener#servicePackageRemoved(java.lang.Class)
-		 */
 		@Override
-		public void servicePackageRemoved(Class<?> services) {
+		public void serviceRemoved(IService services) {
 			servicePackageRemoved++;
 		}
 
@@ -132,76 +124,102 @@ public class QueryEnvironmentTests {
 	}
 
 	@Test
-	public void isRegisteredServicePackageNull() {
-		assertFalse(queryEnvironment.isRegisteredServicePackage(null));
+	public void isRegisteredServiceNull() {
+		assertFalse(queryEnvironment.isRegisteredService(null));
 	}
 
 	@Test
-	public void isRegisteredServicePackage() throws InvalidAcceleoPackageException {
-		assertFalse(queryEnvironment.isRegisteredServicePackage(this.getClass()));
+	public void isRegisteredService() {
+		final Set<IService> services = ServiceUtils.getServices(queryEnvironment, MethodHolder.class);
+		for (IService service : services) {
+			assertFalse(queryEnvironment.isRegisteredService(service));
+		}
 
-		queryEnvironment.registerServicePackage(this.getClass());
+		ServiceUtils.registerServices(queryEnvironment, services);
 
-		assertTrue(queryEnvironment.isRegisteredServicePackage(this.getClass()));
-		assertListener(listener, 1, 0, 0, 0, 0);
+		for (IService service : services) {
+			assertTrue(queryEnvironment.isRegisteredService(service));
+		}
+		assertListener(listener, 2, 0, 0, 0, 0);
 	}
 
 	@Test(expected = java.lang.NullPointerException.class)
-	public void registerServicePackageNull() throws InvalidAcceleoPackageException {
-		queryEnvironment.registerServicePackage(null);
+	public void registerServiceNull() {
+		queryEnvironment.registerService(null);
 	}
 
 	@Test
-	public void registerServicePackageNotRegistered() throws InvalidAcceleoPackageException {
-		ServiceRegistrationResult result = queryEnvironment.registerServicePackage(this.getClass());
+	public void registerServiceNotRegistered() {
+		final Set<IService> services = ServiceUtils.getServices(queryEnvironment, MethodHolder.class);
+		final ServiceRegistrationResult result = ServiceUtils.registerServices(queryEnvironment, services);
 
-		assertTrue(queryEnvironment.getLookupEngine().isRegisteredService(this.getClass()));
+		for (IService service : services) {
+			assertTrue(queryEnvironment.getLookupEngine().isRegisteredService(service));
+		}
 		assertFalse(result.getRegistered().isEmpty());
-		assertListener(listener, 1, 0, 0, 0, 0);
+		assertListener(listener, 2, 0, 0, 0, 0);
 	}
 
 	@Test
-	public void registerServicePackageRegistered() throws InvalidAcceleoPackageException {
-		ServiceRegistrationResult result = queryEnvironment.registerServicePackage(this.getClass());
+	public void registerServiceRegistered() {
+		final Set<IService> services = ServiceUtils.getServices(queryEnvironment, MethodHolder.class);
+		ServiceRegistrationResult result = ServiceUtils.registerServices(queryEnvironment, services);
 
 		assertFalse(result.getRegistered().isEmpty());
 
-		result = queryEnvironment.registerServicePackage(this.getClass());
+		result = ServiceUtils.registerServices(queryEnvironment, services);
 
-		assertTrue(queryEnvironment.getLookupEngine().isRegisteredService(this.getClass()));
+		for (IService service : services) {
+			assertTrue(queryEnvironment.getLookupEngine().isRegisteredService(service));
+		}
 		assertTrue(result.getRegistered().isEmpty());
-		assertListener(listener, 1, 0, 0, 0, 0);
+		assertListener(listener, 2, 0, 0, 0, 0);
 	}
 
 	@Test
-	public void removeServicePackageNull() {
-		queryEnvironment.removeServicePackage(null);
+	public void removeServiceNull() {
+		queryEnvironment.removeService(null);
 		assertListener(listener, 0, 0, 0, 0, 0);
 	}
 
 	@Test
-	public void removeServicePackageNotRegistered() throws InvalidAcceleoPackageException {
-		assertFalse(queryEnvironment.getLookupEngine().isRegisteredService(this.getClass()));
+	public void removeServiceNotRegistered() {
+		final Set<IService> services = ServiceUtils.getServices(queryEnvironment, MethodHolder.class);
+		for (IService service : services) {
+			assertFalse(queryEnvironment.getLookupEngine().isRegisteredService(service));
+		}
 
-		queryEnvironment.removeServicePackage(this.getClass());
+		for (IService service : services) {
+			queryEnvironment.getLookupEngine().removeService(service);
+		}
 
-		assertFalse(queryEnvironment.getLookupEngine().isRegisteredService(this.getClass()));
+		for (IService service : services) {
+			assertFalse(queryEnvironment.getLookupEngine().isRegisteredService(service));
+		}
 		assertListener(listener, 0, 0, 0, 0, 0);
 	}
 
 	@Test
-	public void removeServicePackageRegistered() throws InvalidAcceleoPackageException {
-		assertFalse(queryEnvironment.getLookupEngine().isRegisteredService(this.getClass()));
+	public void removeServiceRegistered() {
+		final Set<IService> services = ServiceUtils.getServices(queryEnvironment, MethodHolder.class);
+		for (IService service : services) {
+			assertFalse(queryEnvironment.getLookupEngine().isRegisteredService(service));
+		}
 
-		queryEnvironment.registerServicePackage(this.getClass());
+		ServiceRegistrationResult result = ServiceUtils.registerServices(queryEnvironment, services);
 
-		assertTrue(queryEnvironment.getLookupEngine().isRegisteredService(this.getClass()));
-		assertListener(listener, 1, 0, 0, 0, 0);
+		assertEquals(2, result.getRegistered().size());
+		for (IService service : services) {
+			assertTrue(queryEnvironment.isRegisteredService(service));
+		}
+		assertListener(listener, 2, 0, 0, 0, 0);
 
-		queryEnvironment.removeServicePackage(this.getClass());
+		ServiceUtils.removeServices(queryEnvironment, services);
 
-		assertFalse(queryEnvironment.getLookupEngine().isRegisteredService(this.getClass()));
-		assertListener(listener, 1, 1, 0, 0, 0);
+		for (IService service : services) {
+			assertFalse(queryEnvironment.isRegisteredService(service));
+		}
+		assertListener(listener, 2, 2, 0, 0, 0);
 	}
 
 	@Test(expected = java.lang.NullPointerException.class)
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/lookup/basic/LookupEngineTest.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/lookup/basic/LookupEngineTest.java
index 20f47c8af..65374b1b7 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/lookup/basic/LookupEngineTest.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/lookup/basic/LookupEngineTest.java
@@ -25,9 +25,9 @@ import org.eclipse.acceleo.query.runtime.CrossReferenceProvider;
 import org.eclipse.acceleo.query.runtime.ILookupEngine;
 import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment;
 import org.eclipse.acceleo.query.runtime.IService;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
 import org.eclipse.acceleo.query.runtime.Query;
 import org.eclipse.acceleo.query.runtime.ServiceRegistrationResult;
+import org.eclipse.acceleo.query.runtime.ServiceUtils;
 import org.eclipse.acceleo.query.runtime.impl.AbstractServiceProvider;
 import org.eclipse.acceleo.query.runtime.impl.JavaMethodService;
 import org.eclipse.acceleo.query.runtime.lookup.basic.BasicLookupEngine;
@@ -63,13 +63,9 @@ public class LookupEngineTest {
 
 	private interface ITestLookupEngine extends ILookupEngine {
 
-		ServiceRegistrationResult registerServices(Class<?> newServices)
-				throws InvalidAcceleoPackageException;
+		ServiceRegistrationResult registerService(IService service);
 
-		public ServiceRegistrationResult registerServiceInstance(Object instance)
-				throws InvalidAcceleoPackageException;
-
-		Class<?> removeServices(Class<?> servicesClass);
+		IService removeService(IService service);
 
 		ServiceStore getServices();
 
@@ -348,12 +344,15 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void simpleRegistration() throws InvalidAcceleoPackageException, NoSuchMethodException,
-			SecurityException {
+	public void simpleRegistration() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		final ServiceRegistrationResult result = engine.registerServiceInstance(new TestServices1(provider));
+		final ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(), new TestServices1(
+				provider))) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(0, result.getIsMaskedBy().size());
@@ -370,12 +369,15 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void staticRegistration() throws InvalidAcceleoPackageException, NoSuchMethodException,
-			SecurityException {
+	public void staticRegistration() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		final ServiceRegistrationResult result = engine.registerServices(TestStaticServices.class);
+		final ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				TestStaticServices.class)) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(0, result.getIsMaskedBy().size());
@@ -392,13 +394,15 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void extendedRegistration() throws InvalidAcceleoPackageException, NoSuchMethodException,
-			SecurityException {
+	public void extendedRegistration() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		final ServiceRegistrationResult result = engine.registerServiceInstance(new ExtendedTestServices1(
-				provider));
+		final ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new ExtendedTestServices1(provider))) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(0, result.getIsMaskedBy().size());
@@ -422,18 +426,25 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void doubleRegistration() throws InvalidAcceleoPackageException, NoSuchMethodException,
-			SecurityException {
+	public void doubleRegistration() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		ServiceRegistrationResult result = engine.registerServiceInstance(new TestServices1(provider));
+		ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(), new TestServices1(
+				provider))) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(1, result.getRegistered().size());
 		assertEquals(TestServices1.class.getMethod("service1", EClassifier.class), ((JavaMethodService)result
 				.getRegistered().get(0)).getMethod());
 
-		result = engine.registerServiceInstance(new TestServices1(provider));
-		assertEquals(0, result.getDuplicated().size());
+		result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(), new TestServices1(
+				provider))) {
+			result.merge(engine.registerService(service));
+		}
+		assertEquals(1, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(0, result.getIsMaskedBy().size());
 
@@ -447,18 +458,25 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void duplicateRegistration() throws InvalidAcceleoPackageException, NoSuchMethodException,
-			SecurityException {
+	public void duplicateRegistration() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		ServiceRegistrationResult result = engine.registerServiceInstance(new TestServices1(provider));
+		ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(), new TestServices1(
+				provider))) {
+			result.merge(engine.registerService(service));
+		}
 
 		assertEquals(1, result.getRegistered().size());
 		assertEquals(TestServices1.class.getMethod("service1", EClassifier.class), ((JavaMethodService)result
 				.getRegistered().get(0)).getMethod());
 
-		result = engine.registerServices(TestDuplicateServices1.class);
+		result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				TestDuplicateServices1.class)) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(1, result.getDuplicated().size());
 		final Method expectedDuplicatedMethod = TestServices1.class.getMethod("service1", EClassifier.class);
 
@@ -485,18 +503,24 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void maskRegistration() throws InvalidAcceleoPackageException, NoSuchMethodException,
-			SecurityException {
+	public void maskRegistration() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		ServiceRegistrationResult result = engine.registerServiceInstance(new TestServices1(provider));
+		ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(), new TestServices1(
+				provider))) {
+			result.merge(engine.registerService(service));
+		}
 
 		assertEquals(1, result.getRegistered().size());
 		assertEquals(TestServices1.class.getMethod("service1", EClassifier.class), ((JavaMethodService)result
 				.getRegistered().get(0)).getMethod());
 
-		result = engine.registerServices(TestMaskServices1.class);
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				TestMaskServices1.class)) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(1, result.getMasked().size());
 		final Method expectedMaskMethod = TestServices1.class.getMethod("service1", EClassifier.class);
@@ -519,24 +543,33 @@ public class LookupEngineTest {
 				.getQueryEnvironment(), EClass.class) });
 		assertEquals(TestMaskServices1.class.getMethod("service1", EClass.class), service.getMethod());
 
-		assertEquals(1, result.getRegistered().size());
-		assertEquals(TestMaskServices1.class.getMethod("service1", EClass.class), ((JavaMethodService)result
+		assertEquals(2, result.getRegistered().size());
+		assertEquals(TestServices1.class.getMethod("service1", EClassifier.class), ((JavaMethodService)result
 				.getRegistered().get(0)).getMethod());
+		assertEquals(TestMaskServices1.class.getMethod("service1", EClass.class), ((JavaMethodService)result
+				.getRegistered().get(1)).getMethod());
 	}
 
 	@Test
-	public void maskedByRegistration() throws InvalidAcceleoPackageException, NoSuchMethodException,
-			SecurityException {
+	public void maskedByRegistration() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		ServiceRegistrationResult result = engine.registerServices(TestMaskServices1.class);
+		ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				TestMaskServices1.class)) {
+			result.merge(engine.registerService(service));
+		}
 
 		assertEquals(1, result.getRegistered().size());
 		assertEquals(TestMaskServices1.class.getMethod("service1", EClass.class), ((JavaMethodService)result
 				.getRegistered().get(0)).getMethod());
 
-		result = engine.registerServiceInstance(new TestServices1(provider));
+		result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(), new TestServices1(
+				provider))) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(1, result.getIsMaskedBy().size());
@@ -565,12 +598,15 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void withCrossReferencerRegistration() throws InvalidAcceleoPackageException,
-			NoSuchMethodException, SecurityException {
+	public void withCrossReferencerRegistration() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		final ServiceRegistrationResult result = engine.registerServiceInstance(new TestServices1(provider));
+		final ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(), new TestServices1(
+				provider))) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(0, result.getIsMaskedBy().size());
@@ -592,13 +628,15 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void simpleRegistrationServiceProvider() throws InvalidAcceleoPackageException,
-			NoSuchMethodException, SecurityException {
+	public void simpleRegistrationServiceProvider() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		final ServiceRegistrationResult result = engine.registerServiceInstance(new TestServicesProvider1(
-				provider));
+		final ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServicesProvider1(provider))) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(0, result.getIsMaskedBy().size());
@@ -615,13 +653,15 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void extendedRegistrationServiceProvider() throws InvalidAcceleoPackageException,
-			NoSuchMethodException, SecurityException {
+	public void extendedRegistrationServiceProvider() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		final ServiceRegistrationResult result = engine
-				.registerServiceInstance(new ExtendedTestServicesProvider1(provider));
+		final ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new ExtendedTestServicesProvider1(provider))) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(0, result.getIsMaskedBy().size());
@@ -647,20 +687,26 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void doubleRegistrationServiceProvider() throws InvalidAcceleoPackageException,
-			NoSuchMethodException, SecurityException {
+	public void doubleRegistrationServiceProvider() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		ServiceRegistrationResult result = engine
-				.registerServiceInstance(new TestServicesProvider1(provider));
+		ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServicesProvider1(provider))) {
+			result.merge(engine.registerService(service));
+		}
 
 		assertEquals(1, result.getRegistered().size());
 		assertEquals(TestServicesProvider1.class.getMethod("service1", EClassifier.class),
 				((JavaMethodService)result.getRegistered().get(0)).getMethod());
 
-		result = engine.registerServiceInstance(new TestServicesProvider1(provider));
-		assertEquals(0, result.getDuplicated().size());
+		result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServicesProvider1(provider))) {
+			result.merge(engine.registerService(service));
+		}
+		assertEquals(1, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(0, result.getIsMaskedBy().size());
 
@@ -676,19 +722,25 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void duplicateRegistrationServiceProvider() throws InvalidAcceleoPackageException,
-			NoSuchMethodException, SecurityException {
+	public void duplicateRegistrationServiceProvider() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		ServiceRegistrationResult result = engine
-				.registerServiceInstance(new TestServicesProvider1(provider));
+		ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServicesProvider1(provider))) {
+			result.merge(engine.registerService(service));
+		}
 
 		assertEquals(1, result.getRegistered().size());
 		assertEquals(TestServicesProvider1.class.getMethod("service1", EClassifier.class),
 				((JavaMethodService)result.getRegistered().get(0)).getMethod());
 
-		result = engine.registerServices(TestDuplicateServicesProvider1.class);
+		result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				TestDuplicateServicesProvider1.class)) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(1, result.getDuplicated().size());
 		final Method expectedDuplicatedMethod = TestServicesProvider1.class.getMethod("service1",
 				EClassifier.class);
@@ -717,19 +769,25 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void maskRegistrationServiceProvider() throws InvalidAcceleoPackageException,
-			NoSuchMethodException, SecurityException {
+	public void maskRegistrationServiceProvider() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		ServiceRegistrationResult result = engine
-				.registerServiceInstance(new TestServicesProvider1(provider));
+		ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServicesProvider1(provider))) {
+			result.merge(engine.registerService(service));
+		}
 
 		assertEquals(1, result.getRegistered().size());
 		assertEquals(TestServicesProvider1.class.getMethod("service1", EClassifier.class),
 				((JavaMethodService)result.getRegistered().get(0)).getMethod());
 
-		result = engine.registerServices(TestMaskServicesProvider1.class);
+		result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				TestMaskServicesProvider1.class)) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(1, result.getMasked().size());
 		final Method expectedMaskMethod = TestServicesProvider1.class
@@ -762,18 +820,25 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void maskedByRegistrationServiceProvider() throws InvalidAcceleoPackageException,
-			NoSuchMethodException, SecurityException {
+	public void maskedByRegistrationServiceProvider() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		ServiceRegistrationResult result = engine.registerServices(TestMaskServicesProvider1.class);
+		ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				TestMaskServicesProvider1.class)) {
+			result.merge(engine.registerService(service));
+		}
 
 		assertEquals(1, result.getRegistered().size());
 		assertEquals(TestMaskServicesProvider1.class.getMethod("service1", EClass.class),
 				((JavaMethodService)result.getRegistered().get(0)).getMethod());
 
-		result = engine.registerServiceInstance(new TestServicesProvider1(provider));
+		result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServicesProvider1(provider))) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(1, result.getIsMaskedBy().size());
@@ -806,13 +871,16 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void withCrossReferencerRegistrationServiceProvider() throws InvalidAcceleoPackageException,
-			NoSuchMethodException, SecurityException {
+	public void withCrossReferencerRegistrationServiceProvider() throws NoSuchMethodException,
+			SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		final ServiceRegistrationResult result = engine.registerServiceInstance(new TestServicesProvider1(
-				provider));
+		final ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServicesProvider1(provider))) {
+			result.merge(engine.registerService(service));
+		}
 		assertEquals(0, result.getDuplicated().size());
 		assertEquals(0, result.getMasked().size());
 		assertEquals(0, result.getIsMaskedBy().size());
@@ -837,96 +905,100 @@ public class LookupEngineTest {
 
 	@Test
 	public void isServiceMethodFromObject() throws NoSuchMethodException, SecurityException {
-		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
-		final ITestLookupEngine engine = instanciate(provider);
-
 		final Method method = Object.class.getMethod("equals", Object.class);
 		assertNotNull(method);
-		assertFalse(engine.isServiceMethod(this, method));
+		assertFalse(ServiceUtils.isServiceMethod(this, method));
 	}
 
 	@Test
 	public void isServiceMethodNoParameter() throws NoSuchMethodException, SecurityException {
-		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
-		final ITestLookupEngine engine = instanciate(provider);
-
 		final Method method = MethodHolder.class.getMethod("testNotServiceMethodNoParameter");
 		assertNotNull(method);
-		assertFalse(engine.isServiceMethod(this, method));
+		assertFalse(ServiceUtils.isServiceMethod(this, method));
 	}
 
 	@Test
 	public void isServiceMethodNotStaticNoInstance() throws NoSuchMethodException, SecurityException {
-		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
-		final ITestLookupEngine engine = instanciate(provider);
-
 		final Method method = MethodHolder.class.getMethod("testServiceMethod", Object.class);
 		assertNotNull(method);
-		assertFalse(engine.isServiceMethod(null, method));
+		assertFalse(ServiceUtils.isServiceMethod(null, method));
 	}
 
 	@Test
 	public void isServiceMethodNotStaticInstance() throws NoSuchMethodException, SecurityException {
-		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
-		final ITestLookupEngine engine = instanciate(provider);
-
 		final Method method = MethodHolder.class.getMethod("testServiceMethod", Object.class);
 		assertNotNull(method);
-		assertTrue(engine.isServiceMethod(this, method));
+		assertTrue(ServiceUtils.isServiceMethod(this, method));
 	}
 
 	@Test
 	public void isServiceMethodStaticNoInstance() throws NoSuchMethodException, SecurityException {
-		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
-		final ITestLookupEngine engine = instanciate(provider);
-
 		final Method method = MethodHolder.class.getMethod("testStaticServiceMethod", Object.class);
 		assertNotNull(method);
-		assertTrue(engine.isServiceMethod(null, method));
+		assertTrue(ServiceUtils.isServiceMethod(null, method));
 	}
 
 	@Test
 	public void isServiceMethodStaticInstance() throws NoSuchMethodException, SecurityException {
-		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
-		final ITestLookupEngine engine = instanciate(provider);
-
 		final Method method = MethodHolder.class.getMethod("testStaticServiceMethod", Object.class);
 		assertNotNull(method);
-		assertTrue(engine.isServiceMethod(this, method));
+		assertTrue(ServiceUtils.isServiceMethod(this, method));
 	}
 
 	@Test
-	public void isRegisteredService() throws InvalidAcceleoPackageException {
+	public void isRegisteredService() {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		assertFalse(engine.isRegisteredService(TestServices1.class));
-		engine.registerServiceInstance(new TestServices1(provider));
-		assertTrue(engine.isRegisteredService(TestServices1.class));
+		final Set<IService> services = ServiceUtils.getServices(engine.getQueryEnvironment(),
+				TestServices1.class);
+		for (IService service : services) {
+			engine.removeService(service);
+		}
+
+		for (IService service : services) {
+			assertFalse(engine.isRegisteredService(service));
+		}
+		ServiceRegistrationResult result = new ServiceRegistrationResult();
+		for (IService service : services) {
+			result.merge(engine.registerService(service));
+		}
+		for (IService service : services) {
+			assertTrue(engine.isRegisteredService(service));
+		}
 	}
 
 	@Test
-	public void removeServicesEmpty() {
+	public void removeServiceEmpty() {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		engine.removeServices(ExtendedTestServices1.class);
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(), new TestServices1(
+				provider))) {
+			engine.removeService(service);
+		}
 
 		assertEquals(0, engine.getRegisteredServices().size());
 		assertEquals(0, engine.getServices().size());
 	}
 
 	@Test
-	public void removeServices() throws InvalidAcceleoPackageException {
+	public void removeService() {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 
-		engine.registerServiceInstance(new ExtendedTestServices1(provider));
+		final Set<IService> services = ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new ExtendedTestServices1(provider));
+		for (IService service : services) {
+			engine.registerService(service);
+		}
 
 		assertEquals(2, engine.getRegisteredServices().size());
 		assertEquals(2, engine.getServices().size());
 
-		engine.removeServices(ExtendedTestServices1.class);
+		for (IService service : services) {
+			engine.removeService(service);
+		}
 
 		assertEquals(0, engine.getRegisteredServices().size());
 		assertEquals(0, engine.getServices().size());
@@ -943,20 +1015,25 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void getServices() throws InvalidAcceleoPackageException, NoSuchMethodException, SecurityException {
+	public void getServices() throws NoSuchMethodException, SecurityException {
 		final CrossReferenceProvider provider = new TestCrossReferenceProvider();
 		final ITestLookupEngine engine = instanciate(provider);
 		final Set<IType> types = new LinkedHashSet<IType>();
 		types.add(new ClassType(engine.getQueryEnvironment(), EClassifier.class));
 
-		engine.registerServiceInstance(new ExtendedTestServices1(provider));
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new ExtendedTestServices1(provider))) {
+			engine.registerService(service);
+		}
 		final Set<IService> services = engine.getServices(types);
 		assertEquals(2, services.size());
-		final Iterator<IService> it = services.iterator();
-		assertEquals(ExtendedTestServices1.class.getMethod("service2", EClassifier.class),
-				((JavaMethodService)it.next()).getMethod());
-		assertEquals(ExtendedTestServices1.class.getMethod("service1", EClassifier.class),
-				((JavaMethodService)it.next()).getMethod());
+
+		final Set<Method> methods = new LinkedHashSet<Method>();
+		for (IService service : services) {
+			methods.add(((JavaMethodService)service).getMethod());
+		}
+		assertTrue(methods.contains(ExtendedTestServices1.class.getMethod("service1", EClassifier.class)));
+		assertTrue(methods.contains(ExtendedTestServices1.class.getMethod("service2", EClassifier.class)));
 	}
 
 	@Test
@@ -968,10 +1045,13 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void lookupLowerPriorityLowerType() throws InvalidAcceleoPackageException {
+	public void lookupLowerPriorityLowerType() {
 		final ITestLookupEngine engine = instanciate(null);
-		final ServiceRegistrationResult registrationResult = engine
-				.registerServiceInstance(new TestServiceProvider(0, EClass.class, 1, EClassifier.class));
+		final ServiceRegistrationResult registrationResult = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServiceProvider(0, EClass.class, 1, EClassifier.class))) {
+			registrationResult.merge(engine.registerService(service));
+		}
 
 		assertEquals(0, registrationResult.getDuplicated().size());
 		assertEquals(0, registrationResult.getIsMaskedBy().size());
@@ -996,10 +1076,13 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void lookupLowerPriorityEqualType() throws InvalidAcceleoPackageException {
+	public void lookupLowerPriorityEqualType() {
 		final ITestLookupEngine engine = instanciate(null);
-		final ServiceRegistrationResult registrationResult = engine
-				.registerServiceInstance(new TestServiceProvider(0, EClassifier.class, 1, EClassifier.class));
+		final ServiceRegistrationResult registrationResult = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServiceProvider(0, EClassifier.class, 1, EClassifier.class))) {
+			registrationResult.merge(engine.registerService(service));
+		}
 
 		assertEquals(0, registrationResult.getDuplicated().size());
 		assertEquals(0, registrationResult.getIsMaskedBy().size());
@@ -1024,10 +1107,13 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void lookupLowerPriorityGreaterType() throws InvalidAcceleoPackageException {
+	public void lookupLowerPriorityGreaterType() {
 		final ITestLookupEngine engine = instanciate(null);
-		final ServiceRegistrationResult registrationResult = engine
-				.registerServiceInstance(new TestServiceProvider(0, EClassifier.class, 1, EClass.class));
+		final ServiceRegistrationResult registrationResult = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServiceProvider(0, EClassifier.class, 1, EClass.class))) {
+			registrationResult.merge(engine.registerService(service));
+		}
 
 		assertEquals(0, registrationResult.getDuplicated().size());
 		assertEquals(0, registrationResult.getIsMaskedBy().size());
@@ -1052,10 +1138,13 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void lookupEqualPriorityLowerType() throws InvalidAcceleoPackageException {
+	public void lookupEqualPriorityLowerType() {
 		final ITestLookupEngine engine = instanciate(null);
-		final ServiceRegistrationResult registrationResult = engine
-				.registerServiceInstance(new TestServiceProvider(0, EClass.class, 0, EClassifier.class));
+		final ServiceRegistrationResult registrationResult = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServiceProvider(0, EClass.class, 0, EClassifier.class))) {
+			registrationResult.merge(engine.registerService(service));
+		}
 
 		assertEquals(0, registrationResult.getDuplicated().size());
 		assertEquals(1, registrationResult.getIsMaskedBy().size());
@@ -1081,10 +1170,13 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void lookupEqualPriorityEqualType() throws InvalidAcceleoPackageException {
+	public void lookupEqualPriorityEqualType() {
 		final ITestLookupEngine engine = instanciate(null);
-		final ServiceRegistrationResult registrationResult = engine
-				.registerServiceInstance(new TestServiceProvider(0, EClassifier.class, 0, EClassifier.class));
+		final ServiceRegistrationResult registrationResult = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServiceProvider(0, EClassifier.class, 0, EClassifier.class))) {
+			registrationResult.merge(engine.registerService(service));
+		}
 
 		assertEquals(1, registrationResult.getDuplicated().size());
 		Entry<IService, List<IService>> entry = registrationResult.getDuplicated().entrySet().iterator()
@@ -1110,10 +1202,13 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void lookupEqualPriorityGreaterType() throws InvalidAcceleoPackageException {
+	public void lookupEqualPriorityGreaterType() {
 		final ITestLookupEngine engine = instanciate(null);
-		final ServiceRegistrationResult registrationResult = engine
-				.registerServiceInstance(new TestServiceProvider(0, EClassifier.class, 0, EClass.class));
+		final ServiceRegistrationResult registrationResult = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServiceProvider(0, EClassifier.class, 0, EClass.class))) {
+			registrationResult.merge(engine.registerService(service));
+		}
 
 		assertEquals(0, registrationResult.getDuplicated().size());
 		assertEquals(0, registrationResult.getIsMaskedBy().size());
@@ -1139,10 +1234,13 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void lookupGreaterPriorityLowerType() throws InvalidAcceleoPackageException {
+	public void lookupGreaterPriorityLowerType() {
 		final ITestLookupEngine engine = instanciate(null);
-		final ServiceRegistrationResult registrationResult = engine
-				.registerServiceInstance(new TestServiceProvider(1, EClass.class, 0, EClassifier.class));
+		final ServiceRegistrationResult registrationResult = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServiceProvider(1, EClass.class, 0, EClassifier.class))) {
+			registrationResult.merge(engine.registerService(service));
+		}
 
 		assertEquals(0, registrationResult.getDuplicated().size());
 		assertEquals(1, registrationResult.getIsMaskedBy().size());
@@ -1168,10 +1266,13 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void lookupGreaterPriorityEqualType() throws InvalidAcceleoPackageException {
+	public void lookupGreaterPriorityEqualType() {
 		final ITestLookupEngine engine = instanciate(null);
-		final ServiceRegistrationResult registrationResult = engine
-				.registerServiceInstance(new TestServiceProvider(1, EClassifier.class, 0, EClassifier.class));
+		final ServiceRegistrationResult registrationResult = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServiceProvider(1, EClassifier.class, 0, EClassifier.class))) {
+			registrationResult.merge(engine.registerService(service));
+		}
 
 		assertEquals(0, registrationResult.getDuplicated().size());
 		assertEquals(1, registrationResult.getIsMaskedBy().size());
@@ -1197,10 +1298,13 @@ public class LookupEngineTest {
 	}
 
 	@Test
-	public void lookupGreaterPriorityGreaterType() throws InvalidAcceleoPackageException {
+	public void lookupGreaterPriorityGreaterType() {
 		final ITestLookupEngine engine = instanciate(null);
-		final ServiceRegistrationResult registrationResult = engine
-				.registerServiceInstance(new TestServiceProvider(1, EClassifier.class, 0, EClass.class));
+		final ServiceRegistrationResult registrationResult = new ServiceRegistrationResult();
+		for (IService service : ServiceUtils.getServices(engine.getQueryEnvironment(),
+				new TestServiceProvider(1, EClassifier.class, 0, EClass.class))) {
+			registrationResult.merge(engine.registerService(service));
+		}
 
 		assertEquals(0, registrationResult.getDuplicated().size());
 		assertEquals(1, registrationResult.getIsMaskedBy().size());
diff --git a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/lookup/basic/TestServiceProvider.java b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/lookup/basic/TestServiceProvider.java
index c46c63405..5e307d05a 100644
--- a/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/lookup/basic/TestServiceProvider.java
+++ b/query/tests/org.eclipse.acceleo.query.tests/src/org/eclipse/acceleo/query/tests/runtime/lookup/basic/TestServiceProvider.java
@@ -19,7 +19,6 @@ import org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment;
 import org.eclipse.acceleo.query.runtime.IService;
 import org.eclipse.acceleo.query.runtime.IServiceProvider;
 import org.eclipse.acceleo.query.runtime.IValidationResult;
-import org.eclipse.acceleo.query.runtime.InvalidAcceleoPackageException;
 import org.eclipse.acceleo.query.runtime.impl.AbstractService;
 import org.eclipse.acceleo.query.runtime.impl.ValidationServices;
 import org.eclipse.acceleo.query.validation.type.ClassType;
@@ -233,14 +232,8 @@ public class TestServiceProvider implements IServiceProvider {
 		this.type2 = type2;
 	}
 
-	/**
-	 * {@inheritDoc}
-	 *
-	 * @see org.eclipse.acceleo.query.runtime.IServiceProvider#getServices(org.eclipse.acceleo.query.runtime.IReadOnlyQueryEnvironment)
-	 */
 	@Override
-	public List<IService> getServices(IReadOnlyQueryEnvironment queryEnvironment)
-			throws InvalidAcceleoPackageException {
+	public List<IService> getServices(IReadOnlyQueryEnvironment queryEnvironment) {
 		final List<IService> result = new ArrayList<IService>();
 
 		result.add(new Service1());