 
 		public function describeInjections(type : Class) : TypeDescription
 		{
-			_rawDescription = _descriptor.getInstanceDescription(type);
-			_traits = _rawDescription.traits;
+			var rawDescription : Object = _descriptor.getInstanceDescription(type);
+			const traits : Object = rawDescription.traits;
+			const typeName : String = rawDescription.name;
 			const description : TypeDescription = new TypeDescription();
-			addCtorInjectionPoint(description);
-			addFieldInjectionPoints(description, _traits.variables);
-			addFieldInjectionPoints(description, _traits.accessors);
-			addMethodInjectionPoints(description);
-			addPostConstructMethodPoints(description);
-			addPreDestroyMethodPoints(description);
-			_rawDescription = null;
-			_traits = null;
+			addCtorInjectionPoint(description, traits, typeName);
+			addFieldInjectionPoints(description, traits.variables);
+			addFieldInjectionPoints(description, traits.accessors);
+			addMethodInjectionPoints(description, traits.methods, typeName);
+			addPostConstructMethodPoints(description, traits.methods, typeName);
+			addPreDestroyMethodPoints(description, traits.methods, typeName);
 			return description;
 		}
 
 		//----------------------         Private / Protected Methods        ----------------------//
-		private function addCtorInjectionPoint(description : TypeDescription) : void
-		{
-			const parameters : Array = _traits.constructor;
+		private function addCtorInjectionPoint(
+			description : TypeDescription, traits : Object, typeName : String) : void
+		{
+			const parameters : Array = traits.constructor;
 			if (!parameters)
 			{
-				description.ctor =  _traits.bases.length > 0
+				description.ctor =  traits.bases.length > 0
 					? new NoParamsConstructorInjectionPoint()
 					: null;
 				return;
 			}
 			const injectParameters : Object =
-					_traits.metadata && extractTagParameters('Inject', _traits.metadata);
+					traits.metadata && extractTagParameters('Inject', traits.metadata);
 			const parameterNames : Array =
 				(injectParameters && injectParameters.name || '').split(',');
-			const requiredParameters : int = gatherMethodParameters(parameters, parameterNames);
+			const requiredParameters : int =
+				gatherMethodParameters(parameters, parameterNames, typeName);
 			description.ctor = new ConstructorInjectionPoint(parameters, requiredParameters);
 		}
 
-		private function addMethodInjectionPoints(description : TypeDescription) : void
-		{
-			const methods : Array = _traits.methods;
+		private function addMethodInjectionPoints(
+			description : TypeDescription, methods : Array, typeName : String) : void
+		{
 			if (!methods)
 			{
 				return;

				var parameterNames : Array = (injectParameters.name || '').split(',');
				var parameters : Array = method.parameters;
				const requiredParameters : uint =
						gatherMethodParameters(parameters, parameterNames);
				var injectionPoint : MethodInjectionPoint = new MethodInjectionPoint(
						method.name, parameters, requiredParameters, optional);
				description.addInjectionPoint(injectionPoint);
			}
		}

		private function addPostConstructMethodPoints(description : TypeDescription) : void
		{
			var injectionPoints : Array = gatherOrderedInjectionPointsForTag(
				PostConstructInjectionPoint, 'PostConstruct');
			for (var i : int = 0, length : int = injectionPoints.length; i < length; i++)
			{
				description.addInjectionPoint(injectionPoints[i]);
			}
		}

		private function addPreDestroyMethodPoints(description : TypeDescription) : void
		{
			var injectionPoints : Array = gatherOrderedInjectionPointsForTag(
				PreDestroyInjectionPoint, 'PreDestroy');
			if (!injectionPoints.length)
			{
				return;

		}

		private function gatherOrderedInjectionPointsForTag(
			injectionPointClass : Class, tag : String, methods : Array, typeName : String) : Array
		{
			const injectionPoints : Array = [];
			if (!methods)
			{
				return injectionPoints;
