Expand prototype DeclarationType options

Expanded the acceptable prototypes to include DeclarationTypes having
flags Function and Constant in addition to Variable and
UserDefinedTypeMember.

Author: BZngr

Rubberduck.Refactorings/Common/CodeBuilder.cs

@@ -1,5 +1,4 @@
-using Rubberduck.Common;
-using Rubberduck.Parsing;
+using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
 using System;
@@ -35,7 +34,7 @@ string BuildMemberBlockFromPrototype(ModuleBodyElementDeclaration declaration,
         /// <summary>
         /// Generates a Property Get codeblock based on the prototype declaration 
         /// </summary>
-        /// <param name="prototype">VariableDeclaration or UserDefinedTypeMember</param>
+        /// <param name="prototype">DeclarationType with flags: Variable, Constant, UserDefinedTypeMember, or Function</param>
         /// <param name="content">Member body content.  Formatting is the responsibility of the caller</param>
         /// <param name="parameterIdentifier">Defaults to '<paramref name="propertyIdentifier"/>Value' unless otherwise specified</param>
         bool TryBuildPropertyGetCodeBlock(Declaration prototype,
@@ -47,7 +46,7 @@ bool TryBuildPropertyGetCodeBlock(Declaration prototype,
         /// <summary>
         /// Generates a Property Let codeblock based on the prototype declaration 
         /// </summary>
-        /// <param name="prototype">VariableDeclaration or UserDefinedTypeMember</param>
+        /// <param name="prototype">DeclarationType with flags: Variable, Constant, UserDefinedTypeMember, or Function</param>
         /// <param name="content">Member body content.  Formatting is the responsibility of the caller</param>
         /// <param name="parameterIdentifier">Defaults to '<paramref name="propertyIdentifier"/>Value' unless otherwise specified</param>
         bool TryBuildPropertyLetCodeBlock(Declaration prototype,
@@ -60,7 +59,7 @@ bool TryBuildPropertyLetCodeBlock(Declaration prototype,
         /// <summary>
         /// Generates a Property Set codeblock based on the prototype declaration 
         /// </summary>
-        /// <param name="prototype">VariableDeclaration or UserDefinedTypeMember</param>
+        /// <param name="prototype">DeclarationType with flags: Variable, Constant, UserDefinedTypeMember, or Function</param>
         /// <param name="content">Member body content.  Formatting is the responsibility of the caller</param>
         /// <param name="parameterIdentifier">Defaults to '<paramref name="propertyIdentifier"/>Value' unless otherwise specified</param>
         bool TryBuildPropertySetCodeBlock(Declaration prototype,
@@ -71,16 +70,20 @@ bool TryBuildPropertySetCodeBlock(Declaration prototype,
             string parameterIdentifier = null);
 
         /// <summary>
-        /// Generates a UserDefinedType (UDT) declaration using a <c>VariableDeclaration</c> as the prototype for
-        /// creating the UserDefinedTypeMember.
+        /// Generates a UserDefinedType (UDT) declaration using the prototype declarations for
+        /// creating the UserDefinedTypeMember declarations.
         /// </summary>
-        /// <remarks>  At least one <c>VariableDeclaration</c> must be provided and 
-        /// all <c>UDTMemberIdentifiers</c> must be unique
+        /// <remarks>No validation or conflict analysis is applied to the identifiers.
         /// </remarks>
-        /// <param name="memberPrototypes">Collection of prototypes and their required identifier.  Must have 1 or more elements</param>
-        string BuildUserDefinedTypeDeclaration(string udtIdentifier, IEnumerable<(VariableDeclaration Field, string UDTMemberIdentifier)> memberPrototypes, Accessibility accessibility = Accessibility.Private);
+        /// <param name="memberPrototypes">DeclarationTypes with flags: Variable, Constant, UserDefinedTypeMember, or Function</param>
+        bool TryBuildUserDefinedTypeDeclaration(string udtIdentifier, IEnumerable<(Declaration Prototype, string UDTMemberIdentifier)> memberPrototypes, out string declaration, Accessibility accessibility = Accessibility.Private);
 
-        string UDTMemberDeclaration(string identifier, string typeName, string indention = null);
+        /// <summary>
+        /// Generates a <c>UserDefinedTypeMember</c> declaration expression based on the prototype declaration
+        /// </summary>
+        /// <param name="prototype">DeclarationType with flags: Variable, Constant, UserDefinedTypeMember, or Function</param>
+        /// <param name="indentation">Defaults is 4 spaces</param>
+        bool TryBuildUDTMemberDeclaration(string identifier, Declaration prototype, out string declaration, string indentation = null);
     }
 
     public class CodeBuilder : ICodeBuilder
@@ -119,7 +122,7 @@ private bool TryBuildPropertyBlockFromTarget<T>(T prototype, DeclarationType let
                 throw new ArgumentException();
             }
 
-            if (!(prototype is VariableDeclaration || prototype.DeclarationType.HasFlag(DeclarationType.UserDefinedTypeMember)))
+            if (!IsValidPrototypeDeclarationType(prototype.DeclarationType))
             {
                 return false;
             }
@@ -243,47 +246,64 @@ private static string EndStatement(DeclarationType declarationType)
         private static string TypeToken(DeclarationType declarationType)
             => _declarationTypeTokens[declarationType].TypeToken;
 
-        public string BuildUserDefinedTypeDeclaration(string udtIdentifier, IEnumerable<(VariableDeclaration Field, string UDTMemberIdentifier)> memberPrototypes, Accessibility accessibility = Accessibility.Private)
+        public bool TryBuildUserDefinedTypeDeclaration(string udtIdentifier, IEnumerable<(Declaration Prototype, string UDTMemberIdentifier)> memberPrototypes, out string declaration, Accessibility accessibility = Accessibility.Private)
         {
-            if (!memberPrototypes.Any())
+            if (udtIdentifier is null
+                ||!memberPrototypes.Any()
+                || memberPrototypes.Any(p => p.Prototype is null || p.UDTMemberIdentifier is null)
+                || memberPrototypes.Any(mp => !IsValidPrototypeDeclarationType(mp.Prototype.DeclarationType)))
             {
-                throw new ArgumentOutOfRangeException();
+                declaration = string.Empty;
+                return false;
             }
 
-            var hasDuplicateMemberNames = memberPrototypes.Select(pr => pr.UDTMemberIdentifier.ToUpperInvariant())
-                .GroupBy(uc => uc).Any(g => g.Count() > 1);
-            if (hasDuplicateMemberNames)
-            {
-                throw new ArgumentException();
-            }
+            var blockLines = memberPrototypes
+                .Select(m => BuildUDTMemberDeclaration(m.UDTMemberIdentifier, m.Prototype))
+                .ToList();
 
-            var newMemberTokenPairs = memberPrototypes.Select(m => (GetDeclarationIdentifier(m.Field, m.UDTMemberIdentifier), m.Field.AsTypeName))
-                .Cast<(string Identifier, string AsTypeName)>();
+            blockLines.Insert(0, $"{accessibility.TokenString()} {Tokens.Type} {udtIdentifier}");
 
-            var blockLines = new List<string>();
+            blockLines.Add($"{Tokens.End} {Tokens.Type}");
 
-            blockLines.Add($"{accessibility.TokenString()} {Tokens.Type} {udtIdentifier}");
+            declaration = string.Join(Environment.NewLine, blockLines);
+            return true;
+        }
 
-            blockLines.AddRange(newMemberTokenPairs.Select(m => UDTMemberDeclaration(m.Identifier, m.AsTypeName)));
+        public bool TryBuildUDTMemberDeclaration(string udtMemberIdentifier, Declaration prototype, out string declaration, string indentation = null)
+        {
+            declaration = string.Empty;
 
-            blockLines.Add($"{Tokens.End} {Tokens.Type}");
+            if (udtMemberIdentifier is null
+                || prototype is null
+                || !IsValidPrototypeDeclarationType(prototype.DeclarationType))
+            {
+                return false;
+            }
 
-            return string.Join(Environment.NewLine, blockLines);
+            declaration = BuildUDTMemberDeclaration(udtMemberIdentifier, prototype, indentation);
+            return true;
         }
 
-        private static string GetDeclarationIdentifier(Declaration field, string udtMemberIdentifier)
+        private static string BuildUDTMemberDeclaration(string udtMemberIdentifier, Declaration prototype, string indentation = null)
         {
-            if (field.IsArray)
+            var identifierExpression = udtMemberIdentifier;
+            if (prototype.IsArray)
             {
-                return field.Context.TryGetChildContext<VBAParser.SubscriptsContext>(out var ctxt)
+                identifierExpression = prototype.Context.TryGetChildContext<VBAParser.SubscriptsContext>(out var ctxt)
                     ? $"{udtMemberIdentifier}({ctxt.GetText()})"
                     : $"{udtMemberIdentifier}()";
             }
-            return udtMemberIdentifier;
+
+            return $"{indentation ?? "    "}{identifierExpression} {Tokens.As} {prototype.AsTypeName}";
         }
 
-        public string UDTMemberDeclaration(string identifier, string typeName, string indention = null)
-            => $"{indention ?? "    "}{identifier} {Tokens.As} {typeName}";
+        private static bool IsValidPrototypeDeclarationType(DeclarationType declarationType)
+        {
+            return declarationType.HasFlag(DeclarationType.Variable)
+                || declarationType.HasFlag(DeclarationType.UserDefinedTypeMember)
+                || declarationType.HasFlag(DeclarationType.Constant)
+                || declarationType.HasFlag(DeclarationType.Function);
+        }
 
         private static bool IsEnumField(VariableDeclaration declaration)
             => IsMemberVariable(declaration)

Rubberduck.Refactorings/CreateUDTMember/CreateUDTMemberModel.cs

@@ -7,25 +7,30 @@ namespace Rubberduck.Refactorings.CreateUDTMember
 {
     public class CreateUDTMemberModel : IRefactoringModel
     {
-        private Dictionary<Declaration, List<(VariableDeclaration prototype, string UDTMemberIdentifier)>> _targets { get; } = new Dictionary<Declaration, List<(VariableDeclaration, string)>>();
+        private Dictionary<Declaration, List<(Declaration prototype, string UDTMemberIdentifier)>> _targets { get; } = new Dictionary<Declaration, List<(Declaration, string)>>();
 
         public CreateUDTMemberModel()
         { }
 
-        public CreateUDTMemberModel(Declaration userDefinedType, IEnumerable<(VariableDeclaration prototype, string UserDefinedTypeMemberIdentifier)> conversionModels)
+        public CreateUDTMemberModel(Declaration userDefinedType, IEnumerable<(Declaration prototype, string UserDefinedTypeMemberIdentifier)> conversionModels)
         {
-            foreach ((VariableDeclaration prototype, string UDTMemberIdentifier) in conversionModels)
+            if (conversionModels.Any(cm => !IsValidPrototypeDeclarationType(cm.prototype.DeclarationType)))
+            {
+                throw new ArgumentException();
+            }
+
+            foreach ((Declaration prototype, string UDTMemberIdentifier) in conversionModels)
             {
                 AssignPrototypeToUserDefinedType(userDefinedType, prototype, UDTMemberIdentifier);
             }
         }
 
         public IReadOnlyCollection<Declaration> UserDefinedTypeTargets => _targets.Keys;
 
-        public IEnumerable<(VariableDeclaration prototype, string userDefinedTypeMemberIdentifier)> this[Declaration udt] 
+        public IEnumerable<(Declaration prototype, string userDefinedTypeMemberIdentifier)> this[Declaration udt] 
             => _targets[udt].Select(pr => (pr.prototype, pr.UDTMemberIdentifier));
 
-        private void AssignPrototypeToUserDefinedType(Declaration udt, VariableDeclaration prototype, string udtMemberIdentifierName = null)
+        private void AssignPrototypeToUserDefinedType(Declaration udt, Declaration prototype, string udtMemberIdentifierName = null)
         {
             if (!udt.DeclarationType.HasFlag(DeclarationType.UserDefinedType))
             {
@@ -34,7 +39,7 @@ private void AssignPrototypeToUserDefinedType(Declaration udt, VariableDeclarati
 
             if (!(_targets.TryGetValue(udt, out var memberPrototypes)))
             {
-                _targets.Add(udt, new List<(VariableDeclaration, string)>());
+                _targets.Add(udt, new List<(Declaration, string)>());
             }
             else
             {
@@ -50,5 +55,13 @@ private void AssignPrototypeToUserDefinedType(Declaration udt, VariableDeclarati
 
             _targets[udt].Add((prototype, udtMemberIdentifierName ?? prototype.IdentifierName));
         }
+
+        private static bool IsValidPrototypeDeclarationType(DeclarationType declarationType)
+        {
+            return declarationType.HasFlag(DeclarationType.Variable)
+                || declarationType.HasFlag(DeclarationType.UserDefinedTypeMember)
+                || declarationType.HasFlag(DeclarationType.Constant)
+                || declarationType.HasFlag(DeclarationType.Function);
+        }
     }
 }

Rubberduck.Refactorings/CreateUDTMember/CreateUDTMemberRefactoringAction.cs

@@ -27,19 +27,24 @@ public override void Refactor(CreateUDTMemberModel model, IRewriteSession rewrit
                 throw new ArgumentException();
             }
 
+            var rewriter = rewriteSession.CheckOutModuleRewriter(model.UserDefinedTypeTargets.First().QualifiedModuleName);
+
             foreach (var udt in model.UserDefinedTypeTargets)
             {
-                InsertNewMembersBlock(BuildNewMembersBlock(udt, model[udt]),
-                    GetInsertionIndex(udt.Context as VBAParser.UdtDeclarationContext),
-                    rewriteSession.CheckOutModuleRewriter(udt.QualifiedModuleName));
+                var newMembersBlock = BuildNewMembersBlock(udt, model);
+
+                var insertionIndex = (udt.Context as VBAParser.UdtDeclarationContext)
+                    .END_TYPE().Symbol.TokenIndex - 1;
+
+                rewriter.InsertBefore(insertionIndex, $"{newMembersBlock}");
             }
         }
 
-        private string BuildNewMembersBlock(Declaration udt, IEnumerable<(VariableDeclaration Field, string UDTMemberIdentifier)> newMemberPairs)
+        private string BuildNewMembersBlock(Declaration udt, CreateUDTMemberModel model)
         {
             var indentation = DetermineIndentationFromLastMember(udt);
 
-            var newMemberStatements = GenerateUserDefinedMemberDeclarations(newMemberPairs, indentation);
+            var newMemberStatements = GenerateUserDefinedMemberDeclarations(model[udt], indentation);
 
             return string.Concat(newMemberStatements);
         }
@@ -55,13 +60,17 @@ private string DetermineIndentationFromLastMember(Declaration udt)
             return endOfStatementContextPrototype.GetText();
         }
 
-        private IEnumerable<string> GenerateUserDefinedMemberDeclarations(IEnumerable<(VariableDeclaration Field, string UDTMemberIdentifier)> newMemberPairs, string indentation)
-            => newMemberPairs.Select(pr => _codeBuilder.UDTMemberDeclaration(pr.UDTMemberIdentifier, pr.Field.AsTypeName, indentation));
-
-        private static void InsertNewMembersBlock(string newMembersBlock, int insertionIndex, IModuleRewriter rewriter) 
-            => rewriter.InsertBefore(insertionIndex, $"{newMembersBlock}");
-
-        private int GetInsertionIndex(VBAParser.UdtDeclarationContext udtContext) 
-            => udtContext.END_TYPE().Symbol.TokenIndex - 1;
+        private IEnumerable<string> GenerateUserDefinedMemberDeclarations(IEnumerable<(Declaration Prototype, string UDTMemberIdentifier)> newMemberPairs, string indentation)
+        {
+            var declarations = new List<string>();
+            foreach (var (Prototype, UDTMemberIdentifier) in newMemberPairs)
+            {
+                if (_codeBuilder.TryBuildUDTMemberDeclaration(UDTMemberIdentifier, Prototype, out var declaration, indentation))
+                {
+                    declarations.Add(declaration);
+                }
+            }
+            return declarations;
+        }
     }
 }

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldInsertNewCode/EncapsulateFieldCodeBuilder.cs

@@ -78,9 +78,11 @@ public string BuildUserDefinedTypeDeclaration(IObjectStateUDT objectStateUDT, IE
             var selected = candidates.Where(c => c.EncapsulateFlag);
 
             var newUDTMembers = selected
-                .Select(m => (m.Declaration as VariableDeclaration, m.BackingIdentifier));
+                .Select(m => (m.Declaration, m.BackingIdentifier));
 
-            return _codeBuilder.BuildUserDefinedTypeDeclaration(objectStateUDT.AsTypeName, newUDTMembers);
+            _codeBuilder.TryBuildUserDefinedTypeDeclaration(objectStateUDT.AsTypeName, newUDTMembers, out var declaration);
+
+            return declaration ?? string.Empty;
         }
 
         public string BuildObjectStateFieldDeclaration(IObjectStateUDT objectStateUDT)

Rubberduck.Refactorings/EncapsulateField/EncapsulateFieldUseBackingUDTMember/EncapsulateFieldUseBackingUDTMemberRefactoringAction.cs

@@ -65,7 +65,7 @@ private void ModifyFields(EncapsulateFieldUseBackingUDTMemberModel encapsulateFi
             if (encapsulateFieldModel.ObjectStateUDTField.IsExistingDeclaration)
             {
                 var conversionPairs = encapsulateFieldModel.SelectedFieldCandidates
-                    .Select(c => (c.Declaration as VariableDeclaration, c.BackingIdentifier));
+                    .Select(c => (c.Declaration, c.BackingIdentifier));
 
                 var model = new CreateUDTMemberModel(encapsulateFieldModel.ObjectStateUDTField.AsTypeDeclaration, conversionPairs);
                 _createUDTMemberRefactoringAction.Refactor(model, rewriteSession);