Refactor Composition Context to prevent composition overwrite

src/Abioc/Composition/CodeComposition.cs

@@ -50,7 +50,7 @@ private static (string generatedCode, object[] fieldValues) GenerateCode(
             IReadOnlyList<IComposition> compositions =
                 context.Compositions.Values.DistinctBy(r => r.Type).OrderBy(r => r.Type.ToCompileName()).ToList();
 
-            var code = new CodeCompositions(registrations, context.ConstructionContext);
+            var code = new CodeCompositions(registrations);
 
             // First try with simple method names.
             foreach (IComposition composition in compositions)
@@ -106,7 +106,7 @@ private static string GenerateCode(CompositionContext context, CodeCompositions
             if (code == null)
                 throw new ArgumentNullException(nameof(code));
 
-            string genericContainerParam = code.HasConstructionContext ? $"<{context.ExtraDataType}>" : string.Empty;
+            string genericContainerParam = context.HasConstructionContext ? $"<{context.ExtraDataType}>" : string.Empty;
 
             var builder = new StringBuilder(10240);
             builder.AppendFormat(
@@ -125,7 +125,7 @@ private static string GenerateCode(CompositionContext context, CodeCompositions
             builder.Append(fieldInitializationsMethod);
 
             builder.Append(NewLine);
-            string composeMapMethod = GenerateComposeMapMethod(code);
+            string composeMapMethod = GenerateComposeMapMethod(context, code);
             composeMapMethod = CodeGen.Indent(NewLine + composeMapMethod, 2);
             builder.Append(composeMapMethod);
 
@@ -186,13 +186,15 @@ private static string GenerateConstructor(CodeCompositions code)
             return builder.ToString();
         }
 
-        private static string GenerateComposeMapMethod(CodeCompositions code)
+        private static string GenerateComposeMapMethod(CompositionContext context, CodeCompositions code)
         {
+            if (context == null)
+                throw new ArgumentNullException(nameof(context));
             if (code == null)
                 throw new ArgumentNullException(nameof(code));
 
-            string composeMapType = code.HasConstructionContext
-                ? $"System.Collections.Generic.Dictionary<System.Type, System.Func<{code.ConstructionContext}, object>>"
+            string composeMapType = context.HasConstructionContext
+                ? $"System.Collections.Generic.Dictionary<System.Type, System.Func<{context.ConstructionContext}, object>>"
                 : "System.Collections.Generic.Dictionary<System.Type, System.Func<object>>";
 
             var builder = new StringBuilder(1024);
@@ -204,7 +206,7 @@ private static string GenerateComposeMapMethod(CodeCompositions code)
             string initializers =
                 string.Join(
                     NewLine,
-                    code.ComposeMethods.Select(c => GenerateComposeMapInitializer(code.HasConstructionContext, c)));
+                    code.ComposeMethods.Select(c => GenerateComposeMapInitializer(context.HasConstructionContext, c)));
             initializers = CodeGen.Indent(NewLine + initializers, 2);
             builder.Append(initializers);
 
@@ -219,11 +221,11 @@ private static string GenerateGetServiceMethod(CompositionContext context, CodeC
             if (code == null)
                 throw new ArgumentNullException(nameof(code));
 
-            string parameter = code.HasConstructionContext
+            string parameter = context.HasConstructionContext
                 ? $",{NewLine}    {context.ExtraDataType} extraData"
                 : string.Empty;
 
-            string contextVariable = code.HasConstructionContext
+            string contextVariable = context.HasConstructionContext
                 ? $"{NewLine}    var context = {context.ConstructionContext}.Default.Initialize(extraData);"
                 : string.Empty;
 
@@ -250,7 +252,7 @@ string GetCaseSnippet(Type key, IComposition composition)
             {
                 string keyComment = key.ToCompileName();
                 string instanceExpression = composition.GetInstanceExpression(context, code.UsingSimpleNames);
-                instanceExpression = CodeGen.Indent(instanceExpression, 1);
+                instanceExpression = CodeGen.Indent(instanceExpression);
 
                 string caseSnippet =
                     $"case {key.GetHashCode()}: // {keyComment}{NewLine}    return {instanceExpression};";
@@ -269,11 +271,11 @@ private static string GenerateGetServicesMethod(CompositionContext context, Code
             if (code == null)
                 throw new ArgumentNullException(nameof(code));
 
-            string parameter = code.HasConstructionContext
+            string parameter = context.HasConstructionContext
                 ? $",{NewLine}    {context.ExtraDataType} extraData"
                 : string.Empty;
 
-            string contextVariable = code.HasConstructionContext
+            string contextVariable = context.HasConstructionContext
                 ? $"{NewLine}    var context = {context.ConstructionContext}.Default.Initialize(extraData);"
                 : string.Empty;
 
@@ -335,23 +337,16 @@ private static string GenerateComposeMapInitializer(
 
         private class CodeCompositions
         {
-            public CodeCompositions(
-                IReadOnlyDictionary<Type, IRegistration[]> registrations,
-                string constructionContext = null)
+            public CodeCompositions(IReadOnlyDictionary<Type, IRegistration[]> registrations)
             {
                 if (registrations == null)
                     throw new ArgumentNullException(nameof(registrations));
 
                 Registrations = registrations;
-                ConstructionContext = constructionContext;
             }
 
             public IReadOnlyDictionary<Type, IRegistration[]> Registrations { get; }
 
-            public string ConstructionContext { get; }
-
-            public bool HasConstructionContext => !string.IsNullOrWhiteSpace(ConstructionContext);
-
             public List<(string name, Type type, bool requiresContext)> ComposeMethods { get; } =
                 new List<(string, Type, bool)>(32);
 

src/Abioc/Composition/CompositionContext.cs

@@ -6,12 +6,15 @@ namespace Abioc.Composition
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using Abioc.Composition.Compositions;
 
     /// <summary>
     /// The composition context.
     /// </summary>
     public class CompositionContext
     {
+        private readonly Dictionary<Type, IComposition> _compositions = new Dictionary<Type, IComposition>(32);
+
         /// <summary>
         /// Initializes a new instance of the <see cref="CompositionContext"/> class.
         /// </summary>
@@ -26,7 +29,7 @@ public CompositionContext(string extraDataType = null, string constructionContex
         /// <summary>
         /// Gets the context.
         /// </summary>
-        public Dictionary<Type, IComposition> Compositions { get; } = new Dictionary<Type, IComposition>(32);
+        public IReadOnlyDictionary<Type, IComposition> Compositions => _compositions;
 
         /// <summary>
         /// Gets the type of the <see cref="ConstructionContext{T}.Extra"/> data.
@@ -37,5 +40,83 @@ public CompositionContext(string extraDataType = null, string constructionContex
         /// Gets the type of the <see cref="ConstructionContext{T}"/>.
         /// </summary>
         public string ConstructionContext { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether
+        /// </summary>
+        public bool HasConstructionContext => !string.IsNullOrWhiteSpace(ConstructionContext);
+
+        /// <summary>
+        /// Removes the <see cref="IComposition"/> from the <see cref="Compositions"/> for the specified
+        /// <paramref name="type"/> returning the value.
+        /// </summary>
+        /// <param name="type">The type under which the <see cref="IComposition"/> is keyed.</param>
+        /// <returns>The <see cref="IComposition"/> that was removed from the <see cref="Compositions"/>.</returns>
+        /// <exception cref="CompositionException">
+        /// There is no <see cref="IComposition"/> for the specified <paramref name="type"/>.
+        /// </exception>
+        public IComposition RemoveComposition(Type type)
+        {
+            if (type == null)
+                throw new ArgumentNullException(nameof(type));
+
+            if (!_compositions.TryGetValue(type, out IComposition composition))
+            {
+                throw new CompositionException($"There is no current composition for the type '{type}'.");
+            }
+
+            _compositions.Remove(type);
+            return composition;
+        }
+
+        /// <summary>
+        /// Adds the <paramref name="composition"/> to the <see cref="Compositions"/>.
+        /// </summary>
+        /// <param name="composition">The <see cref="IComposition"/> to add.</param>
+        /// <exception cref="CompositionException">
+        /// There is already a <see cref="IComposition"/> for the specified
+        /// <paramref name="composition"/>.<see cref="IComposition.Type"/> that is not the
+        /// default and cannot be superseded by specified <paramref name="composition"/>.
+        /// </exception>
+        public void AddComposition(IComposition composition)
+        {
+            if (composition == null)
+                throw new ArgumentNullException(nameof(composition));
+
+            AddComposition(composition.Type, composition);
+        }
+
+        /// <summary>
+        /// Adds the <paramref name="composition"/> to the <see cref="Compositions"/>.
+        /// </summary>
+        /// <param name="type">The <see cref="Type"/> that is satisfied by the <paramref name="composition"/></param>
+        /// <param name="composition">The <see cref="IComposition"/> to add.</param>
+        /// <exception cref="CompositionException">
+        /// There is already a <see cref="IComposition"/> for the specified <paramref name="type"/> that is not the
+        /// default and cannot be superseded by specified <paramref name="composition"/>.
+        /// </exception>
+        public void AddComposition(Type type, IComposition composition)
+        {
+            if (type == null)
+                throw new ArgumentNullException(nameof(type));
+            if (composition == null)
+                throw new ArgumentNullException(nameof(composition));
+
+            if (_compositions.TryGetValue(type, out IComposition existing))
+            {
+#pragma warning disable SA1119 // Statement must not use unnecessary parenthesis
+                if (!(existing is ConstructorComposition constructorComposition) || !constructorComposition.IsDefault)
+#pragma warning restore SA1119 // Statement must not use unnecessary parenthesis
+                {
+                    string message =
+                        $"There is already a composition for '{type}', are there multiple registrations. " +
+                        $"The Existing composition is '{existing.GetType()}', the new composition is " +
+                        $"'{composition.GetType()}'.";
+                    throw new CompositionException(message);
+                }
+            }
+
+            _compositions[type] = composition;
+        }
     }
 }

src/Abioc/Composition/Compositions/ConstructorComposition.cs

@@ -20,9 +20,14 @@ public class ConstructorComposition : CompositionBase
         /// </summary>
         /// <param name="type">The <see cref="Type"/> created by the constructor.</param>
         /// <param name="parameters">The <see cref="Parameters"/> of the constructor.</param>
+        /// <param name="isDefault">
+        /// A value indicating whether this is the default composition, and therefore can be superseded by
+        /// another composition.
+        /// </param>
         public ConstructorComposition(
             Type type,
-            IReadOnlyList<ParameterInfo> parameters)
+            IReadOnlyList<ParameterInfo> parameters,
+            bool isDefault = false)
         {
             if (type == null)
                 throw new ArgumentNullException(nameof(type));
@@ -31,6 +36,7 @@ public ConstructorComposition(
 
             Type = type;
             Parameters = parameters;
+            IsDefault = isDefault;
 
             _parameterExpressions = new List<IParameterExpression>(parameters.Count);
         }
@@ -45,6 +51,12 @@ public ConstructorComposition(
         /// </summary>
         public IReadOnlyList<ParameterInfo> Parameters { get; }
 
+        /// <summary>
+        /// Gets a value indicating whether this is the default composition, and therefore can be superseded by
+        /// another composition.
+        /// </summary>
+        public bool IsDefault { get; }
+
         /// <inheritdoc/>
         public override string GetInstanceExpression(CompositionContext context, bool simpleName)
         {

src/Abioc/Composition/RegistrationComposition.cs

@@ -67,9 +67,9 @@ from kvp in registrations
                 select (kvp.Key, kvp.Value.Single());
 
             // Re-reference the compositions under the type mappings.
-            foreach ((Type type, IRegistration registration) in typeMappings)
+            foreach ((Type serviceType, IRegistration registration) in typeMappings)
             {
-                context.Compositions[type] = context.Compositions[registration.ImplementationType];
+                context.AddComposition(serviceType, context.Compositions[registration.ImplementationType]);
             }
 
             return context;

src/Abioc/Composition/Visitors/FactoryRegistrationVisitor.WithContext.cs

@@ -42,7 +42,7 @@ public void Accept(FactoryRegistration<TExtra> registration)
 
             Type type = registration.ImplementationType;
             var composition = new FactoryComposition(type, registration.Factory, typeof(ConstructionContext<TExtra>));
-            _context.Compositions[type] = composition;
+            _context.AddComposition(composition);
         }
     }
 }

src/Abioc/Composition/Visitors/FactoryRegistrationVisitor.cs

@@ -39,7 +39,7 @@ public void Accept(FactoryRegistration registration)
 
             Type type = registration.ImplementationType;
             var composition = new FactoryComposition(type, registration.Factory);
-            _context.Compositions[type] = composition;
+            _context.AddComposition(composition);
         }
     }
 }

src/Abioc/Composition/Visitors/InjectedSingletonRegistrationVisitor.cs

@@ -42,7 +42,7 @@ public void Accept(InjectedSingletonRegistration<TImplementation> registration)
                 throw new ArgumentNullException(nameof(registration));
 
             IComposition composition = new InjectedSingletonComposition<TImplementation>(registration.Value);
-            _context.Compositions[composition.Type] = composition;
+            _context.AddComposition(composition);
         }
     }
 }

src/Abioc/Composition/Visitors/PropertyDependencyRegistrationVisitor.cs

@@ -42,17 +42,18 @@ public void Accept(PropertyDependencyRegistration registration)
             if (registration == null)
                 throw new ArgumentNullException(nameof(registration));
 
-            (string property, Type type)[] propertiesToInject =
-                GetPropertiesToInject(registration).Select(p => (p.Name, p.PropertyType)).ToArray();
-
+            // Visit the inner registration which will add a composition.
             _manager.Visit(registration.Inner);
 
-            // Get the original composition.
-            IComposition inner = _context.Compositions[registration.ImplementationType];
+            // Get the original composition, removing it to allow it to be replaced.
+            IComposition inner = _context.RemoveComposition(registration.ImplementationType);
+
+            (string property, Type type)[] propertiesToInject =
+                GetPropertiesToInject(registration).Select(p => (p.Name, p.PropertyType)).ToArray();
 
             // Replace the inner composition.
             IComposition composition = new PropertyDependencyComposition(inner, propertiesToInject);
-            _context.Compositions[composition.Type] = composition;
+            _context.AddComposition(composition);
         }
 
         /// <inheritdoc />

src/Abioc/Composition/Visitors/SingleConstructorRegistrationVisitor.cs

@@ -66,8 +66,8 @@ public void Accept(SingleConstructorRegistration registration)
             }
 
             ParameterInfo[] parameters = constructors[0].GetParameters();
-            IComposition composition = new ConstructorComposition(type, parameters);
-            _context.Compositions[composition.Type] = composition;
+            IComposition composition = new ConstructorComposition(type, parameters, isDefault: true);
+            _context.AddComposition(composition);
         }
     }
 }

src/Abioc/Composition/Visitors/SingletonRegistrationVisitor.cs

@@ -39,14 +39,15 @@ public void Accept(SingletonRegistration registration)
             if (registration == null)
                 throw new ArgumentNullException(nameof(registration));
 
+            // Visit the inner registration which will add a composition.
             _manager.Visit(registration.Inner);
 
-            // Get the original composition.
-            IComposition inner = _context.Compositions[registration.ImplementationType];
+            // Get the original composition, removing it to allow it to be replaced.
+            IComposition inner = _context.RemoveComposition(registration.ImplementationType);
 
             // Replace the inner composition.
             IComposition composition = new SingletonComposition(inner);
-            _context.Compositions[composition.Type] = composition;
+            _context.AddComposition(composition);
         }
 
         /// <inheritdoc />

src/Abioc/Composition/Visitors/TypedFactoryRegistrationVisitor.WithContext.cs

@@ -45,7 +45,7 @@ public void Accept(TypedFactoryRegistration<TExtra, TImplementation> registratio
             IComposition composition = new TypedFactoryComposition<TImplementation>(
                 registration.Factory,
                 typeof(ConstructionContext<TExtra>));
-            _context.Compositions[composition.Type] = composition;
+            _context.AddComposition(composition);
         }
     }
 }

src/Abioc/Composition/Visitors/TypedFactoryRegistrationVisitor.cs

@@ -40,7 +40,7 @@ public void Accept(TypedFactoryRegistration<TImplementation> registration)
                 throw new ArgumentNullException(nameof(registration));
 
             IComposition composition = new TypedFactoryComposition<TImplementation>(registration.Factory);
-            _context.Compositions[composition.Type] = composition;
+            _context.AddComposition(composition);
         }
     }
 }