remove un-used parameters (#4514)

Author: SimonCropp

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/ContainerDefinitionsExtractor.cs

@@ -31,21 +31,21 @@ public static IReadOnlyList<ExtractedContainerDefinition> GetContainerDefinition
       while (containingTypeDeclaration.Parent is TypeDeclarationSyntax syntax)
       {
         containingTypeDeclaration = syntax;
-        containers.Add(GetContainerDefinition(extractionContext, containingTypeDeclaration));
+        containers.Add(GetContainerDefinition(containingTypeDeclaration));
       }
 
       namespaceDeclaration = containingTypeDeclaration.Parent as NamespaceDeclarationSyntax;
       if (namespaceDeclaration is not null)
       {
-        containers.Add(GetContainerDefinition(extractionContext, namespaceDeclaration));
+        containers.Add(GetContainerDefinition(namespaceDeclaration));
       }
 
       containers.Reverse();
 
       return containers;
     }
 
-    private static ExtractedContainerDefinition GetContainerDefinition(DefinitionExtractionContext extractionContext, TypeDeclarationSyntax typeDeclarationSyntax)
+    private static ExtractedContainerDefinition GetContainerDefinition(TypeDeclarationSyntax typeDeclarationSyntax)
     {
       StringBuilder containerDefinitionBuilder = new StringBuilder();
       ExtractedContainerDefinition containerDefinition;
@@ -69,7 +69,7 @@ private static ExtractedContainerDefinition GetContainerDefinition(DefinitionExt
       return containerDefinition;
     }
 
-    private static ExtractedContainerDefinition GetContainerDefinition(DefinitionExtractionContext extractionContext, NamespaceDeclarationSyntax namespaceDeclarationSyntax)
+    private static ExtractedContainerDefinition GetContainerDefinition(NamespaceDeclarationSyntax namespaceDeclarationSyntax)
     {
       StringBuilder containerDefinitionBuilder = new StringBuilder();
       ExtractedContainerDefinition containerDefinition;

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/FieldDefinitionExtractor.cs

@@ -28,12 +28,12 @@ public static ExtractedFieldDefinition ExtractFieldDefinition(DefinitionExtracti
     {
       ExtractedFieldDefinition fieldDefinition = new ExtractedFieldDefinition();
 
-      fieldDefinition.FieldName = GetFieldName(extractionContext, fieldDeclaration);
-      fieldDefinition.TypeDefinition.TypeName = GetFieldTypeName(extractionContext, fieldDeclaration);
+      fieldDefinition.FieldName = GetFieldName(fieldDeclaration);
+      fieldDefinition.TypeDefinition.TypeName = GetFieldTypeName(fieldDeclaration);
       fieldDefinition.TypeDefinition.TypeNamespace = extractionContext.GetTypeNamespace(fieldDeclaration.Declaration.Type);
       fieldDefinition.TypeDefinition.IsAutoSerializable = extractionContext.IsTypeAutoSerializable(fieldDeclaration.Declaration.Type);
       fieldDefinition.TypeDefinition.ImplementsIMobileObject = extractionContext.DoesTypeImplementIMobileObject(fieldDeclaration.Declaration.Type);
-      fieldDefinition.TypeDefinition.Nullable = GetFieldTypeNullable(extractionContext, fieldDeclaration);
+      fieldDefinition.TypeDefinition.Nullable = GetFieldTypeNullable(fieldDeclaration);
       return fieldDefinition;
     }
 
@@ -42,10 +42,9 @@ public static ExtractedFieldDefinition ExtractFieldDefinition(DefinitionExtracti
     /// <summary>
     /// Determines whether the field type is nullable.
     /// </summary>
-    /// <param name="extractionContext">The definition extraction context in which the extraction is being performed.</param>
     /// <param name="fieldDeclaration">The FieldDeclarationSyntax representing the field declaration.</param>
     /// <returns><c>true</c> if the field type is nullable; otherwise, <c>false</c>.</returns>
-    private static bool GetFieldTypeNullable(DefinitionExtractionContext extractionContext, FieldDeclarationSyntax fieldDeclaration)
+    private static bool GetFieldTypeNullable(FieldDeclarationSyntax fieldDeclaration)
     {
       return fieldDeclaration.Declaration.Type is NullableTypeSyntax;
     }
@@ -54,21 +53,19 @@ private static bool GetFieldTypeNullable(DefinitionExtractionContext extractionC
     /// <summary>
     /// Extract the name of the field for which we are building information
     /// </summary>
-    /// <param name="extractionContext">The definition extraction context in which the extraction is being performed</param>
     /// <param name="fieldDeclaration">The FieldDeclarationSyntax from which to extract the necessary information</param>
     /// <returns>The name of the field for which we are extracting information</returns>
-    private static string GetFieldName(DefinitionExtractionContext extractionContext, FieldDeclarationSyntax fieldDeclaration)
+    private static string GetFieldName(FieldDeclarationSyntax fieldDeclaration)
     {
       return fieldDeclaration.Declaration.Variables[0].Identifier.ToString();
     }
 
     /// <summary>
     /// Extract the type name of the field for which we are building information
     /// </summary>
-    /// <param name="extractionContext">The definition extraction context in which the extraction is being performed</param>
     /// <param name="fieldDeclaration">The FieldDeclarationSyntax from which to extract the necessary information</param>
     /// <returns>The type name of the field for which we are extracting information</returns>
-    private static string GetFieldTypeName(DefinitionExtractionContext extractionContext, FieldDeclarationSyntax fieldDeclaration)
+    private static string GetFieldTypeName(FieldDeclarationSyntax fieldDeclaration)
     {
       return fieldDeclaration.Declaration.Type.ToString();
     }

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/FieldDefinitionsExtractor.cs

@@ -77,7 +77,7 @@ private static List<FieldDeclarationSyntax> GetPublicNonExcludedFields(Definitio
       // Get all fields that are not specifically opted out with the [AutoNonSerialized] attribute
       serializableFields = targetTypeDeclaration.Members.Where(
         m => m is FieldDeclarationSyntax fieldDeclaration &&
-        HasOneOfScopes(extractionContext, fieldDeclaration, "public") &&
+        HasOneOfScopes(fieldDeclaration, "public") &&
         !extractionContext.IsFieldDecoratedWithAutoNonSerialized(fieldDeclaration))
         .Cast<FieldDeclarationSyntax>()
         .ToList();
@@ -98,7 +98,7 @@ private static List<FieldDeclarationSyntax> GetNonPublicIncludedFields(Definitio
       // Get any private or protected fields that are opted in with the use of the [AutoSerialized] attribute
       serializableFields = targetTypeDeclaration.Members.Where(
         m => m is FieldDeclarationSyntax fieldDeclaration &&
-        !HasOneOfScopes(extractionContext, fieldDeclaration, "public") &&
+        !HasOneOfScopes(fieldDeclaration, "public") &&
         extractionContext.IsFieldDecoratedWithAutoSerialized(fieldDeclaration))
         .Cast<FieldDeclarationSyntax>()
         .ToList();
@@ -129,11 +129,10 @@ private static List<FieldDeclarationSyntax> GetAllIncludedFields(DefinitionExtra
     /// <summary>
     /// Determine if a field has one of the scopes requested by a caller
     /// </summary>
-    /// <param name="context">The definition extraction context for this extraction</param>
     /// <param name="fieldDeclaration">The declaration of the field being tested</param>
     /// <param name="scopes">The list of scopes in which the caller is interested</param>
     /// <returns>Boolean true if the field has one of the scopes requested by the caller, else false</returns>
-    private static bool HasOneOfScopes(DefinitionExtractionContext context, FieldDeclarationSyntax fieldDeclaration, params string[] scopes)
+    private static bool HasOneOfScopes(FieldDeclarationSyntax fieldDeclaration, params string[] scopes)
     {
       foreach (string scope in scopes)
       {

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/PropertyDefinitionExtractor.cs

@@ -28,46 +28,44 @@ public static ExtractedPropertyDefinition ExtractPropertyDefinition(DefinitionEx
     {
       ExtractedPropertyDefinition propertyDefinition = new ExtractedPropertyDefinition();
 
-      propertyDefinition.PropertyName = GetPropertyName(extractionContext, propertyDeclaration);
-      propertyDefinition.TypeDefinition.TypeName = GetPropertyTypeName(extractionContext, propertyDeclaration);
+      propertyDefinition.PropertyName = GetPropertyName(propertyDeclaration);
+      propertyDefinition.TypeDefinition.TypeName = GetPropertyTypeName(propertyDeclaration);
       propertyDefinition.TypeDefinition.TypeNamespace = extractionContext.GetTypeNamespace(propertyDeclaration.Type);
       propertyDefinition.TypeDefinition.IsAutoSerializable = extractionContext.IsTypeAutoSerializable(propertyDeclaration.Type);
       propertyDefinition.TypeDefinition.ImplementsIMobileObject = extractionContext.DoesTypeImplementIMobileObject(propertyDeclaration.Type);
-      propertyDefinition.TypeDefinition.Nullable = GetFieldTypeNullable(extractionContext, propertyDeclaration);
+      propertyDefinition.TypeDefinition.Nullable = GetFieldTypeNullable(propertyDeclaration);
 
       return propertyDefinition;
     }
 
     #region Private Helper Methods
+
     /// <summary>
     /// Determines whether the field type is nullable.
     /// </summary>
-    /// <param name="extractionContext">The definition extraction context in which the extraction is being performed.</param>
     /// <param name="propertyDeclaration">The PropertyDeclarationSyntax representing the field declaration.</param>
     /// <returns><c>true</c> if the field type is nullable; otherwise, <c>false</c>.</returns>
-    private static bool GetFieldTypeNullable(DefinitionExtractionContext extractionContext, PropertyDeclarationSyntax propertyDeclaration)
+    private static bool GetFieldTypeNullable(PropertyDeclarationSyntax propertyDeclaration)
     {
       return propertyDeclaration.Type is NullableTypeSyntax;
     }
 
     /// <summary>
     /// Extract the name of the property for which we are building information
     /// </summary>
-    /// <param name="extractionContext">The definition extraction context in which the extraction is being performed</param>
     /// <param name="propertyDeclaration">The PropertyDeclarationSyntax from which to extract the necessary information</param>
     /// <returns>The name of the property for which we are extracting information</returns>
-    private static string GetPropertyName(DefinitionExtractionContext extractionContext, PropertyDeclarationSyntax propertyDeclaration)
+    private static string GetPropertyName(PropertyDeclarationSyntax propertyDeclaration)
     {
       return propertyDeclaration.Identifier.ValueText;
     }
 
     /// <summary>
     /// Extract the type name of the property for which we are building information
     /// </summary>
-    /// <param name="extractionContext">The definition extraction context in which the extraction is being performed</param>
     /// <param name="propertyDeclaration">The PropertyDeclarationSyntax from which to extract the necessary information</param>
     /// <returns>The type name of the property for which we are extracting information</returns>
-    private static string GetPropertyTypeName(DefinitionExtractionContext extractionContext, PropertyDeclarationSyntax propertyDeclaration)
+    private static string GetPropertyTypeName(PropertyDeclarationSyntax propertyDeclaration)
     {
       return propertyDeclaration.Type.ToString();
     }

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/PropertyDefinitionsExtractor.cs

@@ -75,8 +75,8 @@ private static List<PropertyDeclarationSyntax> GetPublicNonExcludedProperties(De
       // Get public or internal properties that are not specifically opted out with the [AutoNonSerialized] attribute
       serializableProperties = targetTypeDeclaration.Members.Where(
         m => m is PropertyDeclarationSyntax propertyDeclaration &&
-        HasOneOfScopes(extractionContext, propertyDeclaration, "public") &&
-        HasGetterAndSetter(extractionContext, propertyDeclaration) &&
+        HasOneOfScopes(propertyDeclaration, "public") &&
+        HasGetterAndSetter(propertyDeclaration) &&
         !extractionContext.IsPropertyDecoratedWithAutoNonSerialized(propertyDeclaration))
         .Cast<PropertyDeclarationSyntax>()
         .ToList();
@@ -97,8 +97,8 @@ private static List<PropertyDeclarationSyntax> GetNonPublicIncludedProperties(De
       // Get private or protected properties that are specifically opted in with the [AutoSerialized] attribute
       serializableProperties = targetTypeDeclaration.Members.Where(
         m => m is PropertyDeclarationSyntax propertyDeclaration &&
-        !HasOneOfScopes(extractionContext, propertyDeclaration, "public") &&
-        HasGetterAndSetter(extractionContext, propertyDeclaration) &&
+        !HasOneOfScopes(propertyDeclaration, "public") &&
+        HasGetterAndSetter(propertyDeclaration) &&
         extractionContext.IsPropertyDecoratedWithAutoSerialized(propertyDeclaration))
         .Cast<PropertyDeclarationSyntax>()
         .ToList();
@@ -109,11 +109,10 @@ private static List<PropertyDeclarationSyntax> GetNonPublicIncludedProperties(De
     /// <summary>
     /// Determine if a property has one of the scopes requested by a caller
     /// </summary>
-    /// <param name="context">The definition extraction context for this extraction</param>
     /// <param name="propertyDeclaration">The declaration of the property being tested</param>
     /// <param name="scopes">The list of scopes in which the caller is interested</param>
     /// <returns>Boolean true if the property has one of the scopes requested by the caller, else false</returns>
-    private static bool HasOneOfScopes(DefinitionExtractionContext context, PropertyDeclarationSyntax propertyDeclaration, params string[] scopes)
+    private static bool HasOneOfScopes(PropertyDeclarationSyntax propertyDeclaration, params string[] scopes)
     {
       foreach (string scope in scopes)
       {
@@ -129,10 +128,9 @@ private static bool HasOneOfScopes(DefinitionExtractionContext context, Property
     /// <summary>
     /// Determine if a property has both a getter and a setter
     /// </summary>
-    /// <param name="context">The definition extraction context for this extraction</param>
     /// <param name="propertyDeclaration">The declaration of the property being tested</param>
     /// <returns>Boolean true if the property has both a getter and setter (of any scope), else false</returns>
-    private static bool HasGetterAndSetter(DefinitionExtractionContext context, PropertyDeclarationSyntax propertyDeclaration)
+    private static bool HasGetterAndSetter(PropertyDeclarationSyntax propertyDeclaration)
     {
       bool hasGetter = false;
       bool hasSetter = false;

Source/Csla.Generators/cs/AutoSerialization/Csla.Generator.AutoSerialization.CSharp/AutoSerializable/Discovery/TypeDefinitionExtractor.cs

@@ -30,10 +30,10 @@ public static ExtractedTypeDefinition ExtractTypeDefinition(DefinitionExtraction
       ExtractedTypeDefinition definition = new ExtractedTypeDefinition();
       StringBuilder fullyQualifiedNameBuilder = new StringBuilder();
 
-      definition.TypeName = GetTypeName(extractionContext, targetTypeDeclaration);
-      definition.TypeKind = GetTypeKind(extractionContext, targetTypeDeclaration);
-      definition.Namespace = GetNamespace(extractionContext, targetTypeDeclaration);
-      definition.Scope = GetScopeDefinition(extractionContext, targetTypeDeclaration);
+      definition.TypeName = GetTypeName(targetTypeDeclaration);
+      definition.TypeKind = GetTypeKind(targetTypeDeclaration);
+      definition.Namespace = GetNamespace(targetTypeDeclaration);
+      definition.Scope = GetScopeDefinition(targetTypeDeclaration);
 
       foreach (ExtractedContainerDefinition containerDefinition in ContainerDefinitionsExtractor.GetContainerDefinitions(extractionContext, targetTypeDeclaration))
       {
@@ -63,10 +63,9 @@ public static ExtractedTypeDefinition ExtractTypeDefinition(DefinitionExtraction
     /// <summary>
     /// Extract the namespace of the type for which we will be generating code
     /// </summary>
-    /// <param name="extractionContext">The definition extraction context in which the extraction is being performed</param>
     /// <param name="targetTypeDeclaration">The TypeDeclarationSyntax from which to extract the necessary information</param>
     /// <returns>The namespace of the type for which generation is being performed</returns>
-    private static string GetNamespace(DefinitionExtractionContext extractionContext, TypeDeclarationSyntax targetTypeDeclaration)
+    private static string GetNamespace(TypeDeclarationSyntax targetTypeDeclaration)
     {
       // If we don't have a namespace at all we'll return an empty string
       // This accounts for the "default namespace" case
@@ -113,10 +112,9 @@ potentialNamespaceParent is not NamespaceDeclarationSyntax
     /// <summary>
     /// Extract the scope of the type for which we will be generating code
     /// </summary>
-    /// <param name="extractionContext">The definition extraction context in which the extraction is being performed</param>
     /// <param name="targetTypeDeclaration">The TypeDeclarationSyntax from which to extract the necessary information</param>
     /// <returns>The scope of the type for which generation is being performed</returns>
-    private static string GetScopeDefinition(DefinitionExtractionContext extractionContext, TypeDeclarationSyntax targetTypeDeclaration)
+    private static string GetScopeDefinition(TypeDeclarationSyntax targetTypeDeclaration)
     {
       StringBuilder scopeNameBuilder = new StringBuilder();
 
@@ -166,21 +164,19 @@ private static void AppendScopeName(StringBuilder stringBuilder, string scope)
     /// <summary>
     /// Extract the name of the type for which we will be generating code
     /// </summary>
-    /// <param name="extractionContext">The definition extraction context in which the extraction is being performed</param>
     /// <param name="targetTypeDeclaration">The TypeDeclarationSyntax from which to extract the necessary information</param>
     /// <returns>The name of the type for which generation is being performed</returns>
-    private static string GetTypeName(DefinitionExtractionContext extractionContext, TypeDeclarationSyntax targetTypeDeclaration)
+    private static string GetTypeName(TypeDeclarationSyntax targetTypeDeclaration)
     {
       return targetTypeDeclaration.Identifier.ToString();
     }
 
     /// <summary>
     /// Extract the textual definition of the kind that this type represents
     /// </summary>
-    /// <param name="extractionContext">The definition extraction context in which the extraction is being performed</param>
     /// <param name="targetTypeDeclaration">The TypeDeclarationSyntax from which to extract the necessary information</param>
     /// <returns>The kind of the type for which generation is being performed</returns>
-    private static string GetTypeKind(DefinitionExtractionContext extractionContext, TypeDeclarationSyntax targetTypeDeclaration)
+    private static string GetTypeKind(TypeDeclarationSyntax targetTypeDeclaration)
     {
       return targetTypeDeclaration.Keyword.ToString();
     }