 					_classDescriptor.getDescription(getConstructor(target));
 
 			var injectionPoints : Array = injecteeDescription.injectionPoints;
-			var length : int = injectionPoints.length;
-			for (var i : int = 0; i < length; i++)
-			{
-				var injectionPoint : InjectionPoint = injectionPoints[i];
-				injectionPoint.applyInjection(target, this);
-			}
+			applyInjectionPoints(target, injectionPoints);
 		}
 
 		public function getInstance(type : Class) : *
 		{
 			var mapping : InjectionRule = getMapping(type);
-			if (!mapping || !mapping.hasProvider())
-			{
-				return instantiateUnmapped(type);
-			}
-			return mapping.apply(this);
+			if (mapping && mapping.hasProvider())
+			{
+				return mapping.apply(this);
+			}
+			return instantiateUnmapped(type);
 		}
 		
 		public function createChildInjector(applicationDomain : ApplicationDomain = null) : Injector

			return _mappings[requestType] || getAncestorMapping(requestType);
		}

		SsInternal function getAncestorMapping(whenAskedFor : Class) : InjectionRule
		{
			return _parentInjector ? _parentInjector.getMapping(whenAskedFor) : null;
		}

		SsInternal function getRuleForInjectionPointConfig(
				config : InjectionPointConfig) : InjectionRule
		{
			var type : Class = Class(applicationDomain.getDefinition(config.typeName));
			if (config.injectionName)
			{
				return usingName(config.injectionName).getMapping(type);
			}
			return getMapping(type);
		}

		SsInternal function instantiateUnmapped(type : Class) : *

				throw new InjectorError("Can't instantiate interface " + getQualifiedClassName(type));
			}
			var instance : * = injectionPoint.applyInjection(type, this);
			applyInjectionPoints(instance, typeDescription.injectionPoints);
			return instance;
		}

