diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/ContextChangeEvent.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/ContextChangeEvent.java
index 3aabd9f..fe66ece 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/ContextChangeEvent.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/ContextChangeEvent.java
@@ -10,7 +10,6 @@
  *******************************************************************************/
 package org.eclipse.e4.core.services.context;
 
-import org.eclipse.e4.core.services.injector.IObjectProvider;
 
 /**
  * An event describing a change to an {@link IEclipseContext}. The following types of events are
@@ -67,7 +66,7 @@
 	public static final int UPDATE = 5;
 
 	private Object[] args;
-	private IObjectProvider context;
+	private IEclipseContext context;
 	private int eventType;
 	private String key;
 
@@ -81,7 +80,7 @@
 	 * @param args
 	 * @param name
 	 */
-	ContextChangeEvent(IObjectProvider context, int eventType, Object[] args, String name,
+	ContextChangeEvent(IEclipseContext context, int eventType, Object[] args, String name,
 			Object oldValue) {
 		this.context = context;
 		this.key = name;
@@ -105,7 +104,7 @@
 	 * 
 	 * @return the context where the change occurred
 	 */
-	public IObjectProvider getContext() {
+	public IEclipseContext getContext() {
 		return context;
 	}
 
@@ -135,8 +134,8 @@
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
-		if ((eventType == DISPOSE) || (eventType == UNINJECTED))
-			result = prime * result + ((context == null) ? 0 : context.hashCode());
+		// if ((eventType == DISPOSE) || (eventType == UNINJECTED))
+		// result = prime * result + ((context == null) ? 0 : context.hashCode());
 		result = prime * result + eventType;
 		result = prime * result + ((key == null) ? 0 : key.hashCode());
 		return result;
@@ -151,13 +150,13 @@
 			return false;
 		ContextChangeEvent other = (ContextChangeEvent) obj;
 
-		if ((eventType == DISPOSE) || (eventType == UNINJECTED)) {
-			if (context == null) {
-				if (other.context != null)
-					return false;
-			} else if (!context.equals(other.context))
-				return false;
-		}
+		// if ((eventType == DISPOSE) || (eventType == UNINJECTED)) {
+		// if (context == null) {
+		// if (other.context != null)
+		// return false;
+		// } else if (!context.equals(other.context))
+		// return false;
+		// }
 
 		if (eventType != other.eventType)
 			return false;
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/EclipseContextFactory.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/EclipseContextFactory.java
index cf16ce2..5f1cf5b 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/EclipseContextFactory.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/EclipseContextFactory.java
@@ -15,9 +15,7 @@
 import org.eclipse.e4.core.services.context.spi.IContextConstants;
 import org.eclipse.e4.core.services.context.spi.IEclipseContextStrategy;
 import org.eclipse.e4.core.services.context.spi.ILookupStrategy;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
 import org.eclipse.e4.core.services.internal.context.EclipseContext;
-import org.eclipse.e4.core.services.internal.context.ObjectProviderContext;
 import org.eclipse.e4.internal.core.services.osgi.OSGiContextStrategy;
 import org.osgi.framework.BundleContext;
 
@@ -97,12 +95,6 @@
 	 */
 	public static ContextChangeEvent createContextEvent(IEclipseContext context, int eventType,
 			Object[] args, String name, Object oldValue) {
-		return new ContextChangeEvent(new ObjectProviderContext(context), eventType, args, name,
-				oldValue);
-	}
-
-	public static ContextChangeEvent createContextEvent(IObjectProvider provider, int eventType,
-			Object[] args, String name, Object oldValue) {
-		return new ContextChangeEvent(provider, eventType, args, name, oldValue);
+		return new ContextChangeEvent(context, eventType, args, name, oldValue);
 	}
 }
\ No newline at end of file
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/spi/ContextInjectionFactory.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/spi/ContextInjectionFactory.java
index 82c7094..a85bd43 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/spi/ContextInjectionFactory.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/context/spi/ContextInjectionFactory.java
@@ -16,11 +16,11 @@
 import org.eclipse.e4.core.services.IDisposable;
 import org.eclipse.e4.core.services.context.IEclipseContext;
 import org.eclipse.e4.core.services.context.IEclipseContextAware;
+import org.eclipse.e4.core.services.injector.AbstractObjectSupplier;
 import org.eclipse.e4.core.services.injector.IInjector;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
 import org.eclipse.e4.core.services.injector.InjectorFactory;
+import org.eclipse.e4.core.services.internal.context.ContextObjectSupplier;
 import org.eclipse.e4.core.services.internal.context.EclipseContext;
-import org.eclipse.e4.core.services.internal.context.ObjectProviderContext;
 
 /**
  * An injection factory is used to inject data and services from a context into a domain object. The
@@ -93,8 +93,9 @@
 	 * @return Returns the injected object
 	 */
 	static public Object inject(Object object, IEclipseContext context) {
-		IObjectProvider provider = ObjectProviderContext.getObjectProvider(context);
-		injector.inject(object, provider);
+		AbstractObjectSupplier supplier = ContextObjectSupplier.getObjectSupplier(context,
+				injector);
+		injector.inject(object, supplier);
 		return object;
 	}
 
@@ -115,8 +116,9 @@
 	 */
 	static public Object invoke(Object object, String methodName, IEclipseContext context)
 			throws InvocationTargetException, CoreException {
-		IObjectProvider provider = ObjectProviderContext.getObjectProvider(context);
-		return injector.invoke(object, methodName, provider);
+		AbstractObjectSupplier supplier = ContextObjectSupplier.getObjectSupplier(context,
+				injector);
+		return injector.invoke(object, methodName, supplier);
 	}
 
 	/**
@@ -136,8 +138,9 @@
 	 */
 	static public Object invoke(Object object, String methodName, IEclipseContext context,
 			Object defaultValue) throws InvocationTargetException {
-		IObjectProvider provider = ObjectProviderContext.getObjectProvider(context);
-		return injector.invoke(object, methodName, defaultValue, provider);
+		AbstractObjectSupplier supplier = ContextObjectSupplier.getObjectSupplier(context,
+				injector);
+		return injector.invoke(object, methodName, defaultValue, supplier);
 	}
 
 	/**
@@ -169,7 +172,8 @@
 	 */
 	static public Object make(Class clazz, final IEclipseContext context)
 			throws InvocationTargetException, InstantiationException {
-		IObjectProvider provider = ObjectProviderContext.getObjectProvider(context);
-		return injector.make(clazz, provider);
+		AbstractObjectSupplier supplier = ContextObjectSupplier.getObjectSupplier(context,
+				injector);
+		return injector.make(clazz, supplier);
 	}
 }
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/AbstractObjectSupplier.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/AbstractObjectSupplier.java
new file mode 100644
index 0000000..d7d24d1
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/AbstractObjectSupplier.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.injector;
+
+/**
+ * This interface describes an "object supplier" - something that knows how to instantiate objects
+ * corresponding to the descriptor. NOTE: This is a preliminary form; this API will change.
+ */
+abstract public class AbstractObjectSupplier {
+
+	final protected IInjector injector;
+
+	// TBD remove?
+	abstract public Object get(IObjectDescriptor descriptor, IRequestor requestor);
+
+	abstract public Object[] get(IObjectDescriptor[] descriptors, IRequestor requestor);
+
+	public AbstractObjectSupplier(IInjector injector) {
+		this.injector = injector;
+	}
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IBinding.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IBinding.java
new file mode 100644
index 0000000..72476a4
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IBinding.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.injector;
+
+// TBD should this be an abstract base class?
+/**
+ * Describes binding between object description and its implementation to be used by the dependency
+ * injection.
+ * 
+ */
+public interface IBinding {
+
+	public IBinding named(String name);
+
+	public IBinding implementedBy(Class<?> clazz);
+
+	public Class<?> getDescribedClass();
+
+	public String getQualifierName();
+
+	public Class<?> getImplementationClass();
+
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IInjector.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IInjector.java
index 62c75b8..d6a67c7 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IInjector.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IInjector.java
@@ -23,17 +23,32 @@
  */
 public interface IInjector {
 
-	public boolean inject(Object object, IObjectProvider objectProvider);
+	final public static Object NOT_A_VALUE = new Object();
 
-	public Object make(Class clazz, IObjectProvider objectProvider)
-			throws InvocationTargetException, InstantiationException;
+	public boolean inject(Object object, AbstractObjectSupplier objectSupplier);
 
-	public Object invoke(Object object, String methodName, IObjectProvider objectProvider)
+	public boolean uninject(Object object, AbstractObjectSupplier objectSupplier);
+
+	public Object invoke(Object object, String methodName, AbstractObjectSupplier objectSupplier)
 			throws InvocationTargetException, CoreException;
 
 	public Object invoke(Object object, String methodName, Object defaultValue,
-			IObjectProvider objectProvider) throws InvocationTargetException;
+			AbstractObjectSupplier objectSupplier) throws InvocationTargetException;
 
-	public boolean injectStatic(Class clazz, IObjectProvider objectProvider);
+	public Object make(Class<?> clazz, AbstractObjectSupplier objectSupplier)
+			throws InvocationTargetException, InstantiationException;
+
+	public Object make(IObjectDescriptor descriptor, AbstractObjectSupplier objectSupplier)
+			throws InvocationTargetException, InstantiationException;
+
+	public boolean injectStatic(Class<?> clazz, AbstractObjectSupplier objectSupplier);
+
+	public boolean update(IRequestor[] requestors, AbstractObjectSupplier objectSupplier);
+
+	public boolean disposed(AbstractObjectSupplier objectSupplier);
+
+	public IBinding addBinding(Class<?> clazz);
+
+	public IBinding addBinding(IBinding binding);
 
 }
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IObjectDescriptor.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IObjectDescriptor.java
new file mode 100644
index 0000000..c6040af
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IObjectDescriptor.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.injector;
+
+import java.lang.reflect.Type;
+
+/**
+ * NOTE: This is a preliminary form; this API will change.
+ * 
+ * @noextend This interface is not intended to be extended by clients.
+ * @noimplement This interface is not intended to be implemented by clients.
+ */
+public interface IObjectDescriptor {
+
+	// TBD rename getDesiredClass()
+	// TBD is this needed if we can get a Type?
+	public Class<?> getElementClass();
+
+	public Type getElementType();
+
+	public boolean isOptional();
+
+	public boolean hasQualifier(String qualifier);
+
+	public String[] getQualifiers();
+
+	public String getQualifierValue(String qualifier);
+
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IObjectProvider.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IObjectProvider.java
deleted file mode 100644
index 3b3323f..0000000
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IObjectProvider.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009, 2010 IBM Corporation and others.
- * 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:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.e4.core.services.injector;
-
-import org.eclipse.e4.core.services.context.IRunAndTrack;
-
-/**
- * This interface describes an "object provider" - something that knows how to instantiate objects
- * corresponding to the key. NOTE: This is a preliminary form; this API will change.
- */
-public interface IObjectProvider {
-
-	public boolean containsKey(ObjectDescriptor key);
-
-	public Object get(ObjectDescriptor key);
-
-	// TBD replace this with events specific to injection, not context
-	public void runAndTrack(final IRunAndTrack runnable, Object[] args);
-}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IRequestor.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IRequestor.java
new file mode 100644
index 0000000..5e64c9d
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/IRequestor.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.injector;
+
+// TBD this is really a "feedback" object. 
+/**
+ * @noimplement This interface is not intended to be implemented by clients.
+ * @noextend This interface is not intended to be extended by clients.
+ */
+public interface IRequestor {
+
+	/**
+	 * The injected object that initiated this request
+	 */
+	public Object getRequestingObject();
+
+	/**
+	 * Determines if the requestor wants to be called whenever one of the dependent object changes.
+	 */
+	public boolean shouldTrack();
+
+	public boolean shouldGroupUpdates();
+
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/ObjectDescriptorFactory.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/ObjectDescriptorFactory.java
new file mode 100644
index 0000000..c2ef932
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/ObjectDescriptorFactory.java
@@ -0,0 +1,54 @@
+/*******************************************************************************
+ * Copyright (c) 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.injector;
+
+import java.lang.reflect.Type;
+import javax.inject.Named;
+import org.eclipse.e4.core.services.internal.context.ObjectDescriptor;
+
+/**
+ * NOTE: This is a preliminary form; this API will change.
+ * 
+ * @noextend This class is not intended to be subclassed by clients.
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ */
+final public class ObjectDescriptorFactory {
+
+	static final private String named = Named.class.getName();
+
+	private ObjectDescriptorFactory() {
+		// prevents instantiation
+	}
+
+	static public IObjectDescriptor make(Class<?> clazz, boolean optional) {
+		return new ObjectDescriptor(clazz, null, null, optional);
+	}
+
+	static public IObjectDescriptor make(Type type, boolean optional) {
+		return new ObjectDescriptor(type, null, null, optional);
+	}
+
+	static public IObjectDescriptor make(String name, boolean optional) {
+		return new ObjectDescriptor(null, new String[] { named }, new String[] { name }, optional);
+	}
+
+	static public IObjectDescriptor make(Class<?> clazz, String name, boolean optional) {
+		if (name == null)
+			return make(clazz, optional);
+		return new ObjectDescriptor(clazz, new String[] { named }, new String[] { name }, optional);
+	}
+
+	static public IObjectDescriptor make(Type type, String name, boolean optional) {
+		if (name == null)
+			return make(type, optional);
+		return new ObjectDescriptor(type, new String[] { named }, new String[] { name }, optional);
+	}
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/annotations/AnnotationsSupport.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/annotations/AnnotationsSupport.java
index fc007da..2fbdef5 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/annotations/AnnotationsSupport.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/annotations/AnnotationsSupport.java
@@ -13,7 +13,7 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
+import java.lang.reflect.Type;
 import org.eclipse.e4.core.services.internal.context.InjectionProperties;
 
 /**
@@ -25,28 +25,28 @@
 		// placeholder
 	}
 
-	public InjectionProperties getInjectProperties(Field field, IObjectProvider context) {
+	public InjectionProperties getInjectProperties(Field field) {
 		return new InjectionProperties(false, null, false);
 	}
 
-	public InjectionProperties getInjectProperties(Method method, IObjectProvider context) {
+	public InjectionProperties getInjectProperties(Method method) {
 		return new InjectionProperties(false, null, false);
 	}
 
-	public InjectionProperties getInjectProperties(Constructor constructor, IObjectProvider context) {
+	public InjectionProperties getInjectProperties(Constructor constructor) {
 		return new InjectionProperties(true, null, false);
 	}
 
-	public InjectionProperties[] getInjectParamsProperties(Constructor constructor,
-			IObjectProvider context) {
-		Class[] params = constructor.getParameterTypes();
+	public InjectionProperties[] getInjectParamsProperties(Constructor constructor) {
+		Type[] params = constructor.getGenericParameterTypes();
+
 		InjectionProperties[] result = new InjectionProperties[params.length];
 		for (int i = 0; i < result.length; i++)
 			result[i] = new InjectionProperties(false, null, false);
 		return result;
 	}
 
-	public InjectionProperties[] getInjectParamProperties(Method method, IObjectProvider context) {
+	public InjectionProperties[] getInjectParamProperties(Method method) {
 		Class[] params = method.getParameterTypes();
 		InjectionProperties[] result = new InjectionProperties[params.length];
 		for (int i = 0; i < result.length; i++)
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/Binding.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/Binding.java
new file mode 100644
index 0000000..192af5b
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/Binding.java
@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * Copyright (c) 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.internal.context;
+
+import org.eclipse.e4.core.services.injector.IBinding;
+import org.eclipse.e4.core.services.injector.IInjector;
+
+public class Binding implements IBinding {
+
+	final private Class<?> clazz;
+	final private IInjector injector;
+
+	private Class<?> implementationClazz;
+	private String qualifierName;
+
+	public Binding(Class<?> clazz, IInjector injector) {
+		this.clazz = clazz;
+		this.injector = injector;
+	}
+
+	private Binding(Binding source) {
+		this.clazz = source.clazz;
+		this.injector = source.injector;
+		this.implementationClazz = source.implementationClazz;
+		this.qualifierName = source.qualifierName;
+	}
+
+	public IBinding named(String name) {
+		Binding binding = new Binding(this);
+		binding.qualifierName = name;
+		injector.addBinding(binding);
+		return binding;
+	}
+
+	public IBinding implementedBy(Class<?> clazz) {
+		Binding binding = new Binding(this);
+		binding.implementationClazz = clazz;
+		injector.addBinding(binding);
+		return binding;
+	}
+
+	public Class<?> getDescribedClass() {
+		return clazz;
+	}
+
+	public String getQualifierName() {
+		return qualifierName;
+	}
+
+	public Class<?> getImplementationClass() {
+		if (implementationClazz != null)
+			return implementationClazz;
+		return clazz;
+	}
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/Computation.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/Computation.java
index c71570b..59afe26 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/Computation.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/Computation.java
@@ -18,7 +18,6 @@
 import java.util.Set;
 import org.eclipse.e4.core.services.context.ContextChangeEvent;
 import org.eclipse.e4.core.services.context.IEclipseContext;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
 import org.eclipse.e4.core.services.internal.context.EclipseContext.Scheduled;
 
 abstract class Computation {
@@ -52,8 +51,7 @@
 	public abstract boolean equals(Object arg0);
 
 	final void handleInvalid(ContextChangeEvent event, List<Scheduled> scheduled) {
-		IObjectProvider provider = event.getContext();
-		IEclipseContext context = ((ObjectProviderContext) provider).getContext();
+		IEclipseContext context = event.getContext();
 
 		String name = event.getName();
 		Set<String> names = dependencies.get(context);
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ConstructorRequestor.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ConstructorRequestor.java
new file mode 100644
index 0000000..1407b0c
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ConstructorRequestor.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.internal.context;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Type;
+import org.eclipse.e4.core.services.injector.IObjectDescriptor;
+import org.eclipse.e4.core.services.injector.ObjectDescriptorFactory;
+
+public class ConstructorRequestor extends Requestor {
+
+	final private Constructor<?> constructor;
+
+	public ConstructorRequestor(Constructor<?> constructor) {
+		// TBD make an integer update types? 0 - static , 1 - normal, 2 - grouped?
+		super(null, false /* do not track */, false /* N/A: no updates */, false /* mandatory */);
+		this.constructor = constructor;
+	}
+
+	public Object execute() throws InvocationTargetException, InstantiationException {
+		return callConstructor(constructor, actualArgs);
+	}
+
+	@Override
+	public IObjectDescriptor[] getDependentObjects() {
+		// Class[] parameterTypes = constructor.getParameterTypes();
+		Type[] parameterTypes = constructor.getGenericParameterTypes();
+		InjectionProperties[] properties = annotationSupport.getInjectParamsProperties(constructor);
+		IObjectDescriptor[] descriptors = new IObjectDescriptor[properties.length];
+		for (int i = 0; i < properties.length; i++) {
+			descriptors[i] = ObjectDescriptorFactory.make(parameterTypes[i], properties[i]
+					.getPropertyName(), properties[i].isOptional());
+		}
+		return descriptors;
+	}
+
+	private Object callConstructor(Constructor<?> constructor, Object[] args)
+			throws InvocationTargetException, InstantiationException {
+		Object result = null;
+		boolean wasAccessible = true;
+		if (!constructor.isAccessible()) {
+			constructor.setAccessible(true);
+			wasAccessible = false;
+		}
+		try {
+			result = constructor.newInstance(args);
+		} catch (IllegalArgumentException e) {
+			// should not happen, is checked at the start of this method
+			logError(constructor, e);
+			return null;
+		} catch (IllegalAccessException e) {
+			// should not happen as we set constructor to be accessible
+			logError(constructor, e);
+			return null;
+		} finally {
+			if (!wasAccessible)
+				constructor.setAccessible(false);
+		}
+		return result;
+	}
+
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ContextObjectSupplier.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ContextObjectSupplier.java
new file mode 100644
index 0000000..8fbb8e2
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ContextObjectSupplier.java
@@ -0,0 +1,186 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.internal.context;
+
+import javax.inject.Named;
+import org.eclipse.e4.core.services.context.ContextChangeEvent;
+import org.eclipse.e4.core.services.context.IEclipseContext;
+import org.eclipse.e4.core.services.context.IRunAndTrack;
+import org.eclipse.e4.core.services.injector.AbstractObjectSupplier;
+import org.eclipse.e4.core.services.injector.IInjector;
+import org.eclipse.e4.core.services.injector.IObjectDescriptor;
+import org.eclipse.e4.core.services.injector.IRequestor;
+
+public class ContextObjectSupplier extends AbstractObjectSupplier {
+
+	static private class ContextInjectionListener implements IRunAndTrackObject {
+
+		final private Object[] result;
+		final private String[] keys;
+		final private IInjector injector;
+		final private IRequestor requestor;
+		final private AbstractObjectSupplier supplier;
+		final private IEclipseContext context;
+
+		public ContextInjectionListener(IEclipseContext context, Object[] result, String[] keys,
+				IInjector injector, IRequestor requestor, AbstractObjectSupplier supplier) {
+			this.result = result;
+			this.keys = keys;
+			this.injector = injector;
+			this.requestor = requestor;
+			this.supplier = supplier;
+			this.context = context;
+		}
+
+		public boolean notify(ContextChangeEvent event) {
+			if (event.getEventType() == ContextChangeEvent.INITIAL) {
+				// needs to be done inside runnable to establish dependencies
+				for (int i = 0; i < keys.length; i++) {
+					if (keys[i] == null)
+						continue;
+					if (context.containsKey(keys[i]))
+						result[i] = context.get(keys[i]);
+					else
+						result[i] = IInjector.NOT_A_VALUE; // TBD make sure this still creates
+															// dependency on the key
+				}
+			} else if (event.getEventType() == ContextChangeEvent.DISPOSE) {
+				injector.disposed(supplier);
+				return false;
+			} else if (event.getEventType() == ContextChangeEvent.UNINJECTED) {
+				injector.uninject(event.getArguments()[0], supplier);
+				return false;
+			} else
+				injector.update(new IRequestor[] { requestor }, supplier);
+			return true;
+		}
+
+		@Override
+		public int hashCode() {
+			final int prime = 31;
+			int result = 1;
+			result = prime * result + ((context == null) ? 0 : context.hashCode());
+			result = prime * result + ((injector == null) ? 0 : injector.hashCode());
+			result = prime * result + ((requestor == null) ? 0 : requestor.hashCode());
+			return result;
+		}
+
+		@Override
+		public boolean equals(Object obj) {
+			if (this == obj)
+				return true;
+			if (obj == null)
+				return false;
+			if (getClass() != obj.getClass())
+				return false;
+			ContextInjectionListener other = (ContextInjectionListener) obj;
+			if (context == null) {
+				if (other.context != null)
+					return false;
+			} else if (!context.equals(other.context))
+				return false;
+			if (injector == null) {
+				if (other.injector != null)
+					return false;
+			} else if (!injector.equals(other.injector))
+				return false;
+			if (requestor == null) {
+				if (other.requestor != null)
+					return false;
+			} else if (!requestor.equals(other.requestor))
+				return false;
+			return true;
+		}
+
+		public Object getObject() {
+			// XXX remove?
+			// TODO Auto-generated method stub
+			return null;
+		}
+
+		public boolean batchProcess() {
+			return requestor.shouldGroupUpdates();
+		}
+	}
+
+	final static private String ECLIPSE_CONTEXT_NAME = IEclipseContext.class.getName();
+	final private IEclipseContext context;
+
+	public ContextObjectSupplier(IEclipseContext context, IInjector injector) {
+		super(injector);
+		this.context = context;
+	}
+
+	public IEclipseContext getContext() {
+		return context;
+	}
+
+	@Override
+	public Object get(IObjectDescriptor descriptor, IRequestor requestor) {
+		// This method is rarely or never used on the primary supplier
+		if (descriptor == null)
+			return IInjector.NOT_A_VALUE;
+		Object[] result = get(new IObjectDescriptor[] { descriptor }, requestor);
+		if (result == null)
+			return null;
+		return result[0];
+	}
+
+	@Override
+	public Object[] get(IObjectDescriptor[] descriptors, final IRequestor requestor) {
+		final Object[] result = new Object[descriptors.length];
+		final String[] keys = new String[descriptors.length];
+
+		for (int i = 0; i < descriptors.length; i++) {
+			keys[i] = (descriptors[i] == null) ? null : getKey(descriptors[i]);
+			if (ECLIPSE_CONTEXT_NAME.equals(keys[i])) {
+				result[i] = context;
+				keys[i] = null;
+			}
+		}
+
+		if (requestor != null && requestor.shouldTrack()) { // only track if requested
+			IRunAndTrack trackable = new ContextInjectionListener(context, result, keys, injector,
+					requestor, this);
+			context.runAndTrack(trackable, null);
+		} else {
+			for (int i = 0; i < descriptors.length; i++) {
+				if (keys[i] == null)
+					continue;
+				if (context.containsKey(keys[i]))
+					result[i] = context.get(keys[i]);
+				else
+					result[i] = IInjector.NOT_A_VALUE;
+			}
+		}
+		return result;
+	}
+
+	private String getKey(IObjectDescriptor descriptor) {
+		if (descriptor.hasQualifier(Named.class.getName()))
+			return descriptor.getQualifierValue(Named.class.getName());
+		Class<?> elementClass = descriptor.getElementClass();
+		if (elementClass != null)
+			return elementClass.getName();
+		return null;
+	}
+
+	static public ContextObjectSupplier getObjectSupplier(IEclipseContext context,
+			IInjector injector) {
+		String key = ContextObjectSupplier.class.getName();
+		if (context.containsKey(key, true))
+			return (ContextObjectSupplier) context.get(key);
+		ContextObjectSupplier objectSupplier = new ContextObjectSupplier(context, injector);
+		context.set(key, objectSupplier);
+		return objectSupplier;
+	}
+
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/EclipseContext.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/EclipseContext.java
index 73b280d..0811591 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/EclipseContext.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/EclipseContext.java
@@ -151,8 +151,7 @@
 				if ((eventType == ContextChangeEvent.ADDED)
 						|| (eventType == ContextChangeEvent.REMOVED)) {
 					cachedEvent = event;
-					EclipseContext eventsContext = (EclipseContext) ((ObjectProviderContext) event
-							.getContext()).getContext();
+					EclipseContext eventsContext = (EclipseContext) event.getContext();
 					eventsContext.addWaiting(this);
 					// eventsContext.getRoot().waiting.add(this);
 					return true;
@@ -171,8 +170,7 @@
 			} finally {
 				currentComputation.set(oldComputation);
 			}
-			EclipseContext eventsContext = (EclipseContext) ((ObjectProviderContext) event
-					.getContext()).getContext();
+			EclipseContext eventsContext = (EclipseContext) event.getContext();
 			if (result)
 				startListening(eventsContext);
 			else
@@ -407,7 +405,7 @@
 	 * The given name has been modified or removed in this context. Invalidate all local value
 	 * computations and listeners that depend on this name.
 	 */
-	private void invalidate(String name, int eventType, Object oldValue, List<Scheduled> scheduled) {
+	public void invalidate(String name, int eventType, Object oldValue, List<Scheduled> scheduled) {
 		if (EclipseContext.DEBUG)
 			System.out.println("invalidating " + this + ',' + name); //$NON-NLS-1$
 		removeLocalValueComputations(name);
@@ -583,18 +581,11 @@
 	public void removeListenersTo(Object object) {
 		if (object == null)
 			return;
-		synchronized (listeners) {
-			ContextChangeEvent event = EclipseContextFactory.createContextEvent(this,
-					ContextChangeEvent.UNINJECTED, null, null, null);
-			for (Iterator<Computation> i = listeners.keySet().iterator(); i.hasNext();) {
-				Computation computation = i.next();
-				if (computation instanceof TrackableComputationExt) {
-					if (object == ((TrackableComputationExt) computation).getObject()) {
-						((IRunAndTrack) computation).notify(event);
-						i.remove();
-					}
-				}
-			}
+		Computation[] ls = listeners.keySet().toArray(new Computation[listeners.size()]);
+		ContextChangeEvent event = EclipseContextFactory.createContextEvent(this,
+				ContextChangeEvent.UNINJECTED, new Object[] { object }, null, null);
+		for (Computation computation : ls) {
+			((IRunAndTrack) computation).notify(event);
 		}
 	}
 
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/FieldRequestor.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/FieldRequestor.java
new file mode 100644
index 0000000..1d07427
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/FieldRequestor.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.internal.context;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import org.eclipse.e4.core.services.injector.IObjectDescriptor;
+import org.eclipse.e4.core.services.injector.ObjectDescriptorFactory;
+
+public class FieldRequestor extends Requestor {
+
+	final private Field field;
+
+	public FieldRequestor(Field field, Object requestingObject, boolean track,
+			boolean groupUpdates, boolean optional) {
+		super(requestingObject, track, groupUpdates, optional);
+		this.field = field;
+	}
+
+	public Object execute() throws InvocationTargetException, InstantiationException {
+		setField(field, actualArgs[0]);
+		return null;
+	}
+
+	@Override
+	public IObjectDescriptor[] getDependentObjects() {
+		InjectionProperties properties = annotationSupport.getInjectProperties(field);
+		IObjectDescriptor objectDescriptor = ObjectDescriptorFactory.make(field.getGenericType(),
+				properties.getPropertyName(), properties.isOptional());
+		return new IObjectDescriptor[] { objectDescriptor };
+	}
+
+	private boolean setField(Field field, Object value) {
+		Object userObject = getRequestingObject();
+		if (userObject == null)
+			return false;
+		boolean wasAccessible = true;
+		if (!field.isAccessible()) {
+			field.setAccessible(true);
+			wasAccessible = false;
+		}
+		try {
+			field.set(userObject, value);
+		} catch (IllegalArgumentException e) {
+			logError(field, e);
+			return false;
+		} catch (IllegalAccessException e) {
+			logError(field, e);
+			return false;
+		} finally {
+			if (!wasAccessible)
+				field.setAccessible(false);
+		}
+		return true;
+	}
+
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionAbstract.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionAbstract.java
deleted file mode 100644
index c2f7435..0000000
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionAbstract.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2010 IBM Corporation and others.
- * 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:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.e4.core.services.internal.context;
-
-import java.lang.ref.WeakReference;
-import org.eclipse.e4.core.services.context.ContextChangeEvent;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
-import org.eclipse.e4.core.services.injector.ObjectDescriptor;
-import org.eclipse.e4.core.services.internal.annotations.AnnotationsSupport;
-
-abstract public class InjectionAbstract implements IRunAndTrackObject {
-
-	final static protected Object NOT_A_VALUE = new Object();
-
-	final protected WeakReference userObjectRef;
-	final protected AnnotationsSupport annotationSupport;
-	final protected IObjectProvider primarySupplier;
-
-	protected boolean optional = false;
-	final private boolean batchProcess;
-
-	abstract public boolean notify(ContextChangeEvent event);
-
-	public InjectionAbstract(Object userObject, IObjectProvider primarySupplier,
-			boolean batchProcess) {
-		userObjectRef = new WeakReference(userObject);
-		// plug-in class that gets replaced in Java 1.5+
-		annotationSupport = new AnnotationsSupport(); // TBD this should be a static util class
-		this.primarySupplier = primarySupplier;
-		this.batchProcess = batchProcess;
-	}
-
-	public Object getObject() {
-		if (userObjectRef == null)
-			return null;
-		return userObjectRef.get();
-	}
-
-	protected boolean injectNulls(int eventType, IObjectProvider changed) {
-		if ((eventType != ContextChangeEvent.UNINJECTED)
-				&& (eventType != ContextChangeEvent.DISPOSE))
-			return false;
-		return (changed.equals(primarySupplier));
-	}
-
-	protected boolean ignoreMissing(int eventType, IObjectProvider changed) {
-		if (eventType == ContextChangeEvent.REMOVED)
-			return true;
-		if ((eventType != ContextChangeEvent.UNINJECTED)
-				&& (eventType != ContextChangeEvent.DISPOSE))
-			return false;
-		return (changed.equals(primarySupplier));
-	}
-
-	protected Object getValue(ObjectDescriptor objectDescriptor, InjectionProperties properties,
-			Class parameterType, boolean ignoreMissing, boolean injectWithNulls) {
-		// 1) if we have a provider, use it
-		Object provider = properties.getProvider();
-		if (provider != null)
-			return provider;
-
-		// 2) if we have the key in the context
-		if (primarySupplier.containsKey(objectDescriptor)) {
-			if (injectWithNulls)
-				return null;
-			Object value = primarySupplier.get(objectDescriptor);
-			if (value == null)
-				return value;
-			if (parameterType.isAssignableFrom(value.getClass()))
-				return value;
-		}
-
-		// 3) can we ignore this argument?
-		if (ignoreMissing || properties.isOptional())
-			return null;
-
-		if (!optional) {
-			String msg = "Unable to find value for \"" + objectDescriptor.toString() + "\"";
-			throw new IllegalArgumentException(msg);
-		}
-		return NOT_A_VALUE;
-	}
-
-	protected void logError(Object destination, Exception e) {
-		String msg = "Injection failed " + destination.toString();
-		logError(msg, e);
-	}
-
-	protected void logError(String msg, Exception e) {
-		System.out.println(msg); //$NON-NLS-1$
-		if (e != null)
-			e.printStackTrace();
-		// TBD convert this into real logging
-		// String msg = NLS.bind("Injection failed", destination.toString());
-		// RuntimeLog.log(new Status(IStatus.WARNING,
-		// IRuntimeConstants.PI_COMMON, 0, msg, e));
-	}
-
-	public boolean batchProcess() {
-		return batchProcess;
-	}
-
-}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionClass.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionClass.java
deleted file mode 100644
index aa79d6a..0000000
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionClass.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009, 2010 IBM Corporation and others.
- * 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:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.e4.core.services.internal.context;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Iterator;
-import org.eclipse.e4.core.services.IDisposable;
-import org.eclipse.e4.core.services.context.ContextChangeEvent;
-import org.eclipse.e4.core.services.context.IEclipseContext;
-import org.eclipse.e4.core.services.context.spi.ContextInjectionFactory;
-import org.eclipse.e4.core.services.context.spi.IContextConstants;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
-import org.eclipse.e4.core.services.injector.ObjectDescriptor;
-
-public class InjectionClass extends InjectionAbstract {
-
-	final static private String JAVA_OBJECT = "java.lang.Object"; //$NON-NLS-1$
-
-	public InjectionClass(Object userObject, IObjectProvider primarySupplier) {
-		super(userObject, primarySupplier, false);
-	}
-
-	public boolean notify(ContextChangeEvent event) {
-		Object object = getObject();
-		if (object == null)
-			return false;
-		int eventType = event.getEventType();
-		if (eventType == ContextChangeEvent.DISPOSE) {
-			if (object instanceof IDisposable)
-				((IDisposable) object).dispose();
-			processPreDestory(object, object.getClass(), new ArrayList(5));
-			return false;
-		}
-		if (eventType == ContextChangeEvent.INITIAL) {
-			processPostConstruct(object, object.getClass(), new ArrayList(5));
-		}
-		IObjectProvider context = event.getContext();
-		// pseudo-dependency to create a link
-		ObjectDescriptor desc = ObjectDescriptor.make("e4_valid_context");
-		context.get(desc);
-		return true;
-	}
-
-	private void processPostConstruct(Object userObject, Class objectClass, ArrayList classHierarchy) {
-		Class superClass = objectClass.getSuperclass();
-		if (superClass != null && !superClass.getName().equals(JAVA_OBJECT)) {
-			classHierarchy.add(objectClass);
-			processPostConstruct(userObject, superClass, classHierarchy);
-			classHierarchy.remove(objectClass);
-		}
-		Method[] methods = objectClass.getDeclaredMethods();
-		for (int i = 0; i < methods.length; i++) {
-			Method method = methods[i];
-			if (!isPostConstruct(method))
-				continue;
-			if (!isOverridden(method, classHierarchy)) {
-				InjectionMethod methodInvoke = new InjectionMethod(getObject(), primarySupplier,
-						method, false);
-				try {
-					methodInvoke.invoke(false, false);
-				} catch (InjectionException e) {
-					// TBD log
-					e.printStackTrace();
-				}
-			}
-		}
-	}
-
-	// TBD simplify this: only one non-annotation and one "implements IInitializable"?
-	/**
-	 * Returns whether the given method is a post-construction process method, as defined by the
-	 * class comment of {@link ContextInjectionFactory}.
-	 */
-	private boolean isPostConstruct(Method method) {
-		boolean isPostConstruct = annotationSupport.isPostConstruct(method);
-		if (isPostConstruct)
-			return true;
-		if (!method.getName().equals(IContextConstants.INJECTION_SET_CONTEXT_METHOD))
-			return false;
-		Class[] parms = method.getParameterTypes();
-		if (parms.length == 0)
-			return true;
-		if (parms.length == 1 && parms[0].equals(IEclipseContext.class))
-			return true;
-		return false;
-	}
-
-	private void processPreDestory(Object userObject, Class objectClass, ArrayList classHierarchy) {
-		Class superClass = objectClass.getSuperclass();
-		if (superClass != null && !superClass.getName().equals(JAVA_OBJECT)) {
-			classHierarchy.add(objectClass);
-			processPreDestory(userObject, superClass, classHierarchy);
-			classHierarchy.remove(objectClass);
-		}
-		Method[] methods = objectClass.getDeclaredMethods();
-		for (int i = 0; i < methods.length; i++) {
-			Method method = methods[i];
-			if (method.getParameterTypes().length > 0) // TBD why?
-				continue;
-			if (!annotationSupport.isPreDestory(method))
-				continue;
-			if (!isOverridden(method, classHierarchy)) {
-				InjectionMethod methodInvoke = new InjectionMethod(getObject(), primarySupplier,
-						method, false);
-				try {
-					methodInvoke.invoke(false, false);
-				} catch (InjectionException e) {
-					// TBD log
-					e.printStackTrace();
-				}
-			}
-		}
-	}
-
-	// TBD move into the base class? For @PostConstruct?
-	/**
-	 * Checks if a given method is overridden with an injectable method.
-	 */
-	private boolean isOverridden(Method method, ArrayList classHierarchy) {
-		int modifiers = method.getModifiers();
-		if (Modifier.isPrivate(modifiers))
-			return false;
-		if (Modifier.isStatic(modifiers))
-			return false;
-		// method is not private if we reached this line, check not(public OR protected)
-		boolean isDefault = !(Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers));
-
-		for (Iterator i = classHierarchy.iterator(); i.hasNext();) {
-			Class subClass = (Class) i.next();
-			Method override = null;
-			try {
-				override = subClass.getDeclaredMethod(method.getName(), method.getParameterTypes());
-			} catch (SecurityException e) {
-				continue;
-			} catch (NoSuchMethodException e) {
-				continue; // this is the desired outcome
-			}
-			if (override != null) {
-				if (isDefault) { // must be in the same package to override
-					Package originalPackage = method.getDeclaringClass().getPackage();
-					Package overridePackage = subClass.getPackage();
-
-					if (originalPackage == null && overridePackage == null)
-						return true;
-					if (originalPackage == null || overridePackage == null)
-						return false;
-					if (originalPackage.equals(overridePackage))
-						return true;
-				} else
-					return true;
-			}
-		}
-		return false;
-	}
-
-}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionConstructor.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionConstructor.java
deleted file mode 100644
index efaf0b2..0000000
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionConstructor.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009, 2010 IBM Corporation and others.
- * 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:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.e4.core.services.internal.context;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import org.eclipse.e4.core.services.context.ContextChangeEvent;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
-import org.eclipse.e4.core.services.injector.ObjectDescriptor;
-
-/**
- * Collection of static methods that deal with reflection-based injection at a low level.
- */
-public class InjectionConstructor extends InjectionAbstract {
-
-	private final Constructor constructor;
-
-	public InjectionConstructor(Object userObject, IObjectProvider primarySupplier,
-			Constructor constructor) {
-		super(userObject, primarySupplier, false);
-		this.constructor = constructor;
-	}
-
-	public boolean notify(ContextChangeEvent event) {
-		if (event.getEventType() == ContextChangeEvent.INITIAL)
-			make();
-		return false; // constructor injection is static by nature
-	}
-
-	public Object make() {
-		Object[] actualParams = processParams();
-		if (actualParams == null)
-			return null;
-		try {
-			return callConstructor(constructor, actualParams);
-		} catch (InvocationTargetException e) {
-			String msg = "Could not invoke " + constructor.getName();
-			logError(msg, e);
-			return null;
-		} catch (InstantiationException e) {
-			String msg = "Could not instantiate " + constructor.getName();
-			logError(msg, e);
-			return null;
-		}
-	}
-
-	private Object[] processParams() {
-		Class[] parameterTypes = constructor.getParameterTypes();
-		InjectionProperties[] properties = annotationSupport.getInjectParamsProperties(constructor,
-				primarySupplier);
-		Object[] actualParams = new Object[properties.length];
-		for (int i = 0; i < actualParams.length; i++) {
-			try {
-				ObjectDescriptor objectDescriptor = ObjectDescriptor.make(parameterTypes[i],
-						properties[i].getPropertyName());
-				actualParams[i] = getValue(objectDescriptor, properties[i], parameterTypes[i],
-						false, false);
-			} catch (IllegalArgumentException e) {
-				String msg = "Unable to find matching arguments for " + constructor.getName();
-				logError(msg, e);
-				return null;
-			}
-		}
-		return actualParams;
-	}
-
-	private Object callConstructor(Constructor constructor, Object[] args)
-			throws InvocationTargetException, InstantiationException {
-		if (args != null) { // make sure args are assignable
-			Class[] parameterTypes = constructor.getParameterTypes();
-			if (parameterTypes.length != args.length) {
-				// internal error, log it
-				logError(constructor, new IllegalArgumentException());
-				return null;
-			}
-			for (int i = 0; i < args.length; i++) {
-				if ((args[i] != null) && !parameterTypes[i].isAssignableFrom(args[i].getClass()))
-					return null;
-			}
-		}
-
-		Object result = null;
-		boolean wasAccessible = true;
-		if (!constructor.isAccessible()) {
-			constructor.setAccessible(true);
-			wasAccessible = false;
-		}
-		try {
-			result = constructor.newInstance(args);
-		} catch (IllegalArgumentException e) {
-			// should not happen, is checked at the start of this method
-			logError(constructor, e);
-			return null;
-		} catch (IllegalAccessException e) {
-			// should not happen as we set constructor to be accessible
-			logError(constructor, e);
-			return null;
-		} finally {
-			if (!wasAccessible)
-				constructor.setAccessible(false);
-		}
-		return result;
-	}
-}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionField.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionField.java
deleted file mode 100644
index b7cb645..0000000
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionField.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009, 2010 IBM Corporation and others.
- * 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:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.e4.core.services.internal.context;
-
-import java.lang.reflect.Field;
-import org.eclipse.e4.core.services.context.ContextChangeEvent;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
-import org.eclipse.e4.core.services.injector.ObjectDescriptor;
-
-/**
- * Collection of static methods that deal with reflection-based injection at a low level.
- */
-public class InjectionField extends InjectionAbstract {
-
-	private final Field field;
-
-	public InjectionField(Object userObject, IObjectProvider primarySupplier, Field field,
-			boolean batchProcess) {
-		super(userObject, primarySupplier, batchProcess);
-		this.field = field;
-		InjectionProperties fieldProps = annotationSupport.getInjectProperties(field,
-				primarySupplier);
-		optional = fieldProps.isOptional();
-	}
-
-	public boolean notify(ContextChangeEvent event) {
-		Object userObject = getObject();
-		if (userObject == null)
-			return false;
-		// set variables based on the event type
-		int eventType = event.getEventType();
-		IObjectProvider changed = event.getContext();
-
-		boolean ignoreMissing = ignoreMissing(eventType, changed);
-		boolean injectWithNulls = injectNulls(eventType, changed);
-
-		InjectionProperties properties = annotationSupport.getInjectProperties(field,
-				primarySupplier);
-		ObjectDescriptor objectDescriptor = ObjectDescriptor.make(field.getType(), properties
-				.getPropertyName());
-		Object value;
-		try {
-			value = getValue(objectDescriptor, properties, field.getType(), ignoreMissing,
-					injectWithNulls);
-		} catch (IllegalArgumentException e) {
-			String msg = "Could not set " + field.getName();
-			logError(msg, e);
-			return true; // keep trying?
-		}
-		setField(value);
-		if (eventType == ContextChangeEvent.DISPOSE && primarySupplier.equals(changed))
-			return false;
-		return true;
-	}
-
-	private boolean setField(Object value) {
-		Object userObject = getObject();
-		boolean wasAccessible = true;
-		if (!field.isAccessible()) {
-			field.setAccessible(true);
-			wasAccessible = false;
-		}
-		try {
-			field.set(userObject, value);
-		} catch (IllegalArgumentException e) {
-			logError(field, e);
-			return false;
-		} catch (IllegalAccessException e) {
-			logError(field, e);
-			return false;
-		} finally {
-			if (!wasAccessible)
-				field.setAccessible(false);
-		}
-		return true;
-	}
-
-}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionMethod.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionMethod.java
deleted file mode 100644
index 69ddd8d..0000000
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectionMethod.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009, 2010 IBM Corporation and others.
- * 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:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.e4.core.services.internal.context;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import org.eclipse.e4.core.services.context.ContextChangeEvent;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
-import org.eclipse.e4.core.services.injector.ObjectDescriptor;
-
-/**
- * Collection of static methods that deal with reflection-based injection at a low level.
- */
-public class InjectionMethod extends InjectionAbstract {
-
-	private final Method method;
-
-	public InjectionMethod(Object userObject, IObjectProvider primarySupplier, Method method,
-			boolean batchProcess) {
-		super(userObject, primarySupplier, batchProcess);
-		this.method = method;
-		InjectionProperties methodProps = annotationSupport.getInjectProperties(method,
-				primarySupplier);
-		optional = methodProps.isOptional();
-	}
-
-	public boolean notify(ContextChangeEvent event) {
-		Object userObject = getObject();
-		if (userObject == null)
-			return false;
-		int eventType = event.getEventType();
-		IObjectProvider changed = event.getContext();
-		boolean ignoreMissing = ignoreMissing(eventType, changed);
-		boolean injectWithNulls = injectNulls(eventType, changed);
-		try {
-			invoke(ignoreMissing, injectWithNulls);
-		} catch (InjectionException e) {
-			logError(method, e);
-			return false;
-		}
-		if (eventType == ContextChangeEvent.DISPOSE && primarySupplier.equals(changed))
-			return false;
-		return true;
-	}
-
-	public Object invoke(boolean ignoreMissing, boolean injectWithNulls) throws InjectionException {
-		Object[] actualParams = processParams(ignoreMissing, injectWithNulls);
-		if (actualParams == null) {
-			if (!optional) {
-				String msg = "Unable to find matching argument to call method \""
-						+ method.getName() + "\"";
-				throw new InjectionException(msg);
-			}
-			return null;
-		}
-		try {
-			return callMethod(actualParams);
-		} catch (InvocationTargetException e) {
-			String msg = "Unexpected error invoking method \"" + method.getName() + "\"";
-			throw new InjectionException(msg, e);
-		}
-	}
-
-	private Object[] processParams(boolean ignoreMissing, boolean injectWithNulls) {
-		Class[] parameterTypes = method.getParameterTypes();
-		InjectionProperties[] properties = annotationSupport.getInjectParamProperties(method,
-				primarySupplier);
-		Object[] actualParams = new Object[properties.length];
-		for (int i = 0; i < actualParams.length; i++) {
-			try {
-				ObjectDescriptor objectDescriptor = ObjectDescriptor.make(parameterTypes[i],
-						properties[i].getPropertyName());
-				Object actualValue = getValue(objectDescriptor, properties[i], parameterTypes[i],
-						ignoreMissing, injectWithNulls);
-				if (actualValue == NOT_A_VALUE)
-					return null;
-				actualParams[i] = actualValue;
-			} catch (IllegalArgumentException e) {
-				String msg = "Could not invoke " + method.getName();
-				logError(msg, e);
-				return null;
-			}
-		}
-		return actualParams;
-	}
-
-	private Object callMethod(Object[] args) throws InvocationTargetException {
-		Object userObject = getObject();
-		Object result = null;
-		boolean wasAccessible = true;
-		if (!method.isAccessible()) {
-			method.setAccessible(true);
-			wasAccessible = false;
-		}
-		try {
-			result = method.invoke(userObject, args);
-		} catch (IllegalArgumentException e) {
-			// should not happen, is checked during formation of the array of actual arguments
-			logError(method, e);
-			return null;
-		} catch (IllegalAccessException e) {
-			// should not happen, is checked at the start of this method
-			logError(method, e);
-			return null;
-		} finally {
-			if (!wasAccessible)
-				method.setAccessible(false);
-		}
-		return result;
-	}
-}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectorImpl.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectorImpl.java
index 88829a8..2ed6436 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectorImpl.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/InjectorImpl.java
@@ -10,126 +10,608 @@
  *******************************************************************************/
 package org.eclipse.e4.core.services.internal.context;
 
+import java.lang.ref.WeakReference;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.inject.Named;
+import javax.inject.Provider;
+import javax.inject.Singleton;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
-import org.eclipse.e4.core.internal.services.ServicesActivator;
+import org.eclipse.e4.core.services.IDisposable;
+import org.eclipse.e4.core.services.context.IEclipseContext;
+import org.eclipse.e4.core.services.context.spi.ContextInjectionFactory;
 import org.eclipse.e4.core.services.context.spi.IContextConstants;
-import org.eclipse.e4.core.services.events.IEventBroker;
+import org.eclipse.e4.core.services.injector.AbstractObjectSupplier;
+import org.eclipse.e4.core.services.injector.IBinding;
 import org.eclipse.e4.core.services.injector.IInjector;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
-import org.eclipse.e4.core.services.injector.ObjectDescriptor;
+import org.eclipse.e4.core.services.injector.IObjectDescriptor;
+import org.eclipse.e4.core.services.injector.IRequestor;
+import org.eclipse.e4.core.services.injector.ObjectDescriptorFactory;
 import org.eclipse.e4.core.services.internal.annotations.AnnotationsSupport;
-import org.osgi.service.event.Event;
-import org.osgi.service.event.EventHandler;
 
 /**
  * Reflection-based dependency injector.
  */
 public class InjectorImpl implements IInjector {
 
-	final static private String DEBUG_INJECTOR = "org.eclipse.e4.core.services/debug/injector"; //$NON-NLS-1$
-	final static private boolean shouldTrace = ServicesActivator.getDefault()
-			.getBooleanDebugOption(DEBUG_INJECTOR, false);
 	final static private String JAVA_OBJECT = "java.lang.Object"; //$NON-NLS-1$
-
+	// XXX remove
 	// plug-in class that gets replaced in Java 1.5+
-	final private static AnnotationsSupport annotationSupport = new AnnotationsSupport(); // XXX
-																							// remove;
+	final private static AnnotationsSupport annotationSupport = new AnnotationsSupport();
 
-	public InjectorImpl() {
-		// placeholder
+	// TBD thread safety
+	private Map<String, AbstractObjectSupplier> extendedSuppliers = new HashMap<String, AbstractObjectSupplier>();
+
+	private Map<AbstractObjectSupplier, List<WeakReference<?>>> injectedObjects = new HashMap<AbstractObjectSupplier, List<WeakReference<?>>>();
+	private HashMap<Class<?>, Object> singletonCache = new HashMap<Class<?>, Object>();
+	private Map<Class<?>, Set<IBinding>> bindings = new HashMap<Class<?>, Set<IBinding>>();
+
+	public boolean inject(Object object, AbstractObjectSupplier objectSupplier) {
+		// Two stages: first, go and collect {requestor, descriptor[] }
+		ArrayList<Requestor> requestors = new ArrayList<Requestor>();
+		processClassHierarchy(object, false /* no static */, true /* track */, true /* normal order */,
+				requestors);
+		// Ask suppliers to fill actual values {requestor, descriptor[], actualvalues[] }
+		if (!resolveRequestorArgs(requestors, objectSupplier, false))
+			return false;
+
+		// Call requestors in order
+		for (Requestor requestor : requestors) {
+			try {
+				if (requestor.isResolved())
+					requestor.execute();
+			} catch (InvocationTargetException e) {
+				logError("Injection failed for the object \"" + object.toString()
+						+ "\". Unable to execute \"" + requestor.toString() + "\"");
+				return false;
+			} catch (InstantiationException e) {
+				logError("Injection failed for the object \"" + object.toString()
+						+ "\". Unable to execute \"" + requestor.toString() + "\"");
+				return false;
+			}
+		}
+		rememberInjectedObject(object, objectSupplier);
+
+		// TBD current tests assume that @PostConstruct methods will be
+		// called after injection; however, name implies that it is only
+		// called when the object is constructed. Fix this after the 1.4/1.5 merge.
+		try {
+			processPostConstruct(object, object.getClass(), objectSupplier,
+					new ArrayList<Class<?>>(5));
+		} catch (InvocationTargetException e) {
+			logError("Injection failed for the object \"" + object.toString()
+					+ "\". Unable to process post-construct methods.", e);
+			return false;
+		} catch (InstantiationException e) {
+			logError("Injection failed for the object \"" + object.toString()
+					+ "\". Unable to process post-construct methods.", e);
+			return false;
+		}
+		return true;
 	}
 
-	public boolean inject(Object userObject, IObjectProvider objectProvider) {
-		boolean result = false;
-		try {
-			result = processClassHierarchy(userObject, false /* process static */, objectProvider);
-		} catch (InvocationTargetException e) {
-			logExternalError("Exception occured while processing injecting", userObject, e);
+	private void rememberInjectedObject(Object object, AbstractObjectSupplier objectSupplier) {
+		synchronized (injectedObjects) {
+			List<WeakReference<?>> list;
+			if (!injectedObjects.containsKey(objectSupplier)) {
+				list = new ArrayList<WeakReference<?>>();
+				injectedObjects.put(objectSupplier, list);
+			} else
+				list = injectedObjects.get(objectSupplier);
+			for (WeakReference<?> ref : list) {
+				if (object == ref.get())
+					return; // we already have it
+			}
+			list.add(new WeakReference<Object>(object));
 		}
-		objectProvider.runAndTrack(new InjectionClass(userObject, objectProvider), null);
+	}
+
+	private boolean forgetInjectedObject(Object object, AbstractObjectSupplier objectSupplier) {
+		synchronized (injectedObjects) {
+			if (!injectedObjects.containsKey(objectSupplier))
+				return false;
+			List<WeakReference<?>> list = injectedObjects.get(objectSupplier);
+			for (Iterator<WeakReference<?>> i = list.iterator(); i.hasNext();) {
+				WeakReference<?> ref = i.next();
+				if (object == ref.get())
+					i.remove();
+				return true;
+			}
+			return false;
+		}
+	}
+
+	private List<WeakReference<?>> forgetSupplier(AbstractObjectSupplier objectSupplier) {
+		synchronized (injectedObjects) {
+			if (!injectedObjects.containsKey(objectSupplier))
+				return null;
+			return injectedObjects.remove(objectSupplier);
+		}
+	}
+
+	private List<WeakReference<?>> getSupplierObjects(AbstractObjectSupplier objectSupplier) {
+		synchronized (injectedObjects) {
+			if (!injectedObjects.containsKey(objectSupplier))
+				return null;
+			return injectedObjects.get(objectSupplier);
+		}
+	}
+
+	public boolean uninject(Object object, AbstractObjectSupplier objectSupplier) {
+		if (!forgetInjectedObject(object, objectSupplier))
+			return false; // not injected at this time
+		// Two stages: first, go and collect {requestor, descriptor[] }
+		ArrayList<Requestor> requestors = new ArrayList<Requestor>();
+		processClassHierarchy(object, false /* no static */, true /* track */,
+				false /* inverse order */, requestors);
+		// might still need to get resolved values from secondary suppliers
+		// Ask suppliers to fill actual values {requestor, descriptor[], actualvalues[] }
+		if (!resolveRequestorArgs(requestors, null, true /* fill with nulls */))
+			return false;
+
+		// Call requestors in order
+		for (Requestor requestor : requestors) {
+			try {
+				requestor.execute();
+			} catch (InvocationTargetException e) {
+				logError("Uninjection failed for the object \"" + object.toString()
+						+ "\". Unable to execute \"" + requestor.toString() + "\"");
+				return false;
+			} catch (InstantiationException e) {
+				logError("Uninjection failed for the object \"" + object.toString()
+						+ "\". Unable to execute \"" + requestor.toString() + "\"");
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public Object invoke(Object object, String methodName, AbstractObjectSupplier objectSupplier)
+			throws InvocationTargetException, CoreException {
+		Object result = invokeUsingClass(object, object.getClass(), methodName,
+				IInjector.NOT_A_VALUE, objectSupplier);
+		if (result == IInjector.NOT_A_VALUE) {
+			IStatus status = new Status(IStatus.ERROR, "org.eclipse.e4.core.services",
+					"Unable to find matching method to invoke");
+			throw new CoreException(status);
+		}
 		return result;
 	}
 
-	// TBD use null object to inject statics
-	public boolean injectStatic(Class clazz, IObjectProvider objectProvider) {
+	public Object invoke(Object object, String methodName, Object defaultValue,
+			AbstractObjectSupplier objectSupplier) throws InvocationTargetException {
+		return invokeUsingClass(object, object.getClass(), methodName, defaultValue, objectSupplier);
+	}
+
+	private Object invokeUsingClass(Object userObject, Class<?> currentClass, String methodName,
+			Object defaultValue, AbstractObjectSupplier objectSupplier)
+			throws InvocationTargetException {
+		Method[] methods = currentClass.getDeclaredMethods();
+		for (int j = 0; j < methods.length; j++) {
+			Method method = methods[j];
+			if (!method.getName().equals(methodName))
+				continue;
+			MethodRequestor requestor = new MethodRequestor(method, userObject, false, false, true);
+
+			Object[] actualArgs = resolveArgs(requestor, objectSupplier, false);
+			int unresolved = unresolved(actualArgs);
+			if (unresolved != -1) {
+				logError("Injection failed for object \""
+						+ requestor.getRequestingObject().toString()
+						+ "\". Unable to find value for \""
+						+ requestor.getDependentObjects()[unresolved] + "\"");
+				return null;
+			}
+			requestor.setResolvedArgs(actualArgs);
+
+			try {
+				return requestor.execute();
+			} catch (InstantiationException e) {
+				// TBD clean up the error handling; need to propagate original exception
+				logError("Exception occured in the injected method " + method.getName(), e);
+				return null;
+			}
+		}
+		Class<?> superClass = currentClass.getSuperclass();
+		if (superClass == null) {
+			return defaultValue;
+		}
+		return invokeUsingClass(userObject, superClass, methodName, defaultValue, objectSupplier);
+	}
+
+	public Object make(Class<?> clazz, AbstractObjectSupplier objectSupplier)
+			throws InvocationTargetException, InstantiationException {
+		IObjectDescriptor descriptor = ObjectDescriptorFactory.make(clazz, false);
+		return make(descriptor, objectSupplier);
+	}
+
+	public Object make(IObjectDescriptor descriptor, AbstractObjectSupplier objectSupplier)
+			throws InvocationTargetException, InstantiationException {
+		IBinding binding = findBinding(descriptor);
+		if (binding == null) {
+			Class<?> desiredClass = descriptor.getElementClass();
+			return internalMake(desiredClass, objectSupplier);
+		}
+		return internalMake(binding.getImplementationClass(), objectSupplier);
+	}
+
+	private Object internalMake(Class<?> clazz, AbstractObjectSupplier objectSupplier)
+			throws InvocationTargetException, InstantiationException {
+
+		boolean isSingleton = clazz.isAnnotationPresent(Singleton.class);
+		if (isSingleton) {
+			synchronized (singletonCache) {
+				if (singletonCache.containsKey(clazz))
+					return singletonCache.get(clazz);
+			}
+		}
+
+		Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+		// Sort the constructors by descending number of constructor arguments
+		ArrayList<Constructor<?>> sortedConstructors = new ArrayList<Constructor<?>>(
+				constructors.length);
+		for (Constructor<?> constructor : constructors)
+			sortedConstructors.add(constructor);
+		Collections.sort(sortedConstructors, new Comparator<Constructor<?>>() {
+			public int compare(Constructor<?> c1, Constructor<?> c2) {
+				int l1 = c1.getParameterTypes().length;
+				int l2 = c2.getParameterTypes().length;
+				return l2 - l1;
+			}
+		});
+
+		for (Constructor<?> constructor : sortedConstructors) {
+			// skip private and protected constructors; allow public and package visibility
+			int modifiers = constructor.getModifiers();
+			if (((modifiers & Modifier.PRIVATE) != 0) || ((modifiers & Modifier.PROTECTED) != 0))
+				continue;
+
+			// unless this is the default constructor, it has to be tagged
+			InjectionProperties cProps = annotationSupport.getInjectProperties(constructor);
+			if (!cProps.shouldInject() && constructor.getParameterTypes().length != 0)
+				continue;
+
+			ConstructorRequestor requestor = new ConstructorRequestor(constructor);
+			Object[] actualArgs = resolveArgs(requestor, objectSupplier, false);
+			if (unresolved(actualArgs) != -1)
+				continue;
+			requestor.setResolvedArgs(actualArgs);
+
+			Object newInstance = requestor.execute();
+			if (newInstance != null) {
+				inject(newInstance, objectSupplier);
+				if (isSingleton) {
+					synchronized (singletonCache) { // TBD this is not quite right, synch the method
+						singletonCache.put(clazz, newInstance);
+					}
+				}
+				return newInstance;
+			}
+		}
+
+		logError("Could not find satisfiable constructor in class " + clazz.getName());
+		return null;
+	}
+
+	public boolean injectStatic(Class<?> clazz, AbstractObjectSupplier objectSupplier) {
+		// TBD add processing on a null object
+		Object object;
 		try {
-			Object object = make(clazz, objectProvider);
-			return processClassHierarchy(object, true /* process static */, objectProvider);
+			object = make(clazz, objectSupplier);
 		} catch (InvocationTargetException e) {
 			// try-catch won't be necessary once we stop creating an object
 			e.printStackTrace();
+			return false;
 		} catch (InstantiationException e) {
 			// try-catch won't be necessary once we stop creating an object
 			e.printStackTrace();
+			return false;
 		}
-		return false;
+
+		// TBD this is copy/paste from as invoke() with static = true.
+		// Two stages: first, go and collect {requestor, descriptor[] }
+		ArrayList<Requestor> requestors = new ArrayList<Requestor>();
+		processClassHierarchy(object, true /* static */, true /* track */, true /* normal order */,
+				requestors);
+		// Ask suppliers to fill actual values {requestor, descriptor[], actualvalues[] }
+		if (!resolveRequestorArgs(requestors, objectSupplier, false))
+			return false;
+
+		// Call requestors in order
+		for (Requestor requestor : requestors) {
+			try {
+				requestor.execute();
+			} catch (InvocationTargetException e) {
+				logError("Injection failed for the object \"" + object.toString()
+						+ "\". Unable to execute \"" + requestor.toString() + "\"");
+				return false;
+			} catch (InstantiationException e) {
+				logError("Injection failed for the object \"" + object.toString()
+						+ "\". Unable to execute \"" + requestor.toString() + "\"");
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	public boolean update(IRequestor[] requestors, AbstractObjectSupplier objectSupplier) {
+		ArrayList<Requestor> list = new ArrayList<Requestor>(requestors.length);
+		for (IRequestor requestor : requestors) {
+			list.add((Requestor) requestor);
+		}
+		resolveRequestorArgs(list, objectSupplier, true);
+
+		// Call requestors in order
+		for (IRequestor requestor : requestors) {
+			try {
+				((Requestor) requestor).execute();
+			} catch (InvocationTargetException e) {
+				logError("Injection failed for the object \""
+						+ requestor.getRequestingObject().toString() + "\". Unable to execute \""
+						+ requestor.toString() + "\"");
+				return false;
+			} catch (InstantiationException e) {
+				logError("Injection failed for the object \""
+						+ requestor.getRequestingObject().toString() + "\". Unable to execute \""
+						+ requestor.toString() + "\"");
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public boolean disposed(AbstractObjectSupplier objectSupplier) {
+		List<WeakReference<?>> references = getSupplierObjects(objectSupplier);
+		if (references == null)
+			return true;
+		Object[] objects = new Object[references.size()];
+		int count = 0;
+		for (WeakReference<?> ref : references) {
+			Object object = ref.get();
+			if (object != null) {
+				objects[count] = object;
+				count++;
+			}
+		}
+		for (int i = 0; i < count; i++) {
+			processPreDestory(objects[i], objects[i].getClass(), new ArrayList<Class<?>>(5));
+			uninject(objects[i], objectSupplier);
+		}
+		forgetSupplier(objectSupplier);
+		return true;
+	}
+
+	private void processPreDestory(Object userObject, Class<?> objectClass,
+			ArrayList<Class<?>> classHierarchy) {
+		Class<?> superClass = objectClass.getSuperclass();
+		if (superClass != null && !superClass.getName().equals(JAVA_OBJECT)) {
+			classHierarchy.add(objectClass);
+			processPreDestory(userObject, superClass, classHierarchy);
+			classHierarchy.remove(objectClass);
+		}
+		Method[] methods = objectClass.getDeclaredMethods();
+		for (int i = 0; i < methods.length; i++) {
+			Method method = methods[i];
+			if (method.getParameterTypes().length > 0) // TBD why?
+				continue;
+			if (!annotationSupport.isPreDestory(method))
+				continue;
+			if (!isOverridden(method, classHierarchy)) {
+				// TBD optional @PreDestory? might make sense if we allow args on those methods
+				MethodRequestor requestor = new MethodRequestor(method, userObject, false, false,
+						false);
+				try {
+					requestor.execute();
+				} catch (InvocationTargetException e) {
+					logError("Unable to call pre-destory method \"" + method.getName() + "\"", e);
+				} catch (InstantiationException e) {
+					logError("Unable to call pre-destory method \"" + method.getName() + "\"", e);
+				}
+			}
+		}
+		if (userObject instanceof IDisposable)
+			((IDisposable) userObject).dispose();
+	}
+
+	private boolean resolveRequestorArgs(ArrayList<Requestor> requestors,
+			AbstractObjectSupplier objectSupplier, boolean fillNulls) {
+		for (Requestor requestor : requestors) {
+			Object[] actualArgs = resolveArgs(requestor, objectSupplier, fillNulls);
+			int unresolved = unresolved(actualArgs);
+			if (unresolved == -1) {
+				requestor.setResolvedArgs(actualArgs);
+				continue;
+			}
+
+			if (requestor.isOptional())
+				requestor.setResolvedArgs(null);
+			else {
+				logError("Injection failed for object \""
+						+ requestor.getRequestingObject().toString()
+						+ "\". Unable to find value for \""
+						+ requestor.getDependentObjects()[unresolved] + "\"");
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private Object[] resolveArgs(Requestor requestor, AbstractObjectSupplier objectSupplier,
+			boolean fillNulls) {
+		IObjectDescriptor[] descriptors = requestor.getDependentObjects();
+
+		// 0) initial fill - all are unresolved
+		Object[] actualArgs = new Object[descriptors.length];
+		for (int i = 0; i < actualArgs.length; i++) {
+			actualArgs[i] = NOT_A_VALUE;
+		}
+
+		// 1) check if we have a Provider<T>
+		for (int i = 0; i < actualArgs.length; i++) {
+			Class<?> providerClass = getProviderType(descriptors[i].getElementType());
+			if (providerClass == null)
+				continue;
+			actualArgs[i] = new ProviderImpl<Class<?>>(descriptors[i], this, objectSupplier);
+			descriptors[i] = null; // mark as used
+		}
+
+		// 2) use the primary supplier
+		if (objectSupplier != null) {
+			Object[] primarySupplierArgs = objectSupplier.get(descriptors, requestor);
+			for (int i = 0; i < actualArgs.length; i++) {
+				if (descriptors[i] == null)
+					continue; // already resolved
+				if (primarySupplierArgs[i] != NOT_A_VALUE) {
+					actualArgs[i] = primarySupplierArgs[i];
+					descriptors[i] = null; // mark as used
+				}
+			}
+		}
+
+		// 3) try extended suppliers
+		for (int i = 0; i < actualArgs.length; i++) {
+			if (descriptors[i] == null)
+				continue; // already resolved
+			AbstractObjectSupplier extendedSupplier = findExtendedSupplier(descriptors[i]);
+			if (extendedSupplier == null)
+				continue;
+			Object result = extendedSupplier.get(descriptors[i], requestor);
+			if (result != NOT_A_VALUE) {
+				actualArgs[i] = result;
+				descriptors[i] = null; // mark as used
+			}
+		}
+
+		// 4) try the bindings
+		for (int i = 0; i < actualArgs.length; i++) {
+			if (descriptors[i] == null)
+				continue; // already resolved
+			IBinding binding = findBinding(descriptors[i]);
+			if (binding != null) {
+				try {
+					actualArgs[i] = internalMake(binding.getImplementationClass(), objectSupplier);
+				} catch (InvocationTargetException e) {
+					logError("Unable to create object for class \""
+							+ binding.getImplementationClass() + "\".", e);
+					continue;
+				} catch (InstantiationException e) {
+					logError("Unable to create object for class \""
+							+ binding.getImplementationClass() + "\".", e);
+					continue;
+				}
+			}
+		}
+
+		// 5) post process
+		descriptors = requestor.getDependentObjects(); // reset nulled out values
+		for (int i = 0; i < descriptors.length; i++) {
+			// check that values are of a correct type
+			if (actualArgs[i] != null && actualArgs[i] != IInjector.NOT_A_VALUE) {
+				Class<?> descriptorsClass = descriptors[i].getElementClass();
+				if (!descriptorsClass.isAssignableFrom(actualArgs[i].getClass()))
+					actualArgs[i] = IInjector.NOT_A_VALUE;
+			}
+			// replace optional unresolved values with null
+			if (descriptors[i].isOptional() && actualArgs[i] == IInjector.NOT_A_VALUE)
+				actualArgs[i] = null;
+			else if (fillNulls && actualArgs[i] == IInjector.NOT_A_VALUE)
+				actualArgs[i] = null;
+		}
+
+		return actualArgs;
+	}
+
+	private AbstractObjectSupplier findExtendedSupplier(IObjectDescriptor descriptor) {
+		String[] qualifiers = descriptor.getQualifiers();
+		if (qualifiers == null)
+			return null;
+		for (String qualifier : qualifiers) {
+			if (extendedSuppliers.containsKey(qualifier))
+				return extendedSuppliers.get(qualifier);
+		}
+		return null;
+	}
+
+	private int unresolved(Object[] actualArgs) {
+		for (int i = 0; i < actualArgs.length; i++) {
+			if (actualArgs[i] == IInjector.NOT_A_VALUE)
+				return i;
+		}
+		return -1;
+	}
+
+	private void processClassHierarchy(Object userObject, boolean processStatic, boolean track,
+			boolean normalOrder, List<Requestor> requestors) {
+		processClass(userObject, (userObject == null) ? null : userObject.getClass(),
+				new ArrayList<Class<?>>(5), processStatic, track, normalOrder, requestors);
 	}
 
 	/**
 	 * Make the processor visit all declared members on the given class and all superclasses
-	 * 
-	 * @throws InvocationTargetException
 	 */
-	private boolean processClass(Object userObject, Class objectsClass, ArrayList classHierarchy,
-			boolean processStatic, IObjectProvider objectProvider) throws InvocationTargetException {
+	private void processClass(Object userObject, Class<?> objectsClass,
+			ArrayList<Class<?>> classHierarchy, boolean processStatic, boolean track,
+			boolean normalOrder, List<Requestor> requestors) {
 		// order: superclass, fields, methods
 		if (objectsClass != null) {
-			Class superClass = objectsClass.getSuperclass();
+			Class<?> superClass = objectsClass.getSuperclass();
 			if (!superClass.getName().equals(JAVA_OBJECT)) {
 				classHierarchy.add(objectsClass);
-				if (!processClass(userObject, superClass, classHierarchy, processStatic,
-						objectProvider))
-					return false;
+				processClass(userObject, superClass, classHierarchy, processStatic, track,
+						normalOrder, requestors);
 				classHierarchy.remove(objectsClass);
 			}
 		}
-		if (!processFields(userObject, objectsClass, processStatic, objectProvider))
-			return false;
-		if (!processMethods(userObject, objectsClass, classHierarchy, processStatic, objectProvider))
-			return false;
-		return true;
-	}
-
-	private boolean processClassHierarchy(Object userObject, boolean processStatic,
-			IObjectProvider objectProvider) throws InvocationTargetException {
-		if (!processClass(userObject, (userObject == null) ? null : userObject.getClass(),
-				new ArrayList(5), processStatic, objectProvider))
-			return false;
-		return true;
+		if (normalOrder) {
+			processFields(userObject, objectsClass, processStatic, track, requestors);
+			processMethods(userObject, objectsClass, classHierarchy, processStatic, track,
+					requestors);
+		} else {
+			processMethods(userObject, objectsClass, classHierarchy, processStatic, track,
+					requestors);
+			processFields(userObject, objectsClass, processStatic, track, requestors);
+		}
 	}
 
 	/**
 	 * Make the processor visit all declared fields on the given class.
 	 */
-	private boolean processFields(Object userObject, Class objectsClass, boolean processStatic,
-			IObjectProvider objectProvider) {
+	private void processFields(Object userObject, Class<?> objectsClass, boolean processStatic,
+			boolean track, List<Requestor> requestors) {
 		Field[] fields = objectsClass.getDeclaredFields();
 		for (int i = 0; i < fields.length; i++) {
 			Field field = fields[i];
 			if (Modifier.isStatic(field.getModifiers()) != processStatic)
 				continue;
-			InjectionProperties properties = annotationSupport.getInjectProperties(field,
-					objectProvider);
+
+			// XXX limit to "should inject"
+			InjectionProperties properties = annotationSupport.getInjectProperties(field);
+			// XXX this will be removed on 1.4/1.5 merge
 			if (field.getName().startsWith(IContextConstants.INJECTION_PREFIX))
 				properties.setInject(true);
-
 			if (!properties.shouldInject())
 				continue;
-			objectProvider.runAndTrack(new InjectionField(userObject, objectProvider, field,
-					properties.groupUpdates()), null);
+
+			requestors.add(new FieldRequestor(field, userObject, track, properties.groupUpdates(),
+					properties.isOptional()));
 		}
-		return true;
 	}
 
 	/**
@@ -137,9 +619,9 @@
 	 * 
 	 * @throws InvocationTargetException
 	 */
-	private boolean processMethods(final Object userObject, Class objectsClass,
-			ArrayList classHierarchy, boolean processStatic, IObjectProvider objectProvider)
-			throws InvocationTargetException {
+	private void processMethods(final Object userObject, Class<?> objectsClass,
+			ArrayList<Class<?>> classHierarchy, boolean processStatic, boolean track,
+			List<Requestor> requestors) {
 		Method[] methods = objectsClass.getDeclaredMethods();
 		for (int i = 0; i < methods.length; i++) {
 			final Method method = methods[i];
@@ -147,50 +629,49 @@
 				continue; // process in the subclass
 			if (Modifier.isStatic(method.getModifiers()) != processStatic)
 				continue;
-			InjectionProperties properties = annotationSupport.getInjectProperties(method,
-					objectProvider);
+
+			InjectionProperties properties = annotationSupport.getInjectProperties(method);
 			if (method.getName().startsWith(IContextConstants.INJECTION_PREFIX))
 				properties.setInject(true);
 
-			if (properties.getHandlesEvent() != null) {
-				// XXX this is wrong, but it will be removed anyway
-				ObjectDescriptor desc = ObjectDescriptor.make(IEventBroker.class);
-				IEventBroker eventBroker = (IEventBroker) objectProvider.get(desc);
-				eventBroker.subscribe(properties.getHandlesEvent(), null, new EventHandler() {
-					public void handleEvent(Event event) {
-						Object data = event.getProperty(IEventBroker.DATA);
-						boolean wasAccessible = method.isAccessible();
-						if (!wasAccessible) {
-							method.setAccessible(true);
-						}
-						try {
-							method.invoke(userObject, data);
-						} catch (Exception e) {
-							throw new RuntimeException(e);
-						} finally {
-							if (!wasAccessible) {
-								method.setAccessible(false);
-							}
-						}
-					}
-				}, properties.getEventHeadless());
-				continue;
-			}
+			// replace with @Event("name") qualifier
+			// if (properties.getHandlesEvent() != null) {
+			// // XXX this is wrong, but it will be removed anyway
+			// ObjectDescriptor desc = ObjectDescriptor.make(IEventBroker.class);
+			// IEventBroker eventBroker = (IEventBroker) objectProvider.get(desc);
+			// eventBroker.subscribe(properties.getHandlesEvent(), null, new EventHandler() {
+			// public void handleEvent(Event event) {
+			// Object data = event.getProperty(IEventBroker.DATA);
+			// boolean wasAccessible = method.isAccessible();
+			// if (!wasAccessible) {
+			// method.setAccessible(true);
+			// }
+			// try {
+			// method.invoke(userObject, data);
+			// } catch (Exception e) {
+			// throw new RuntimeException(e);
+			// } finally {
+			// if (!wasAccessible) {
+			// method.setAccessible(false);
+			// }
+			// }
+			// }
+			// }, properties.getEventHeadless());
+			// continue;
+			// }
 
 			if (!properties.shouldInject())
 				continue;
 
-			objectProvider.runAndTrack(new InjectionMethod(userObject, objectProvider, method,
-					properties.groupUpdates()), null);
+			requestors.add(new MethodRequestor(method, userObject, track,
+					properties.groupUpdates(), properties.isOptional()));
 		}
-		return true;
 	}
 
-	// TBD this is the same method as in the class injector
 	/**
 	 * Checks if a given method is overridden with an injectable method.
 	 */
-	private boolean isOverridden(Method method, ArrayList classHierarchy) {
+	private boolean isOverridden(Method method, ArrayList<Class<?>> classHierarchy) {
 		int modifiers = method.getModifiers();
 		if (Modifier.isPrivate(modifiers))
 			return false;
@@ -199,141 +680,175 @@
 		// method is not private if we reached this line, check not(public OR protected)
 		boolean isDefault = !(Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers));
 
-		for (Iterator i = classHierarchy.iterator(); i.hasNext();) {
-			Class subClass = (Class) i.next();
-			Method override = null;
+		for (Class<?> subClass : classHierarchy) {
 			try {
-				override = subClass.getDeclaredMethod(method.getName(), method.getParameterTypes());
+				subClass.getDeclaredMethod(method.getName(), method.getParameterTypes());
 			} catch (SecurityException e) {
 				continue;
 			} catch (NoSuchMethodException e) {
 				continue; // this is the desired outcome
 			}
-			if (override != null) {
-				if (isDefault) { // must be in the same package to override
-					Package originalPackage = method.getDeclaringClass().getPackage();
-					Package overridePackage = subClass.getPackage();
+			if (isDefault) { // must be in the same package to override
+				Package originalPackage = method.getDeclaringClass().getPackage();
+				Package overridePackage = subClass.getPackage();
 
-					if (originalPackage == null && overridePackage == null)
-						return true;
-					if (originalPackage == null || overridePackage == null)
-						return false;
-					if (originalPackage.equals(overridePackage))
-						return true;
-				} else
+				if (originalPackage == null && overridePackage == null)
 					return true;
-			}
+				if (originalPackage == null || overridePackage == null)
+					return false;
+				if (originalPackage.equals(overridePackage))
+					return true;
+			} else
+				return true;
 		}
 		return false;
 	}
 
-	public Object invoke(Object userObject, String methodName, IObjectProvider objectProvider)
-			throws InvocationTargetException, CoreException {
-		Method[] methods = userObject.getClass().getDeclaredMethods();
-		for (int j = 0; j < methods.length; j++) {
-			Method method = methods[j];
-			if (!method.getName().equals(methodName))
-				continue;
-
-			InjectionMethod injectMethod = new InjectionMethod(userObject, objectProvider, method,
-					false);
-			try {
-				return injectMethod.invoke(false, false);
-			} catch (InjectionException e) {
-				IStatus status = new Status(IStatus.ERROR, "org.eclipse.e4.core.services",
-						"Unable to invoke method");
-				throw new CoreException(status);
-			}
-		}
-		IStatus status = new Status(IStatus.ERROR, "org.eclipse.e4.core.services",
-				"Unable to find matching method to invoke");
-		throw new CoreException(status);
-	}
-
-	public Object invoke(Object userObject, String methodName, Object defaultValue,
-			IObjectProvider objectProvider) throws InvocationTargetException {
-		return invokeUsingClass(userObject, userObject.getClass(), methodName, defaultValue,
-				objectProvider);
-	}
-
-	public Object invokeUsingClass(Object userObject, Class currentClass, String methodName,
-			Object defaultValue, IObjectProvider objectProvider) throws InvocationTargetException {
-		Method[] methods = currentClass.getDeclaredMethods();
-		for (int j = 0; j < methods.length; j++) {
-			Method method = methods[j];
-			if (!method.getName().equals(methodName))
-				continue;
-
-			InjectionMethod injectMethod = new InjectionMethod(userObject, objectProvider, method,
-					false);
-			try {
-				return injectMethod.invoke(false, false);
-			} catch (InjectionException e) {
-				// TBD? abort or continue?
-				logExternalError("Exception occured in the injectd method " + method.getName(),
-						userObject, e);
-			}
-		}
-		Class superClass = currentClass.getSuperclass();
-		if (superClass == null) {
-			return defaultValue;
-		}
-		return invokeUsingClass(userObject, superClass, methodName, defaultValue, objectProvider);
-	}
-
-	public Object make(Class clazz, IObjectProvider objectProvider)
+	private void processPostConstruct(Object userObject, Class<?> objectClass,
+			AbstractObjectSupplier objectSupplier, ArrayList<Class<?>> classHierarchy)
 			throws InvocationTargetException, InstantiationException {
-		Constructor[] constructors = clazz.getDeclaredConstructors();
+		Class<?> superClass = objectClass.getSuperclass();
+		if (superClass != null && !superClass.getName().equals(JAVA_OBJECT)) {
+			classHierarchy.add(objectClass);
+			processPostConstruct(userObject, superClass, objectSupplier, classHierarchy);
+			classHierarchy.remove(objectClass);
+		}
+		Method[] methods = objectClass.getDeclaredMethods();
+		for (int i = 0; i < methods.length; i++) {
+			Method method = methods[i];
+			if (!isPostConstruct(method))
+				continue;
+			if (isOverridden(method, classHierarchy))
+				continue;
 
-		// Sort the constructors by descending number of constructor arguments
-		ArrayList sortedConstructors = new ArrayList(constructors.length);
-		for (int i = 0; i < constructors.length; i++)
-			sortedConstructors.add(constructors[i]);
-		Collections.sort(sortedConstructors, new Comparator() {
-			public int compare(Object c1, Object c2) {
-				int l1 = ((Constructor) c1).getParameterTypes().length;
-				int l2 = ((Constructor) c2).getParameterTypes().length;
-				return l2 - l1;
+			MethodRequestor requestor = new MethodRequestor(method, userObject, false, false, false);
+			Object[] actualArgs = resolveArgs(requestor, objectSupplier, false);
+			int unresolved = unresolved(actualArgs);
+			if (unresolved != -1) {
+				logError("Injection failed for object \""
+						+ requestor.getRequestingObject().toString()
+						+ "\". Unable to find value for \""
+						+ requestor.getDependentObjects()[unresolved] + "\"");
+				continue;
 			}
-		});
+			requestor.setResolvedArgs(actualArgs);
 
-		for (Iterator i = sortedConstructors.iterator(); i.hasNext();) {
-			Constructor constructor = (Constructor) i.next();
-
-			// skip private and protected constructors; allow public and package visibility
-			if (((constructor.getModifiers() & Modifier.PRIVATE) != 0)
-					|| ((constructor.getModifiers() & Modifier.PROTECTED) != 0))
-				continue;
-
-			// unless this is the default constructor, it has to be tagged
-			InjectionProperties cProps = annotationSupport.getInjectProperties(constructor,
-					objectProvider);
-			if (!cProps.shouldInject() && constructor.getParameterTypes().length != 0)
-				continue;
-
-			InjectionConstructor injectedConstructor = new InjectionConstructor(null,
-					objectProvider, constructor);
-			Object newInstance = injectedConstructor.make();
-			if (newInstance != null) {
-				inject(newInstance, objectProvider);
-				return newInstance;
+			try {
+				requestor.execute();
+			} catch (InvocationTargetException e) {
+				logError("Unable to call post-construct method \"" + method.getName() + "\"", e);
+			} catch (InstantiationException e) {
+				logError("Unable to call post-construct method \"" + method.getName() + "\"", e);
 			}
 		}
+	}
 
-		if (shouldTrace)
-			System.out
-					.println("Could not find satisfiable constructor in class " + clazz.getName());
+	// TBD simplify this: only one non-annotation and one "implements IInitializable"?
+	/**
+	 * Returns whether the given method is a post-construction process method, as defined by the
+	 * class comment of {@link ContextInjectionFactory}.
+	 */
+	private boolean isPostConstruct(Method method) {
+		boolean isPostConstruct = annotationSupport.isPostConstruct(method);
+		if (isPostConstruct)
+			return true;
+		if (!method.getName().equals(IContextConstants.INJECTION_SET_CONTEXT_METHOD))
+			return false;
+		Class<?>[] parms = method.getParameterTypes();
+		if (parms.length == 0)
+			return true;
+		if (parms.length == 1 && parms[0].equals(IEclipseContext.class))
+			return true;
+		return false;
+	}
+
+	/**
+	 * Returns null if not a provider
+	 */
+	private Class<?> getProviderType(Type type) {
+		if (!(type instanceof ParameterizedType))
+			return null;
+		Type rawType = ((ParameterizedType) type).getRawType();
+		if (!(rawType instanceof Class<?>))
+			return null;
+		boolean isProvider = ((Class<?>) rawType).equals(Provider.class);
+		if (!isProvider)
+			return null;
+		Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments();
+		if (actualTypes.length != 1)
+			return null;
+		if (!(actualTypes[0] instanceof Class<?>))
+			return null;
+		return (Class<?>) actualTypes[0];
+	}
+
+	public IBinding addBinding(Class<?> clazz) {
+		return addBinding(new Binding(clazz, this));
+	}
+
+	public IBinding addBinding(IBinding binding) {
+		Class<?> clazz = binding.getDescribedClass();
+		synchronized (bindings) {
+			if (bindings.containsKey(clazz)) {
+				Set<IBinding> collection = bindings.get(clazz);
+				String desiredQualifierName = binding.getQualifierName();
+				for (Iterator<IBinding> i = collection.iterator(); i.hasNext();) {
+					IBinding collectionBinding = i.next();
+					if (eq(collectionBinding.getQualifierName(), desiredQualifierName)) {
+						i.remove();
+						break;
+					}
+				}
+				collection.add(binding);
+			} else {
+				Set<IBinding> collection = new HashSet<IBinding>(1);
+				collection.add(binding);
+				bindings.put(clazz, collection);
+			}
+		}
+		return binding;
+	}
+
+	private IBinding findBinding(IObjectDescriptor descriptor) {
+		Class<?> desiredClass = getProviderType(descriptor.getElementType());
+		if (desiredClass == null)
+			desiredClass = descriptor.getElementClass();
+		synchronized (bindings) {
+			if (!bindings.containsKey(desiredClass))
+				return null;
+			Set<IBinding> collection = bindings.get(desiredClass);
+			String desiredQualifierName = descriptor.getQualifierValue(Named.class.getName());
+
+			for (Iterator<IBinding> i = collection.iterator(); i.hasNext();) {
+				IBinding collectionBinding = i.next();
+				if (eq(collectionBinding.getQualifierName(), desiredQualifierName))
+					return collectionBinding;
+			}
+		}
 		return null;
 	}
 
-	private void logExternalError(String msg, Object destination, Exception e) {
-		System.out.println(msg + " " + destination.toString()); //$NON-NLS-1$
+	/**
+	 * Are two, possibly null, string equal?
+	 */
+	private boolean eq(String str1, String str2) {
+		if (str1 == null && str2 == null)
+			return true;
+		if (str1 == null || str2 == null)
+			return false;
+		return str1.equals(str2);
+	}
+
+	// TBD implement logging
+	private void logError(String msg) {
+		logError(msg, new InjectionException());
+	}
+
+	private void logError(String msg, Throwable e) {
+		if (msg != null)
+			System.err.println(msg);
 		if (e != null)
 			e.printStackTrace();
-		// TBD convert this into real logging
-		// String msg = NLS.bind("Injection failed", destination.toString());
-		// RuntimeLog.log(new Status(IStatus.WARNING,
-		// IRuntimeConstants.PI_COMMON, 0, msg, e));
 	}
 
 }
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/MethodRequestor.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/MethodRequestor.java
new file mode 100644
index 0000000..574dcad
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/MethodRequestor.java
@@ -0,0 +1,73 @@
+/*******************************************************************************
+ * Copyright (c) 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.internal.context;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import org.eclipse.e4.core.services.injector.IObjectDescriptor;
+import org.eclipse.e4.core.services.injector.ObjectDescriptorFactory;
+
+public class MethodRequestor extends Requestor {
+
+	final private Method method;
+
+	public MethodRequestor(Method method, Object requestingObject, boolean track,
+			boolean groupUpdates, boolean optional) {
+		super(requestingObject, track, groupUpdates, optional);
+		this.method = method;
+	}
+
+	public Object execute() throws InvocationTargetException, InstantiationException {
+		return callMethod(method, actualArgs);
+	}
+
+	@Override
+	public IObjectDescriptor[] getDependentObjects() {
+		Type[] parameterTypes = method.getGenericParameterTypes();
+		// TBD make getInjectParamProperties produce ObjectDescriptors
+		InjectionProperties[] properties = annotationSupport.getInjectParamProperties(method);
+		IObjectDescriptor[] descriptors = new IObjectDescriptor[properties.length];
+		for (int i = 0; i < properties.length; i++) {
+			descriptors[i] = ObjectDescriptorFactory.make(parameterTypes[i], properties[i]
+					.getPropertyName(), properties[i].isOptional());
+		}
+		return descriptors;
+	}
+
+	private Object callMethod(Method method, Object[] args) throws InvocationTargetException {
+		Object userObject = getRequestingObject();
+		if (userObject == null)
+			return null;
+		Object result = null;
+		boolean wasAccessible = true;
+		if (!method.isAccessible()) {
+			method.setAccessible(true);
+			wasAccessible = false;
+		}
+		try {
+			result = method.invoke(userObject, args);
+		} catch (IllegalArgumentException e) {
+			// should not happen, is checked during formation of the array of actual arguments
+			logError(method, e);
+			return null;
+		} catch (IllegalAccessException e) {
+			// should not happen, is checked at the start of this method
+			logError(method, e);
+			return null;
+		} finally {
+			if (!wasAccessible)
+				method.setAccessible(false);
+		}
+		return result;
+	}
+
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/ObjectDescriptor.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ObjectDescriptor.java
similarity index 62%
rename from bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/ObjectDescriptor.java
rename to bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ObjectDescriptor.java
index ae2be2b..4041a55 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/injector/ObjectDescriptor.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ObjectDescriptor.java
@@ -8,45 +8,50 @@
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
-package org.eclipse.e4.core.services.injector;
+package org.eclipse.e4.core.services.internal.context;
 
-import javax.inject.Named;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import org.eclipse.e4.core.services.injector.IObjectDescriptor;
 
 /**
  * NOTE: This is a preliminary form; this API will change.
  * 
  * @noextend This class is not intended to be subclassed by clients.
  */
-public class ObjectDescriptor {
+public class ObjectDescriptor implements IObjectDescriptor {
 
-	final private Class desiredClass;
+	final private Type desiredType;
 	final private String[] qualifiers;
 	final private String[] values;
 
-	static final private String named = Named.class.getName();
+	// TBD make "Optional" a qualifier?
+	final private boolean optional;
 
-	static public ObjectDescriptor make(Class clazz) {
-		return new ObjectDescriptor(clazz, null, null);
-	}
-
-	static public ObjectDescriptor make(String name) {
-		return new ObjectDescriptor(null, new String[] { named }, new String[] { name });
-	}
-
-	static public ObjectDescriptor make(Class clazz, String name) {
-		if (name == null)
-			return make(clazz);
-		return new ObjectDescriptor(clazz, new String[] { named }, new String[] { name });
-	}
-
-	public ObjectDescriptor(Class desiredClass, String[] qualifiers, String[] values) {
-		this.desiredClass = desiredClass;
+	public ObjectDescriptor(Type desiredType, String[] qualifiers, String[] values, boolean optional) {
+		this.desiredType = desiredType;
 		this.qualifiers = qualifiers;
 		this.values = values;
+		this.optional = optional;
 	}
 
-	public Class getElementClass() {
-		return desiredClass;
+	// TBD rename getDesiredClass()
+	public Class<?> getElementClass() {
+		if (desiredType instanceof Class<?>)
+			return (Class<?>) desiredType;
+		if (desiredType instanceof ParameterizedType)
+			return (Class<?>) ((ParameterizedType) desiredType).getRawType(); // XXX this is wrong;
+																				// might be
+																				// Param<T<T2>>
+		return null;
+	}
+
+	public Type getElementType() {
+		return desiredType;
+	}
+
+	public boolean isOptional() {
+		return optional;
 	}
 
 	public boolean hasQualifier(String qualifier) {
@@ -61,6 +66,10 @@
 		return false;
 	}
 
+	public String[] getQualifiers() {
+		return qualifiers;
+	}
+
 	/**
 	 * Returns null if qualifier is not present
 	 * 
@@ -81,8 +90,8 @@
 
 	public String toString() {
 		StringBuffer buffer = new StringBuffer();
-		if (desiredClass != null)
-			buffer.append(desiredClass.getName());
+		if (desiredType != null)
+			buffer.append(((Class<?>) desiredType).getName());
 		else
 			buffer.append("_descriptor_");
 		if (qualifiers != null) {
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ObjectProviderContext.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ObjectProviderContext.java
deleted file mode 100644
index f8cf2cb..0000000
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ObjectProviderContext.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009, 2010 IBM Corporation and others.
- * 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:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.e4.core.services.internal.context;
-
-import javax.inject.Named;
-import org.eclipse.e4.core.services.context.IEclipseContext;
-import org.eclipse.e4.core.services.context.IRunAndTrack;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
-import org.eclipse.e4.core.services.injector.ObjectDescriptor;
-
-public class ObjectProviderContext implements IObjectProvider {
-
-	final static private String ECLIPSE_CONTEXT_NAME = IEclipseContext.class.getName();
-
-	final private IEclipseContext context;
-
-	public ObjectProviderContext(IEclipseContext context) {
-		this.context = context;
-	}
-
-	public boolean containsKey(ObjectDescriptor properties) {
-		String key = getKey(properties);
-		if (key == null)
-			return false;
-		if (ECLIPSE_CONTEXT_NAME.equals(key))
-			return (context != null);
-		return context.containsKey(key);
-	}
-
-	public Object get(ObjectDescriptor properties) {
-		String key = getKey(properties);
-		if (key == null)
-			return null;
-		if (ECLIPSE_CONTEXT_NAME.equals(key))
-			return context;
-		return context.get(key);
-	}
-
-	private String getKey(ObjectDescriptor descriptor) {
-		if (descriptor.hasQualifier(Named.class.getName()))
-			return descriptor.getQualifierValue(Named.class.getName());
-		Class elementClass = descriptor.getElementClass();
-		if (elementClass != null)
-			return elementClass.getName();
-		return null;
-	}
-
-	public String toString() {
-		return "ContextToInjectorLink(" + context + ')'; //$NON-NLS-1$
-	}
-
-	public IEclipseContext getContext() {
-		return context;
-	}
-
-	static public ObjectProviderContext getObjectProvider(IEclipseContext context) {
-		String key = ObjectProviderContext.class.getName();
-		if (context.containsKey(key, true))
-			return (ObjectProviderContext) context.get(key);
-		ObjectProviderContext objectProvider = new ObjectProviderContext(context);
-		context.set(key, objectProvider);
-		return objectProvider;
-	}
-
-	public void runAndTrack(final IRunAndTrack runnable, Object[] args) {
-		context.runAndTrack(runnable, args);
-	}
-
-	// TBD remove?
-	public boolean equals(Object obj) {
-		if (obj == this)
-			return true;
-		if (!(obj instanceof ObjectProviderContext))
-			return false;
-		return context.equals(((ObjectProviderContext) obj).context);
-	}
-
-	// TBD remove?
-	public int hashCode() {
-		return context.hashCode();
-	}
-
-}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ProviderImpl.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ProviderImpl.java
new file mode 100644
index 0000000..61dd4e4
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ProviderImpl.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.internal.context;
+
+import java.lang.reflect.InvocationTargetException;
+import javax.inject.Provider;
+import org.eclipse.e4.core.services.injector.AbstractObjectSupplier;
+import org.eclipse.e4.core.services.injector.IInjector;
+import org.eclipse.e4.core.services.injector.IObjectDescriptor;
+
+public class ProviderImpl<T> implements Provider<T> {
+
+	final private AbstractObjectSupplier objectProvider;
+	final private IObjectDescriptor objectDescriptor;
+	final private IInjector injector;
+
+	public ProviderImpl(IObjectDescriptor descriptor, IInjector injector,
+			AbstractObjectSupplier provider) {
+		objectDescriptor = descriptor;
+		objectProvider = provider;
+		this.injector = injector;
+	}
+
+	@SuppressWarnings("unchecked")
+	public T get() {
+		try {
+			return (T) injector.make(objectDescriptor, objectProvider);
+		} catch (ClassCastException e) {
+			return null;
+		} catch (InvocationTargetException e) {
+			// TBD add proper logging
+			e.printStackTrace();
+			return null;
+		} catch (InstantiationException e) {
+			// TBD add proper logging
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/Requestor.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/Requestor.java
new file mode 100644
index 0000000..bb5e53a
--- /dev/null
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/Requestor.java
@@ -0,0 +1,99 @@
+/*******************************************************************************
+ * Copyright (c) 2010 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.e4.core.services.internal.context;
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.InvocationTargetException;
+import org.eclipse.e4.core.services.injector.IObjectDescriptor;
+import org.eclipse.e4.core.services.injector.IRequestor;
+import org.eclipse.e4.core.services.internal.annotations.AnnotationsSupport;
+
+/**
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+abstract public class Requestor implements IRequestor {
+
+	final private WeakReference<Object> objectRef;
+	final private boolean track;
+	final private boolean groupUpdates;
+	final private boolean isOptional;
+
+	protected Object[] actualArgs;
+
+	// plug-in class that gets replaced in Java 1.5+
+	// TBD this will be merged-in; replace with an utility class
+	final protected AnnotationsSupport annotationSupport = new AnnotationsSupport();
+
+	public abstract IObjectDescriptor[] getDependentObjects();
+
+	public abstract Object execute() throws InvocationTargetException, InstantiationException;
+
+	public Requestor(Object requestingObject, boolean track, boolean groupUpdates,
+			boolean isOptional) {
+		if (requestingObject != null)
+			objectRef = new WeakReference<Object>(requestingObject);
+		else
+			objectRef = null;
+		this.track = track;
+		this.groupUpdates = groupUpdates;
+		this.isOptional = isOptional;
+	}
+
+	public Object getRequestingObject() {
+		if (objectRef == null)
+			return null;
+		return objectRef.get();
+	}
+
+	/**
+	 * Determines if the requestor wants to be called whenever one of the dependent object changes.
+	 * 
+	 * @return
+	 */
+	public boolean shouldTrack() {
+		return track;
+	}
+
+	public boolean shouldGroupUpdates() {
+		return groupUpdates;
+	}
+
+	public boolean isOptional() {
+		return isOptional;
+	}
+
+	/**
+	 * If actual arguments are resolved for this requestor
+	 */
+	public boolean isResolved() {
+		return (actualArgs != null);
+	}
+
+	public void setResolvedArgs(Object[] actualArgs) {
+		this.actualArgs = actualArgs;
+	}
+
+	protected void logError(Object destination, Exception e) {
+		String msg = "Injection failed " + destination.toString();
+		logError(msg, e);
+	}
+
+	protected void logError(String msg, Exception e) {
+		System.out.println(msg); //$NON-NLS-1$
+		if (e != null)
+			e.printStackTrace();
+		// TBD convert this into real logging
+		// String msg = NLS.bind("Injection failed", destination.toString());
+		// RuntimeLog.log(new Status(IStatus.WARNING,
+		// IRuntimeConstants.PI_COMMON, 0, msg, e));
+	}
+
+}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ValueComputation.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ValueComputation.java
index c193a08..1e09cf3 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ValueComputation.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/core/services/internal/context/ValueComputation.java
@@ -14,7 +14,6 @@
 import org.eclipse.e4.core.services.context.ContextChangeEvent;
 import org.eclipse.e4.core.services.context.IContextFunction;
 import org.eclipse.e4.core.services.context.IEclipseContext;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
 import org.eclipse.e4.core.services.internal.context.EclipseContext.Scheduled;
 
 public class ValueComputation extends Computation {
@@ -113,14 +112,14 @@
 		int eventType = event.getEventType();
 		// if the originating context is being disposed, remove this value computation completely
 		if (eventType == ContextChangeEvent.DISPOSE) {
-			IObjectProvider provider = event.getContext();
-			IEclipseContext eventsContext = ((ObjectProviderContext) provider).getContext();
+			IEclipseContext eventsContext = event.getContext();
 			if (originatingContext.equals(eventsContext)) {
 				removeAll(originatingContext);
 				return;
 			}
 		}
-		this.originatingContext.handleInvalid(this.name,
+		// this.originatingContext.handleInvalid(this.name,
+		((EclipseContext) this.originatingContext).invalidate(this.name,
 				eventType == ContextChangeEvent.DISPOSE ? ContextChangeEvent.REMOVED : eventType,
 				event.getOldValue(), scheduled);
 	}
diff --git a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/internal/core/services/osgi/OSGiContextStrategy.java b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/internal/core/services/osgi/OSGiContextStrategy.java
index 147aadf..4961c90 100644
--- a/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/internal/core/services/osgi/OSGiContextStrategy.java
+++ b/bundles/org.eclipse.e4.core.services/src/org/eclipse/e4/internal/core/services/osgi/OSGiContextStrategy.java
@@ -22,8 +22,6 @@
 import org.eclipse.e4.core.services.context.IRunAndTrack;
 import org.eclipse.e4.core.services.context.spi.IContextConstants;
 import org.eclipse.e4.core.services.context.spi.ILookupStrategy;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
-import org.eclipse.e4.core.services.internal.context.ObjectProviderContext;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.Constants;
 import org.osgi.framework.InvalidSyntaxException;
@@ -264,7 +262,7 @@
 	 * we can do appropriate cleanup of our caches when the requesting context is disposed.
 	 */
 	public boolean notify(ContextChangeEvent event) {
-		IEclipseContext context = getContext(event);
+		IEclipseContext context = event.getContext();
 		if (context == null)
 			return false;
 		if (event.getEventType() != ContextChangeEvent.DISPOSE) {
@@ -285,11 +283,4 @@
 		}
 		return true;
 	}
-
-	private IEclipseContext getContext(ContextChangeEvent event) {
-		IObjectProvider provider = event.getContext();
-		if (provider instanceof ObjectProviderContext)
-			return ((ObjectProviderContext) provider).getContext();
-		return null;
-	}
 }
diff --git a/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/ContextInjectionTest.java b/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/ContextInjectionTest.java
index f0f9674..21d2965 100644
--- a/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/ContextInjectionTest.java
+++ b/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/ContextInjectionTest.java
@@ -46,7 +46,7 @@
 
 			public TestData value;
 
-			public void contextSet(IEclipseContext context) {
+			public void inject__contextSet(IEclipseContext context) {
 				contextSetCalled++;
 			}
 
@@ -130,7 +130,7 @@
 		// check field injection
 		assertEquals(testString, userObject.inject__String);
 		assertEquals(testInt, userObject.getInt());
-		assertEquals(context, userObject.context);
+		// assertEquals(context, userObject.context);
 
 		// check method injection
 		assertEquals(1, userObject.setMethodCalled);
@@ -170,7 +170,7 @@
 		// check field injection
 		assertEquals(testString, userObject.inject__String);
 		assertEquals(testInt, userObject.getInt());
-		assertEquals(context, userObject.context);
+		// assertEquals(context, userObject.context);
 
 		// check method injection
 		assertEquals(1, userObject.setMethodCalled);
@@ -202,7 +202,7 @@
 
 		// check inherited portion
 		assertEquals(testString, userObject.getString());
-		assertEquals(context, userObject.getContext());
+		// assertEquals(context, userObject.getContext());
 		assertEquals(testString, userObject.getStringViaMethod());
 		assertEquals(1, userObject.setStringCalled);
 
diff --git a/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/ObjectBasic.java b/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/ObjectBasic.java
index 3f0c655..c424c54 100644
--- a/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/ObjectBasic.java
+++ b/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/ObjectBasic.java
@@ -49,7 +49,7 @@
 		this.c = c;
 	}
 
-	public void contextSet(IEclipseContext context) {
+	public void inject__contextSet(IEclipseContext context) {
 		this.context = context;
 		finalized = true;
 	}
diff --git a/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/RunAndTrackTest.java b/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/RunAndTrackTest.java
index d923a2f..1a30d4f 100644
--- a/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/RunAndTrackTest.java
+++ b/tests/org.eclipse.e4.core.tests.services/src/org/eclipse/e4/core/services/internal/context/RunAndTrackTest.java
@@ -22,7 +22,6 @@
 import org.eclipse.e4.core.services.context.IRunAndTrack;
 import org.eclipse.e4.core.services.context.spi.ContextFunction;
 import org.eclipse.e4.core.services.context.spi.IContextConstants;
-import org.eclipse.e4.core.services.injector.IObjectProvider;
 import org.eclipse.e4.core.tests.services.TestActivator;
 
 /**
@@ -132,8 +131,7 @@
 
 			public boolean notify(ContextChangeEvent event) {
 				oldValue = event.getOldValue();
-				IObjectProvider provider = event.getContext();
-				IEclipseContext eventsContext = ((ObjectProviderContext) provider).getContext();
+				IEclipseContext eventsContext = event.getContext();
 				newValue = eventsContext.get(NAME);
 				return true;
 			}
@@ -179,8 +177,7 @@
 			public boolean notify(ContextChangeEvent event) {
 				// must get a value so we aren't removed
 				eventType = event.getEventType();
-				IObjectProvider provider = event.getContext();
-				IEclipseContext eventsContext = ((ObjectProviderContext) provider).getContext();
+				IEclipseContext eventsContext = event.getContext();
 				eventsContext.get(NAME);
 				return true;
 			}