fix: disambiguate parameter class names for swashbuckle

src/IntelliTect.Coalesce.CodeGeneration.Api/BaseGenerators/ApiController.cs

@@ -101,7 +101,7 @@ private static void WriteControllerActionJsonPreamble(CSharpCodeBuilder b, Metho
             if (!method.ApiParameters.Any()) return;
 
             b.Line();
-            using (b.Block($"public class {method.NameWithoutAsync}Parameters"))
+            using (b.Block($"public class {method.ParameterClassName}"))
             {
                 foreach (var param in method.ApiParameters.OrderBy(p => p.HasDefaultValue))
                 {
@@ -282,7 +282,7 @@ protected IDisposable WriteControllerActionJsonSignature(CSharpCodeBuilder b, Me
 
             if (method.ApiParameters.Any())
             {
-                b.Line($"[FromBody] {method.NameWithoutAsync}Parameters _params");
+                b.Line($"[FromBody] {method.ParameterClassName} _params");
             }
 
             indent.Dispose();

src/IntelliTect.Coalesce.Tests/TargetClasses/TestDbContext/ComplexModel.cs

@@ -316,6 +316,9 @@ public static ItemResult<IFile> DownloadAttachmentStatic()
         [Coalesce]
         public CaseDtoStandalone CustomDto(CaseDtoStandalone input) => input;
 
+        [Coalesce]
+        public CaseDtoStandalone SameMethodNameAsMethodOnDifferentType(CaseDtoStandalone input) => input;
+
         [Coalesce]
         [ControllerAction(Method = HttpMethod.Post)]
         public static ItemResult HasTopLevelParamWithSameNameAsObjectProp(

src/IntelliTect.Coalesce.Tests/TargetClasses/TestDbContext/ComplexModelDependent.cs

@@ -8,5 +8,8 @@ public class ComplexModelDependent
         public int ParentId { get; set; }
 
         public string Name { get; set; }
+
+        [Coalesce]
+        public CaseDtoStandalone SameMethodNameAsMethodOnDifferentType(CaseDtoStandalone input) => input;
     }
 }

src/IntelliTect.Coalesce/TypeDefinition/MethodViewModel.cs

@@ -170,6 +170,28 @@ ApiActionHttpMethod is not HttpMethod.Get and not HttpMethod.Delete &&
         public IEnumerable<ParameterViewModel> ClientParameters => Parameters
             .Where(f => !f.IsDI);
 
+        /// <summary>
+        /// The generated class that wraps the method parameters for JSON-accepting API endpoints
+        /// </summary>
+        public string ParameterClassName
+        {
+            get
+            {
+                var parameterClassName = $"{NameWithoutAsync}Parameters";
+
+                // Disambiguate the parameter class name using the owning type's name
+                // if there are mutliple same-name methods in the application.
+                // This prevents Swashbuckle from throwing errors when it uses
+                // only the class name as the OpenAPI schema name.
+                if (Parent.ReflectionRepository?.ClientMethodsLookup[Name].Count() > 1)
+                {
+                    parameterClassName = Parent.Name + parameterClassName;
+                }
+
+                return parameterClassName;
+            }
+        }
+
         /// <summary>
         /// List of parameters that are part of the endpoint's API surface.
         /// Includes implicit parameters that are not defined on the underlying implementation.

src/IntelliTect.Coalesce/TypeDefinition/ReflectionRepository.cs

@@ -26,7 +26,6 @@ public class ReflectionRepository
 
         private readonly ConcurrentHashSet<DbContextTypeUsage> _contexts = new();
         private readonly ConcurrentHashSet<ClassViewModel> _entities = new();
-        private ILookup<ClassViewModel, EntityTypeUsage>? _entityUsages = null;
 
         private readonly ConcurrentHashSet<CrudStrategyTypeUsage> _behaviors = new();
         private readonly ConcurrentHashSet<CrudStrategyTypeUsage> _dataSources = new();
@@ -43,10 +42,17 @@ private readonly ConcurrentDictionary<object, TypeViewModel> _allTypeViewModels
         private readonly object _discoverLock = new();
 
         public ReadOnlyHashSet<DbContextTypeUsage> DbContexts => new(_contexts);
+
+        private ILookup<ClassViewModel, EntityTypeUsage>? _entityUsages = null;
         public ILookup<ClassViewModel, EntityTypeUsage> EntityUsages => _entityUsages ??= DbContexts
             .SelectMany(contextUsage => contextUsage.Entities)
             .ToLookup(entityUsage => entityUsage.ClassViewModel);
 
+        private ILookup<string, MethodViewModel>? _clientMethods = null;
+        public ILookup<string, MethodViewModel> ClientMethodsLookup => _clientMethods ??= ControllerBackedClasses
+            .SelectMany(c => c.ClientMethods)
+            .ToLookup(m => m.Name);
+
         private ReadOnlyDictionary<string, ClassViewModel>? _clientTypes;
         public ReadOnlyDictionary<string, ClassViewModel> ClientTypesLookup 
             => _clientTypes ??= new(ClientClasses.Union(Services).ToDictionary(c => c.ClientTypeName, StringComparer.OrdinalIgnoreCase));
@@ -175,6 +181,7 @@ private void ProcessAddedType(TypeViewModel type)
 
             // Null this out so it gets recomputed on next access.
             _clientTypes = null;
+            _clientMethods = null;
 
             if (type.IsA<DbContext>())
             {