private static void AssignMethodNameUsingAnyParameters(List <string> parameterNames, IDictionary <string, int> allParameterNamesCounts, string defaultMethodName, ISet <string> unavailableMethodNames, IDictionary <string, string> methodNamesMap, string methodId) { // assign method name with first available combo of one or more params based on low usage counts // if initial combos are not available then eventually all parameters will be used as part of the name (which is guaranteed to be unique) // sort param names by lowest usage counts to increase probability of getting a shorter method name with fewer params // and decrease long names for methods with a lot of params var sortedParameterNames = parameterNames .OrderBy(name => allParameterNamesCounts[name]) .ToList(); var parameterCounts = Enumerable.Range(1, parameterNames.Count); foreach (var parameterCount in parameterCounts) { var filteredNames = sortedParameterNames .Take(parameterCount) .ToArray(); var modifiedName = MethodNamesMapper.AddParametersToDefaultMethodName(defaultMethodName, filteredNames); if (unavailableMethodNames.Contains(modifiedName)) { continue; } unavailableMethodNames.Add(modifiedName); methodNamesMap.Add(methodId, modifiedName); return; } }
private static bool AssignMethodNameUsingUniqueParameter(IEnumerable <string> parameterNames, IDictionary <string, int> allParameterNamesCounts, string defaultMethodName, ISet <string> unavailableMethodNames, IDictionary <string, string> methodNamesMap, string methodId) { // filter by unique method parameter names var uniqueParameterNames = allParameterNamesCounts .Where(p => p.Value == 1) .Select(p => p.Key); // find first unique parameter within current parameters string firstUniqueParameter = parameterNames .Intersect(uniqueParameterNames) .FirstOrDefault(); if (string.IsNullOrEmpty(firstUniqueParameter)) { return(false); } // use first unique parameter as part of method name var modifiedName = MethodNamesMapper.AddParametersToDefaultMethodName(defaultMethodName, firstUniqueParameter); unavailableMethodNames.Add(modifiedName); methodNamesMap.Add(methodId, modifiedName); return(true); }
private static bool AssignDefaultNameToFirstMethod(IEnumerable <string> parameterNames, int parametersCount, string defaultMethodName, ISet <string> unavailableMethodNames, IDictionary <string, string> methodNamesMap, string methodId) { // assign default method name (without parameters) to first duplicate method // the rest of the duplicate methods will have names with parameters in its name bool isFirstDuplicateMethod = parametersCount <= 1; if (!isFirstDuplicateMethod || unavailableMethodNames.Contains(defaultMethodName)) { return(false); } unavailableMethodNames.Add(defaultMethodName); methodNamesMap.Add(methodId, defaultMethodName); // if current method has a parameter then the modified method name that includes it as part of the name // should no longer be available for later assignment var currentParameterName = parameterNames.SingleOrDefault(); if (string.IsNullOrEmpty(currentParameterName)) { return(true); } var modifiedName = MethodNamesMapper.AddParametersToDefaultMethodName(defaultMethodName, currentParameterName); unavailableMethodNames.Add(modifiedName); return(true); }
public static string TransformMethodNameIfDuplicate(IDictionary <string, string> duplicateMethodNamesMap, string wcfMethodName, SeparatedSyntaxList <ParameterSyntax> wcfParameters) { // replace method name with unique method name if its a duplicate (i.e. overload) var methodId = MethodNamesMapper.MapToMethodId(wcfMethodName, wcfParameters.ToFullString()); var modifiedMethodName = duplicateMethodNamesMap.ContainsKey(methodId) ? duplicateMethodNamesMap[methodId] : wcfMethodName; return(modifiedMethodName); }
public static Dictionary <string, string> CreateMappings(IEnumerable <MethodDeclarationSyntax> wcfMethods) { // maps method IDs for duplicate (i.e. overload) methods with unique method names var namesMap = new Dictionary <string, string>(); var duplicateMethodGroups = FindDuplicateMethodGroupsByName(wcfMethods); if (!duplicateMethodGroups.Any()) { return(namesMap); } foreach (var duplicateMethods in duplicateMethodGroups) { var maxParametersCount = duplicateMethods.Max(d => d.ParameterList.Parameters.Count); var parametersIndexes = Enumerable.Range(0, maxParametersCount + 1); var unavailableMethodNames = new HashSet <string>(); var allParameterNamesCounts = GetAllParameterNamesCounts(duplicateMethods); // go through each duplicate named method starting with the ones with the lowest parameters usage count // and then add a unique name to each method based on its parameters as compared against the usage count of all others // ideally try to keep the method names as short as possible foreach (var parametersIndex in parametersIndexes) { var filteredByParamCountMethods = duplicateMethods.Where(method => method.ParameterList.Parameters.Count == parametersIndex); foreach (var method in filteredByParamCountMethods) { var methodName = method.Identifier.ToFullString(); var defaultMethodName = methodName; var parameters = method.ParameterList.Parameters; var parameterNames = GetParameterNames(parameters); var methodId = MethodNamesMapper.MapToMethodId(methodName, parameters.ToFullString()); // run through each method name assignment rule if (AssignDefaultNameToFirstMethod(parameterNames, parametersIndex, defaultMethodName, unavailableMethodNames, namesMap, methodId)) { continue; } if (AssignMethodNameUsingUniqueParameter(parameterNames, allParameterNamesCounts, defaultMethodName, unavailableMethodNames, namesMap, methodId)) { continue; } AssignMethodNameUsingAnyParameters(parameterNames, allParameterNamesCounts, defaultMethodName, unavailableMethodNames, namesMap, methodId); } } } return(namesMap); }
private static MethodDeclarationSyntax FindWcfServiceMethodByMethodId(MethodDeclarationSyntax wcfClientMethod, IEnumerable <MethodDeclarationSyntax> wcfServiceMethods) { // find method by combo of method name + parameter names/types var clientMethodName = wcfClientMethod.Identifier.ValueText; var clientParameters = wcfClientMethod.ParameterList.Parameters; var clientMethodId = MethodNamesMapper.MapToMethodId(clientMethodName, clientParameters.ToFullString()); var wcfServiceMethod = wcfServiceMethods .SingleOrDefault(serviceMethod => { var serviceMethodName = serviceMethod.Identifier.ValueText; var serviceParams = serviceMethod.ParameterList.Parameters; var serviceParameterId = MethodNamesMapper.MapToMethodId(serviceMethodName, serviceParams.ToFullString()); return(serviceParameterId == clientMethodId); }); return(wcfServiceMethod); }