Skip to content

Commit 52ac1a1

Browse files
BlaiseDBlaiseD
authored
Removing unused code (#190)
1 parent ef7eef1 commit 52ac1a1

File tree

63 files changed

+3215
-1575
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

63 files changed

+3215
-1575
lines changed

‎src/AutoMapper.Extensions.ExpressionMapping/AnonymousTypeFactory.cs‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,9 @@
33
using System.Linq;
44
using System.Reflection;
55
using System.Reflection.Emit;
6+
using System.Runtime.CompilerServices;
7+
8+
[assembly: InternalsVisibleTo("AutoMapper.Extensions.ExpressionMapping.UnitTests, PublicKey=002400000480000094000000060200000024000052534131000400000100010079dfef85ed6ba841717e154f13182c0a6029a40794a6ecd2886c7dc38825f6a4c05b0622723a01cd080f9879126708eef58f134accdc99627947425960ac2397162067507e3c627992aa6b92656ad3380999b30b5d5645ba46cc3fcc6a1de5de7afebcf896c65fb4f9547a6c0c6433045fceccb1fa15e960d519d0cd694b29a4")]
69

710
namespace AutoMapper.Extensions.ExpressionMapping
811
{
@@ -15,7 +18,7 @@ public static Type CreateAnonymousType(IEnumerable<MemberInfo> memberDetails)
1518

1619
public static Type CreateAnonymousType(IDictionary<string, Type> memberDetails)
1720
{
18-
AssemblyName dynamicAssemblyName = new AssemblyName("TempAssembly.AutoMapper.Extensions.ExpressionMapping");
21+
AssemblyName dynamicAssemblyName = new("TempAssembly.AutoMapper.Extensions.ExpressionMapping");
1922
AssemblyBuilder dynamicAssembly = AssemblyBuilder.DefineDynamicAssembly(dynamicAssemblyName, AssemblyBuilderAccess.Run);
2023
ModuleBuilder dynamicModule = dynamicAssembly.DefineDynamicModule("TempAssembly.AutoMapper.Extensions.ExpressionMapping");
2124
TypeBuilder typeBuilder = dynamicModule.DefineType(GetAnonymousTypeName(), TypeAttributes.Public);
@@ -32,7 +35,7 @@ public static Type CreateAnonymousType(IDictionary<string, Type> memberDetails)
3235
FieldBuilder = typeBuilder.DefineField(string.Concat("_", memberName), memberType, FieldAttributes.Private),
3336
PropertyBuilder = typeBuilder.DefineProperty(memberName, PropertyAttributes.HasDefault, memberType, null),
3437
GetMethodBuilder = typeBuilder.DefineMethod(string.Concat("get_", memberName), getSetAttr, memberType, Type.EmptyTypes),
35-
SetMethodBuilder = typeBuilder.DefineMethod(string.Concat("set_", memberName), getSetAttr, null, new Type[] { memberType })
38+
SetMethodBuilder = typeBuilder.DefineMethod(string.Concat("set_", memberName), getSetAttr, null, [memberType])
3639
};
3740
}
3841
);

‎src/AutoMapper.Extensions.ExpressionMapping/ConfigurationExtensions.cs‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,4 @@
11
using AutoMapper.Internal;
2-
using AutoMapper.Mappers;
32

43
namespace AutoMapper.Extensions.ExpressionMapping
54
{

‎src/AutoMapper.Extensions.ExpressionMapping/ElementTypeHelper.cs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ public static Type[] GetElementTypes(Type enumerableType, System.Collections.IEn
1818
{
1919
if (enumerableType.HasElementType)
2020
{
21-
return new[] { enumerableType.GetElementType() };
21+
return [enumerableType.GetElementType()];
2222
}
2323

2424
var iDictionaryType = enumerableType.GetDictionaryType();
@@ -43,7 +43,7 @@ public static Type[] GetElementTypes(Type enumerableType, System.Collections.IEn
4343
{
4444
var first = enumerable?.Cast<object>().FirstOrDefault();
4545

46-
return new[] { first?.GetType() ?? typeof(object) };
46+
return [first?.GetType() ?? typeof(object)];
4747
}
4848

4949
throw new ArgumentException($"Unable to find the element type for type '{enumerableType}'.",

‎src/AutoMapper.Extensions.ExpressionMapping/ExpressionExtensions.cs‎

Lines changed: 1 addition & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -5,39 +5,14 @@
55
using System.Reflection;
66
using AutoMapper.Internal;
77

8-
namespace AutoMapper
8+
namespace AutoMapper.Extensions.ExpressionMapping
99
{
10-
using AutoMapper.Extensions.ExpressionMapping;
1110
using static Expression;
1211

1312
internal static class ExpressionExtensions
1413
{
1514
public static Expression MemberAccesses(this IEnumerable<MemberInfo> members, Expression obj) =>
1615
members.Aggregate(obj, (expression, member) => MakeMemberAccess(expression, member));
17-
18-
public static IEnumerable<MemberExpression> GetMembers(this Expression expression)
19-
{
20-
var memberExpression = expression as MemberExpression;
21-
if(memberExpression == null)
22-
{
23-
return new MemberExpression[0];
24-
}
25-
return memberExpression.GetMembers();
26-
}
27-
28-
public static IEnumerable<MemberExpression> GetMembers(this MemberExpression expression)
29-
{
30-
while(expression != null)
31-
{
32-
yield return expression;
33-
expression = expression.Expression as MemberExpression;
34-
}
35-
}
36-
37-
public static bool IsMemberPath(this LambdaExpression exp)
38-
{
39-
return exp.Body.GetMembers().LastOrDefault()?.Expression == exp.Parameters.First();
40-
}
4116
}
4217

4318
internal static class ExpressionHelpers

‎src/AutoMapper.Extensions.ExpressionMapping/ExpressionMapper.cs‎

Lines changed: 28 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,14 @@
1-
using System;
1+
using AutoMapper.Internal;
2+
using AutoMapper.Internal.Mappers;
3+
using System;
24
using System.Collections.Generic;
5+
using System.Diagnostics.CodeAnalysis;
36
using System.Linq;
47
using System.Linq.Expressions;
58
using System.Reflection;
6-
using AutoMapper.Extensions.ExpressionMapping;
7-
using AutoMapper.Internal;
8-
using AutoMapper.Internal.Mappers;
99
using static System.Linq.Expressions.Expression;
1010

11-
namespace AutoMapper.Mappers
11+
namespace AutoMapper.Extensions.ExpressionMapping
1212
{
1313
public class ExpressionMapper : IObjectMapper
1414
{
@@ -23,7 +23,7 @@ public bool IsMatch(TypePair context) => typeof(LambdaExpression).IsAssignableFr
2323
&& typeof(LambdaExpression).IsAssignableFrom(context.DestinationType)
2424
&& context.DestinationType != typeof(LambdaExpression);
2525

26-
public Expression MapExpression(IGlobalConfiguration configurationProvider, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression)
26+
public Expression MapExpression(IGlobalConfiguration configurationProvider, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression)
2727
=> Call
2828
(
2929
null,
@@ -37,9 +37,10 @@ public Expression MapExpression(IGlobalConfiguration configurationProvider, Prof
3737
return null;
3838
}
3939

40+
[ExcludeFromCodeCoverage]
4041
internal class MappingVisitor : ExpressionVisitor
4142
{
42-
private IList<Type> _destSubTypes = new Type[0];
43+
private IList<Type> _destSubTypes = [];
4344

4445
private readonly IConfigurationProvider _configurationProvider;
4546
private readonly TypeMap _typeMap;
@@ -81,7 +82,7 @@ private MethodCallExpression GetConvertedMethodCall(MethodCallExpression node)
8182
return Call(convertedMethodCall, convertedArguments);
8283
}
8384

84-
private static Type GetConvertingTypeIfExists(IList<Expression> args, Type t, IList<Expression> arguments)
85+
private static Type GetConvertingTypeIfExists(System.Collections.ObjectModel.ReadOnlyCollection<Expression> args, Type t, IList<Expression> arguments)
8586
{
8687
var matchingArgument = args.Where(a => !a.Type.IsGenericType()).FirstOrDefault(a => a.Type == t);
8788
if (matchingArgument != null)
@@ -109,7 +110,7 @@ protected override Expression VisitBinary(BinaryExpression node)
109110
CheckNullableToNonNullableChanges(node.Left, node.Right, ref newLeft, ref newRight);
110111
CheckNullableToNonNullableChanges(node.Right, node.Left, ref newRight, ref newLeft);
111112
return MakeBinary(node.NodeType, newLeft, newRight);
112-
bool IsNullConstant(Expression expression) => expression is ConstantExpression constant && constant.Value == null;
113+
static bool IsNullConstant(Expression expression) => expression is ConstantExpression constant && constant.Value == null;
113114
}
114115

115116
private static void CheckNullableToNonNullableChanges(Expression left, Expression right, ref Expression newLeft, ref Expression newRight)
@@ -145,30 +146,30 @@ private static void UpdateToNonNullableExpression(Expression right, out Expressi
145146
: right.Type;
146147
newRight = Constant(expression.Value, t);
147148
}
148-
else if (right is UnaryExpression)
149-
newRight = ((UnaryExpression) right).Operand;
149+
else if (right is UnaryExpression unaryExpression)
150+
newRight = unaryExpression.Operand;
150151
else
151152
throw new AutoMapperMappingException(
152153
"Mapping a BinaryExpression where one side is nullable and the other isn't");
153154
}
154155

155-
private static bool GoingFromNonNullableToNullable(Expression node, Expression newLeft)
156+
private static bool GoingFromNonNullableToNullable(Expression node, Expression newLeft)
156157
=> !node.Type.IsNullableType() && newLeft.Type.IsNullableType();
157158

158-
private static bool BothAreNullable(Expression node, Expression newLeft)
159+
private static bool BothAreNullable(Expression node, Expression newLeft)
159160
=> node.Type.IsNullableType() && newLeft.Type.IsNullableType();
160161

161-
private static bool BothAreNonNullable(Expression node, Expression newLeft)
162+
private static bool BothAreNonNullable(Expression node, Expression newLeft)
162163
=> !node.Type.IsNullableType() && !newLeft.Type.IsNullableType();
163164

164165
protected override Expression VisitLambda<T>(Expression<T> node)
165166
{
166-
return node.Parameters.Any(b => b.Type == _oldParam.Type)
167-
? VisitLambdaExpression(node)
167+
return node.Parameters.Any(b => b.Type == _oldParam.Type)
168+
? VisitLambdaExpression(node)
168169
: VisitAllParametersExpression(node);
169170
}
170171

171-
private Expression VisitLambdaExpression<T>(Expression<T> expression)
172+
private LambdaExpression VisitLambdaExpression<T>(Expression<T> expression)
172173
{
173174
var convertedBody = Visit(expression.Body);
174175
var convertedArguments = expression.Parameters.Select(e => Visit(e) as ParameterExpression).ToList();
@@ -226,6 +227,7 @@ protected override Expression VisitMember(MemberExpression node)
226227
.Aggregate(replacedExpression, getExpression);
227228
}
228229

230+
[ExcludeFromCodeCoverage]
229231
private class IsConstantExpressionVisitor : ExpressionVisitor
230232
{
231233
public bool IsConstant { get; private set; }
@@ -251,22 +253,22 @@ private Expression GetConvertedSubMemberCall(MemberExpression node)
251253
var typeMap = _configurationProvider.Internal().ResolveTypeMap(sourceType, destType);
252254
var subVisitor = new MappingVisitor(_configurationProvider, typeMap, node.Expression, baseExpression, this);
253255
var newExpression = subVisitor.Visit(node);
254-
_destSubTypes = _destSubTypes.Concat(subVisitor._destSubTypes).ToArray();
256+
_destSubTypes = [.. _destSubTypes, .. subVisitor._destSubTypes];
255257
return newExpression;
256258
}
257259

258-
private Type GetSourceType(PropertyMap propertyMap) =>
260+
private static Type GetSourceType(PropertyMap propertyMap) =>
259261
propertyMap.SourceType ??
260262
throw new AutoMapperMappingException(
261-
"Could not determine source property type. Make sure the property is mapped.",
262-
null,
263+
"Could not determine source property type. Make sure the property is mapped.",
264+
null,
263265
propertyMap);
264266

265267
private PropertyMap FindPropertyMapOfExpression(MemberExpression expression)
266268
{
267269
var propertyMap = PropertyMap(expression);
268-
return propertyMap == null && expression.Expression is MemberExpression
269-
? FindPropertyMapOfExpression((MemberExpression) expression.Expression)
270+
return propertyMap == null && expression.Expression is MemberExpression memberExpression
271+
? FindPropertyMapOfExpression(memberExpression)
270272
: propertyMap;
271273
}
272274

@@ -277,9 +279,9 @@ private PropertyMap PropertyMap(MemberExpression node)
277279
? null
278280
: (!node.Member.DeclaringType.IsAssignableFrom(_typeMap.DestinationType)
279281
? null
280-
: GetExistingPropertyMapFor(node.Member, _typeMap)));
282+
: MappingVisitor.GetExistingPropertyMapFor(node.Member, _typeMap)));
281283

282-
private PropertyMap GetExistingPropertyMapFor(MemberInfo destinationProperty, TypeMap typeMap)
284+
private static PropertyMap GetExistingPropertyMapFor(MemberInfo destinationProperty, TypeMap typeMap)
283285
{
284286
if (!destinationProperty.DeclaringType.IsAssignableFrom(typeMap.DestinationType))
285287
return null;
@@ -290,7 +292,7 @@ private PropertyMap GetExistingPropertyMapFor(MemberInfo destinationProperty, Ty
290292
private void SetSourceSubTypes(PropertyMap propertyMap)
291293
{
292294
if (propertyMap.SourceMember is PropertyInfo info)
293-
_destSubTypes = info.PropertyType.GetTypeInfo().GenericTypeArguments.Concat(new[] { info.PropertyType }).ToList();
295+
_destSubTypes = [.. info.PropertyType.GetTypeInfo().GenericTypeArguments, info.PropertyType];
294296
else if (propertyMap.SourceMember is FieldInfo fInfo)
295297
_destSubTypes = fInfo.FieldType.GetTypeInfo().GenericTypeArguments;
296298
}

‎src/AutoMapper.Extensions.ExpressionMapping/Extensions/VisitorExtensions.cs‎

Lines changed: 12 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -11,37 +11,6 @@ namespace AutoMapper.Extensions.ExpressionMapping.Extensions
1111
{
1212
internal static class VisitorExtensions
1313
{
14-
/// <summary>
15-
/// Returns true if the expression is a direct or descendant member expression of the parameter.
16-
/// </summary>
17-
/// <param name="expression"></param>
18-
/// <returns></returns>
19-
public static bool IsMemberExpression(this Expression expression)
20-
{
21-
if (expression.NodeType == ExpressionType.MemberAccess)
22-
{
23-
var memberExpression = (MemberExpression)expression;
24-
return IsMemberOrParameterExpression(memberExpression.Expression);
25-
}
26-
27-
return false;
28-
}
29-
30-
private static bool IsMemberOrParameterExpression(Expression expression)
31-
{
32-
//the node represents parameter of the expression
33-
switch (expression.NodeType)
34-
{
35-
case ExpressionType.Parameter:
36-
return true;
37-
case ExpressionType.MemberAccess:
38-
var memberExpression = (MemberExpression)expression;
39-
return IsMemberOrParameterExpression(memberExpression.Expression);
40-
}
41-
42-
return false;
43-
}
44-
4514
/// <summary>
4615
/// Returns the fully qualified name of the member starting with the immediate child member of the parameter
4716
/// </summary>
@@ -70,15 +39,11 @@ public static string GetPropertyFullName(this Expression expression)
7039

7140
public static Expression GetUnconvertedExpression(this Expression expression)
7241
{
73-
switch (expression.NodeType)
42+
return expression.NodeType switch
7443
{
75-
case ExpressionType.Convert:
76-
case ExpressionType.ConvertChecked:
77-
case ExpressionType.TypeAs:
78-
return ((UnaryExpression)expression).Operand.GetUnconvertedExpression();
79-
default:
80-
return expression;
81-
}
44+
ExpressionType.Convert or ExpressionType.ConvertChecked or ExpressionType.TypeAs => ((UnaryExpression)expression).Operand.GetUnconvertedExpression(),
45+
_ => expression,
46+
};
8247
}
8348

8449
public static Expression ConvertTypeIfNecessary(this Expression expression, Type memberType)
@@ -136,9 +101,7 @@ public static ParameterExpression GetParameterExpression(this Expression express
136101
if (isExtension && parentExpression == null && methodExpression.Arguments.Count > 0)
137102
parentExpression = methodExpression.Arguments[0];//Method is an extension method based on the type of methodExpression.Arguments[0].
138103

139-
return isExtension && parentExpression == null && methodExpression.Arguments.Count > 0
140-
? GetParameterExpression(methodExpression.Arguments[0])
141-
: GetParameterExpression(parentExpression);
104+
return GetParameterExpression(parentExpression);
142105
}
143106

144107
return null;
@@ -177,33 +140,19 @@ public static string GetMemberFullName(this LambdaExpression expr)
177140
{
178141
if (expr.Body.NodeType == ExpressionType.Parameter)
179142
return string.Empty;
180-
181-
MemberExpression me;
182-
switch (expr.Body.NodeType)
143+
MemberExpression me = expr.Body.NodeType switch
183144
{
184-
case ExpressionType.Convert:
185-
case ExpressionType.ConvertChecked:
186-
case ExpressionType.TypeAs:
187-
me = expr.Body.GetUnconvertedExpression() as MemberExpression;
188-
break;
189-
default:
190-
me = expr.Body as MemberExpression;
191-
break;
192-
}
193-
145+
ExpressionType.Convert or ExpressionType.ConvertChecked or ExpressionType.TypeAs => expr.Body.GetUnconvertedExpression() as MemberExpression,
146+
_ => expr.Body as MemberExpression,
147+
};
194148
return me.GetPropertyFullName();
195149
}
196150

197151
/// <summary>
198-
/// Returns the underlying type typeof(T) when the type implements IEnumerable.
152+
/// Determines whether the specified type is an enumeration type.
199153
/// </summary>
200-
/// <param name="type"></param>
201-
/// <returns></returns>
202-
public static List<Type> GetUnderlyingGenericTypes(this Type type) =>
203-
type == null || !type.GetTypeInfo().IsGenericType
204-
? new List<Type>()
205-
: type.GetGenericArguments().ToList();
206-
154+
/// <param name="type">The type to evaluate. This can be a nullable type, in which case the underlying type is checked.</param>
155+
/// <returns>true if the specified type is an enumeration; otherwise, false.</returns>
207156
public static bool IsEnumType(this Type type)
208157
{
209158
if (type.IsNullableType())

0 commit comments

Comments
 (0)