private void ThrowWhenProviderToRegisterOverlapsWithExistingProvider(
            InstanceProducer producerToRegister)
        {
            // A provider is a superset of the providerToRegister when it can be applied to ALL generic
            // types that the providerToRegister can be applied to as well.
            var overlappingProducers =
                from producer in this.CurrentProducers
                where producer.ImplementationType != null
                where !producer.Registration.WrapsInstanceCreationDelegate
                where !producerToRegister.Registration.WrapsInstanceCreationDelegate
                where producer.ImplementationType == producerToRegister.ImplementationType
                select producer;

            if (overlappingProducers.Any())
            {
                var overlappingProducer = overlappingProducers.FirstOrDefault();

                throw new InvalidOperationException(
                    StringResources.AnOverlappingGenericRegistrationExists(
                        producerToRegister.ServiceType,
                        overlappingProducer.ImplementationType,
                        overlappingProducer.IsConditional,
                        producerToRegister.ImplementationType,
                        producerToRegister.IsConditional));
            }
        }

 internal DisposableTransientComponentDiagnosticResult(Type serviceType, InstanceProducer registration, 
     string description)
     : base(serviceType, description, DiagnosticType.DisposableTransientComponent,
         DiagnosticSeverity.Warning, registration)
 {
     this.Registration = registration;
 }

 internal ServiceTypeDecoratorInfo(Type registeredServiceType, Type implementationType,
     InstanceProducer originalProducer)
 {
     this.registeredServiceType = registeredServiceType;
     this.ImplementationType = implementationType;
     this.OriginalProducer = originalProducer;
 }

        private static IEnumerable<InstanceProducer> GetSelfAndDependentProducers(InstanceProducer producer,
            HashSet<InstanceProducer> set = null)
        {
            set = set ?? new HashSet<InstanceProducer>(ReferenceEqualityComparer<InstanceProducer>.Instance);

            // Prevent stack overflow exception in case the graph is cyclic.
            if (set.Contains(producer))
            {
                yield break;
            }

            // Return self
            yield return set.AddReturn(producer);

            // Return dependent producers
            foreach (var relationship in producer.GetRelationships())
            {
                yield return set.AddReturn(relationship.Dependency);

                foreach (var dependentProducer in GetSelfAndDependentProducers(relationship.Dependency, set))
                {
                    yield return set.AddReturn(dependentProducer);
                }
            }
        }

        private static string BuildDescription(InstanceProducer registration, KnownRelationship[] relationships)
        {
            string componentName = BuildComponentName(registration, relationships);
            string unregisteredTypeName = BuildUnregisteredTypeDescription(relationships);

            return componentName + " depends on " + unregisteredTypeName + ".";
        }

 private static ContainerRegisteredServiceDiagnosticResult BuildDiagnosticResult(
     InstanceProducer registration, KnownRelationship[] relationships)
 {
     return new ContainerRegisteredServiceDiagnosticResult(
         serviceType: registration.ServiceType,
         description: BuildDescription(registration, relationships),
         relationships: relationships);
 }

 private static DebuggerViewItem[] GetDebugValue(Type implementationType, InstanceProducer[] dependencies)
 {
     return new[]
     {
         new DebuggerViewItem("ImplementationType", implementationType.ToFriendlyName(), implementationType),
         new DebuggerViewItem("Dependencies", dependencies.Length + " dependencies.", dependencies),
     };
 }

        internal InitializationContext(InstanceProducer producer, Registration registration)
        {
            // producer will be null when a user calls Registration.BuildExpression() directly, instead of
            // calling InstanceProducer.BuildExpression() or InstanceProducer.GetInstance(). 
            Requires.IsNotNull(registration, nameof(registration));

            this.Producer = producer;
            this.Registration = registration;
        }

 internal TornLifestyleDiagnosticResult(Type serviceType, string description, Lifestyle lifestyle,
     Type implementationType, InstanceProducer[] affectedRegistrations)
     : base(serviceType, description, DiagnosticType.TornLifestyle, DiagnosticSeverity.Warning,
         CreateDebugValue(implementationType, lifestyle, affectedRegistrations))
 {
     this.Lifestyle = lifestyle;
     this.ImplementationType = implementationType;
     this.AffectedRegistrations = new ReadOnlyCollection<InstanceProducer>(affectedRegistrations.ToList());
 }

        public void Add(InstanceProducer producer)
        {
            this.container.ThrowWhenContainerIsLocked();

            this.ThrowWhenOverlappingRegistrationsExist(producer);

            this.providers.RemoveAll(p => p.ServiceType == producer.ServiceType);

            this.providers.Add(new ClosedToInstanceProducerProvider(producer));
        }

 internal ShortCircuitedDependencyDiagnosticResult(Type serviceType, string description,
     InstanceProducer registration, KnownRelationship relationship,
     IEnumerable<InstanceProducer> expectedDependencies)
     : base(serviceType, description, DiagnosticType.ShortCircuitedDependency, 
         DiagnosticSeverity.Warning, 
         CreateDebugValue(registration, relationship, expectedDependencies.ToArray()))
 {
     this.Relationship = relationship;
     this.ExpectedDependencies = new ReadOnlyCollection<InstanceProducer>(expectedDependencies.ToList());
 }

 internal AmbiguousLifestylesDiagnosticResult(Type serviceType, string description, 
     Lifestyle[] lifestyles, Type implementationType, InstanceProducer diagnosedProducer, 
     InstanceProducer[] conflictingProducers)
     : base(serviceType, description, DiagnosticType.AmbiguousLifestyles, DiagnosticSeverity.Warning,
         CreateDebugValue(implementationType, lifestyles, conflictingProducers))
 {
     this.Lifestyles = new ReadOnlyCollection<Lifestyle>(lifestyles.ToList());
     this.ImplementationType = implementationType;
     this.DiagnosedRegistration = diagnosedProducer;
     this.ConflictingRegistrations = new ReadOnlyCollection<InstanceProducer>(conflictingProducers.ToList());
 }

        internal void AddAppliedDecorator(Type decoratorType, Container container, Lifestyle lifestyle, 
            Expression decoratedExpression, IEnumerable<KnownRelationship> decoratorRelationships = null)
        {
            var registration = new ExpressionRegistration(decoratedExpression, decoratorType,
                lifestyle, container);

            registration.ReplaceRelationships(decoratorRelationships ?? Enumerable.Empty<KnownRelationship>());

            var producer = new InstanceProducer(this.registeredServiceType, registration);

            this.appliedDecorators.Add(new DecoratorInfo(decoratorType, producer));
        }

        private static TornLifestyleDiagnosticResult CreateDiagnosticResult(
            InstanceProducer diagnosedProducer,
            InstanceProducer[] affectedProducers)
        {
            Type serviceType = diagnosedProducer.ServiceType;
            Type implementationType = diagnosedProducer.Registration.ImplementationType;
            Lifestyle lifestyle = diagnosedProducer.Registration.Lifestyle;
            string description = BuildDescription(diagnosedProducer, affectedProducers);

            return new TornLifestyleDiagnosticResult(serviceType, description, lifestyle, implementationType,
                affectedProducers);
        }

        private static bool IsAnalyzable(InstanceProducer producer)
        {
            // We can't analyze collections, because this would lead to false positives when decorators are
            // applied to the collection. For a decorator, each collection element it decorates is a 
            // dependency, which will make it look as if the decorator has too many dependencies. Since the
            // container will delegate the creation of those elements back to the container, those elements
            // would by them selves still get analyzed, so the only thing we'd miss here is the decorator.
            if (!producer.ServiceType.Info().IsGenericType)
            {
                return true;
            }

            return producer.ServiceType.GetGenericTypeDefinition() != typeof(IEnumerable<>);
        }

            public void Add(InstanceProducer producer)
            {
                this.container.ThrowWhenContainerIsLocked();
                this.ThrowWhenConditionalAndUnconditionalAreMixed(producer);

                this.ThrowWhenTypeAlreadyRegistered(producer);

                if (producer.IsUnconditional)
                {
                    this.producers.Clear();
                }

                this.producers.Add(producer);
            }

        internal OverriddenParameter(ParameterInfo parameter, Expression expression, InstanceProducer producer)
        {
            this.Parameter = parameter;
            this.Expression = expression;
            this.Producer = producer;

            // A placeholder is a fake expression that we inject into the NewExpression. After the 
            // NewExpression is created, it is ran through the ExpressionBuilding interception. By using
            // placeholders instead of the real overridden expressions we prevent those expressions from
            // being processed twice by the ExpressionBuilding event (since we expect the supplied expressions
            // to already be processed). After the event has ran we replace the placeholders with the real
            // expressions again (using an ExpressionVisitor).
            this.PlaceHolder = System.Linq.Expressions.Expression.Constant(null, parameter.ParameterType);
        }

        public void Add(InstanceProducer producer)
        {
            this.container.ThrowWhenContainerIsLocked();

            this.ThrowWhenConditionalIsRegisteredInOverridingMode(producer);
            this.ThrowWhenOverlappingRegistrationsExist(producer);

            if (this.container.Options.AllowOverridingRegistrations)
            {
                this.providers.RemoveAll(p => p.ServiceType == producer.ServiceType);
            }

            this.providers.Add(new ClosedToInstanceProducerProvider(producer));
        }

        public void Add(InstanceProducer producer)
        {
            this.container.ThrowWhenContainerIsLocked();
            this.ThrowWhenConditionalAndUnconditionalAreMixed(producer);

            this.ThrowWhenTypeAlreadyRegistered(producer);
            this.ThrowWhenProviderToRegisterOverlapsWithExistingProvider(producer);

            if (producer.IsUnconditional)
            {
                this.providers.Clear();
            }

            this.providers.Add(new SingleInstanceProducerProvider(producer));
        }

        public void Add(InstanceProducer producer)
        {
            this.container.ThrowWhenContainerIsLocked();
            this.ThrowWhenConditionalAndUnconditionalAreMixed(producer);
            this.ThrowWhenConditionalIsRegisteredInOverridingMode(producer);

            this.ThrowWhenTypeAlreadyRegistered(producer);
            this.ThrowWhenIdenticalImplementationIsAlreadyRegistered(producer);

            if (producer.IsUnconditional)
            {
                this.providers.Clear();
            }

            this.providers.Add(new SingleInstanceProducerProvider(producer));
        }