Unify naming conventions for runtime lookup

Code generation support for generics introduced the `Of..` name to
append the generic types being mocked (i.e. `IEnumerableOfStringMock`).
This was not reflected in the run-time naming classes so some tests
were failing.

In addition, there was quite some duplication between MockNaming and
StuntNaming, which is now unified with the former delegating to the
latter all behavior and just providing different DefaultNamespace and
DefaultSuffix values.

The new implementation is more aligned with the NamingConvention used
for codegen now.

Author: kzu

src/Moq/Moq.CodeAnalysis/MockNamingConvention.cs

@@ -10,13 +10,13 @@ namespace Moq
     public class MockNamingConvention : NamingConvention
     {
         /// <summary>
-        /// Gets the generated code namespace, which is <see cref="MockNaming.Namespace"/>.
+        /// Gets the generated code namespace, which is <see cref="MockNaming.DefaultNamespace"/>.
         /// </summary>
-        public override string Namespace => MockNaming.Namespace;
+        public override string Namespace => MockNaming.DefaultNamespace;
 
         /// <summary>
-        /// Gets the generated type names suffix, which is <see cref="MockNaming.NameSuffix"/>.
+        /// Gets the generated type names suffix, which is <see cref="MockNaming.DefaultSuffix"/>.
         /// </summary>
-        public override string NameSuffix => MockNaming.NameSuffix;
+        public override string NameSuffix => MockNaming.DefaultSuffix;
     }
 }

src/Moq/Moq.Sdk/MockNaming.cs

@@ -1,7 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using Stunts;
 
 namespace Moq.Sdk
 {
@@ -11,48 +9,46 @@ namespace Moq.Sdk
     public static class MockNaming
     {
         /// <summary>
-        /// The namespace where generated mocks are declared.
+        /// The default namespace where generated mocks are declared.
         /// </summary>
-        public const string Namespace = "Mocks";
+        public const string DefaultNamespace = "Mocks";
 
         /// <summary>
-        /// The suffix added to mock type names.
+        /// The default suffix added to mock type names.
         /// </summary>
-        public const string NameSuffix = "Mock";
+        public const string DefaultSuffix = "Mock";
 
         /// <summary>
-        /// Gets the runtime mock name from its base type and implemented interfaces.
+        /// Gets the runtime mock name from its base type and optional additional 
+        /// interfaces, using the <see cref="DefaultSuffix"/>.
         /// </summary>
-        public static string GetName(Type baseType, Type[] implementedInterfaces)
-        {
-            var builder = new StringBuilder();
-            AddNames(builder, new[] { baseType });
-            AddNames(builder, implementedInterfaces.OrderBy(x => x.Name));
-            return builder.Append(NameSuffix).ToString();
-        }
+        public static string GetName(Type baseType, Type[] additionalInterfaces)
+            => GetName(DefaultSuffix, baseType, additionalInterfaces);
+
+        /// <summary>
+        /// Gets the runtime mock name from its base type and optional additional interfaces 
+        /// and the given <paramref name="suffix"/> appended to the type name.
+        /// </summary>
+        public static string GetName(string suffix, Type baseType, Type[] additionalInterfaces)
+            => StuntNaming.GetName(suffix, baseType, additionalInterfaces);
+
+        /// <summary>
+        /// Gets the runtime mock full name from its base type and optional additional interfaces,
+        /// using the <see cref="DefaultNamespace"/> and <see cref="DefaultSuffix"/>.
+        /// </summary>
+        public static string GetFullName(Type baseType, params Type[] additionalInterfaces)
+            => GetFullName(DefaultNamespace, DefaultSuffix, baseType, additionalInterfaces);
 
         /// <summary>
         /// Gets the runtime mock full name from its base type and implemented interfaces.
         /// </summary>
-        public static string GetFullName(Type baseType, Type[] implementedInterfaces)
-            => Namespace + "." + GetName(baseType, implementedInterfaces);
+        public static string GetFullName(string @namespace, Type baseType, params Type[] additionalInterfaces)
+            => GetFullName(@namespace, DefaultSuffix, baseType, additionalInterfaces);
 
-        static void AddNames(StringBuilder builder, IEnumerable<Type> symbols)
-        {
-            foreach (var symbol in symbols)
-            {
-                if (!symbol.IsGenericType)
-                {
-                    builder.Append(symbol.Name);
-                }
-                else
-                {
-                    // Remove the arity of the generic type
-                    builder.Append(symbol.Name.Substring(0, symbol.Name.IndexOf('`')));
-                    builder.Append("Of");
-                    AddNames(builder, symbol.GenericTypeArguments);
-                }
-            }
-        }
+        /// <summary>
+        /// Gets the runtime mock full name from its base type and implemented interfaces.
+        /// </summary>
+        public static string GetFullName(string @namespace, string suffix, Type baseType, params Type[] additionalInterfaces)
+            => StuntNaming.GetFullName(@namespace, suffix, baseType, additionalInterfaces);
     }
 }

src/Stunts/Stunts.CodeAnalysis/NamingConvention.cs

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using System.Xml;
 using Microsoft.CodeAnalysis;
 
 namespace Stunts
@@ -14,12 +13,12 @@ public class NamingConvention
         /// <summary>
         /// The namespace of the generated code.
         /// </summary>
-        public virtual string Namespace => StuntNaming.Namespace;
+        public virtual string Namespace => StuntNaming.DefaultNamespace;
 
         /// <summary>
         /// Suffix appended to the type name, i.e. <c>IFooStunt</c>.
         /// </summary>
-        public virtual string NameSuffix => StuntNaming.NameSuffix;
+        public virtual string NameSuffix => StuntNaming.DefaultSuffix;
 
         /// <summary>
         /// The type name to generate for the given (optional) base type and implemented interfaces.

src/Stunts/Stunts.Sdk/StuntGenerator.cs

@@ -140,6 +140,8 @@ public async Task<Document> GenerateDocumentAsync(Project project, ITypeSymbol[]
 #if DEBUG
             // Update the persisted temp file in debug builds.
             File.WriteAllText(filePath, code);
+            if (Debugger.IsAttached)
+                Process.Start(filePath);
 #endif
 
             return document;

src/Stunts/Stunts.Tests/StuntFactoryTests.cs

@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 using Xunit;
 
 namespace Stunts.Tests
@@ -19,27 +15,26 @@ public void CreateStuntFromCallingAssemblyWithNamingConvention()
                 new[] { typeof(IDisposable) }, 
                 Array.Empty<object>());
 
-            Assert.IsType<IStuntFactoryIDisposableStunt>(stunt);
+            Assert.IsType<IDisposableIStuntFactoryStunt>(stunt);
         }
 
         [Fact]
         public void CanReplaceDefaultFactory()
         {
             var existing = StuntFactory.Default;
-            var factory = new IStuntFactoryIDisposableStunt();
+            var factory = new IDisposableIStuntFactoryStunt();
             StuntFactory.Default = factory;
 
             Assert.Same(factory, StuntFactory.Default);
 
             StuntFactory.Default = existing;
         }
-
     }
 }
 
 namespace Stunts
 {
-    public class IStuntFactoryIDisposableStunt : IStuntFactory, IDisposable
+    public class IDisposableIStuntFactoryStunt : IStuntFactory, IDisposable
     {
         public object CreateStunt(Assembly stuntsAssembly, Type baseType, Type[] implementedInterfaces, object[] construtorArguments)
             => throw new NotImplementedException();

src/Stunts/Stunts.Tests/StuntGeneratorTests.cs

@@ -35,7 +35,7 @@ public async Task CanGenerateStuntForInterface(string language, bool trace = fal
             var generator = new StuntGenerator();
             var compilation = await CreateStunt(generator, language, typeof(IFoo), trace);
             var assembly = compilation.Emit();
-            var type = assembly.GetExportedTypes().FirstOrDefault();
+            var type = assembly.GetType(StuntNaming.GetFullName(typeof(IFoo)), true);
 
             Assert.NotNull(type);
 
@@ -63,9 +63,7 @@ public async Task CanGenerateStuntForClass(string language, bool trace = false)
             var generator = new StuntGenerator();
             var compilation = await CreateStunt(generator, language, typeof(Foo), trace);
             var assembly = compilation.Emit();
-            var type = assembly.GetExportedTypes().FirstOrDefault();
-
-            Assert.NotNull(type);
+            var type = assembly.GetType(StuntNaming.GetFullName(typeof(Foo)), true);
 
             var instance = Activator.CreateInstance(type);
 
@@ -91,8 +89,8 @@ public async Task GeneratedNameContainsAdditionalInterfaceInName(string language
         {
             var compilation = await CreateStunt(new StuntGenerator(), language, new[] { typeof(INotifyPropertyChanged), typeof(IDisposable) }, trace);
             var assembly = compilation.Emit();
-            var type = assembly.GetExportedTypes().FirstOrDefault();
-
+            var type = assembly.GetType(StuntNaming.GetFullName(typeof(INotifyPropertyChanged), typeof(IDisposable)), true);
+            
             Assert.NotNull(type);
             Assert.True(typeof(IDisposable).IsAssignableFrom(type));
             Assert.True(type.FullName.Contains(nameof(IDisposable)),
@@ -106,7 +104,7 @@ public async Task GeneratedInterfaceHasCompilerGeneratedAttribute(string languag
         {
             var compilation = await CreateStunt(new StuntGenerator(), language, typeof(ICalculator), trace);
             var assembly = compilation.Emit();
-            var type = assembly.GetExportedTypes().FirstOrDefault();
+            var type = assembly.GetType(StuntNaming.GetFullName(typeof(ICalculator)), true);
 
             Assert.NotNull(type);
 
@@ -148,7 +146,7 @@ public async Task GeneratedTypeOverridesVirtualObjectMembers(string language, bo
         {
             var compilation = await CreateStunt(new StuntGenerator(), language, new[] { typeof(INotifyPropertyChanged), typeof(IDisposable) }, trace);
             var assembly = compilation.Emit();
-            var type = assembly.GetExportedTypes().FirstOrDefault();
+            var type = assembly.GetType(StuntNaming.GetFullName(typeof(INotifyPropertyChanged), typeof(IDisposable)), true);
 
             Assert.NotNull(type);
 

src/Stunts/Stunts.Tests/StuntNamingTests.cs

@@ -6,12 +6,12 @@ namespace Stunts.Tests
     public class StuntNamingTests
     {
         [Theory]
-        [InlineData("StuntFactoryIDisposableIServiceProvider" + StuntNaming.NameSuffix, typeof(StuntFactory), typeof(IServiceProvider), typeof(IDisposable))]
+        [InlineData("StuntFactoryIDisposableIServiceProvider" + StuntNaming.DefaultSuffix, typeof(StuntFactory), typeof(IServiceProvider), typeof(IDisposable))]
         public void GetNameOrdersTypes(string expectedName, Type baseType, params Type[] implementedInterfaces)
             => Assert.Equal(expectedName, StuntNaming.GetName(baseType, implementedInterfaces));
 
         [Theory]
-        [InlineData(StuntNaming.Namespace + ".StuntFactoryIDisposableIServiceProvider" + StuntNaming.NameSuffix, typeof(StuntFactory), typeof(IServiceProvider), typeof(IDisposable))]
+        [InlineData(StuntNaming.DefaultNamespace + ".StuntFactoryIDisposableIServiceProvider" + StuntNaming.DefaultSuffix, typeof(StuntFactory), typeof(IServiceProvider), typeof(IDisposable))]
         public void GetFullNameOrdersTypes(string expectedName, Type baseType, params Type[] implementedInterfaces)
             => Assert.Equal(expectedName, StuntNaming.GetFullName(baseType, implementedInterfaces));
     }

src/Stunts/Stunts/StuntNaming.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 
 namespace Stunts
 {
@@ -10,29 +11,83 @@ namespace Stunts
     public static class StuntNaming
     {
         /// <summary>
-        /// The namespace where generated stunts are declared.
+        /// The default namespace where generated stunts are declared.
         /// </summary>
-        public const string Namespace = "Stunts";
+        public const string DefaultNamespace = "Stunts";
 
         /// <summary>
-        /// The suffix added to stunt type names.
+        /// The default suffix added to stunt type names.
         /// </summary>
-        public const string NameSuffix = "Stunt";
+        public const string DefaultSuffix = "Stunt";
 
         /// <summary>
-        /// Gets the runtime stunt name from its base type and implemented interfaces.
+        /// Gets the runtime stunt name from its base type and optional additional 
+        /// interfaces, using the <see cref="DefaultSuffix"/>.
         /// </summary>
-        public static string GetName(Type baseType, Type[] implementedInterfaces)
-        {
-            Array.Sort(implementedInterfaces, Comparer<Type>.Create((x, y) => x.Name.CompareTo(y.Name)));
+        public static string GetName(Type baseType, params Type[] additionalInterfaces)
+            => GetName(DefaultSuffix, baseType, additionalInterfaces);
 
-            return baseType.Name + string.Join("", implementedInterfaces.Select(x => x.Name)) + NameSuffix;
+        /// <summary>
+        /// Gets the runtime stunt name from its base type and optional additional interfaces 
+        /// and the given <paramref name="suffix"/> appended to the type name.
+        /// </summary>
+        public static string GetName(string suffix, Type baseType, params Type[] additionalInterfaces)
+        {
+            if (baseType.IsClass)
+            {
+                return new StringBuilder()
+                    .AddName(baseType)
+                    .AddNames(additionalInterfaces.OrderBy(x => x.Name, StringComparer.Ordinal))
+                    .Append(suffix)
+                    .ToString();
+            }
+            else
+            {
+                return new StringBuilder()
+                    .AddNames(new[] { baseType }
+                        .Concat(additionalInterfaces)
+                        .OrderBy(x => x.Name, StringComparer.Ordinal))
+                    .Append(suffix)
+                    .ToString();
+            }
         }
 
+        /// <summary>
+        /// Gets the runtime stunt full name from its base type and optional additional interfaces,
+        /// using the <see cref="DefaultNamespace"/> and <see cref="DefaultSuffix"/>.
+        /// </summary>
+        public static string GetFullName(Type baseType, params Type[] additionalInterfaces)
+            => GetFullName(DefaultNamespace, DefaultSuffix, baseType, additionalInterfaces);
+
         /// <summary>
         /// Gets the runtime stunt full name from its base type and implemented interfaces.
         /// </summary>
-        public static string GetFullName(Type baseType, Type[] implementedInterfaces)
-            => Namespace + "." + GetName(baseType, implementedInterfaces);
+        public static string GetFullName(string @namespace, Type baseType, params Type[] additionalInterfaces)
+            => GetFullName(@namespace, DefaultSuffix, baseType, additionalInterfaces);
+
+        /// <summary>
+        /// Gets the runtime stunt full name from its base type and implemented interfaces.
+        /// </summary>
+        public static string GetFullName(string @namespace, string suffix, Type baseType, params Type[] additionalInterfaces)
+            => @namespace + "." + GetName(suffix, baseType, additionalInterfaces);
+    }
+
+    internal static class StringBuilderExtensions
+    {
+        public static StringBuilder AddNames(this StringBuilder builder, IEnumerable<Type> types)
+        {
+            foreach (var type in types)
+            {
+                builder.AddName(type);
+                if (type.IsConstructedGenericType)
+                {
+                    builder.Append("Of").AddNames(type.GenericTypeArguments);
+                }
+            }
+            return builder;
+        }
+
+        public static StringBuilder AddName(this StringBuilder builder, Type type)
+            => type.IsGenericType ? builder.Append(type.Name.Substring(0, type.Name.IndexOf('`'))) : builder.Append(type.Name);
     }
 }

src/Stunts/Stunts/Stunts.csproj

@@ -2,7 +2,7 @@
   <Sdk Name="Microsoft.Build.CentralPackageVersions" />
 
   <PropertyGroup>
-    <TargetFramework>netstandard1.3</TargetFramework>
+    <TargetFramework>netstandard2.0</TargetFramework>
 
     <!-- Avoid restore graph errors since the main packaging project also has implicit PackageId=Stunts -->
     <PackageId>Stunts.Core</PackageId>