private static Expression CreateDestinationFunc(
TypeMap typeMap,
TypeMapRegistry typeMapRegistry,
ParameterExpression srcParam,
ParameterExpression destParam,
ParameterExpression ctxtParam)
{
var newDestFunc = ToType(CreateNewDestinationFunc(typeMap, typeMapRegistry, srcParam, ctxtParam),
typeMap.DestinationTypeToUse);
var getDest = typeMap.DestinationTypeToUse.GetTypeInfo().IsValueType
? newDestFunc
: Coalesce(destParam, newDestFunc);
Expression destinationFunc = Assign(destParam, getDest);
if (typeMap.PreserveReferences)
{
var dest = Variable(typeof (object), "dest");
Expression valueBag = Property(ctxtParam, "InstanceCache");
var set = Assign(Property(valueBag, "Item", srcParam), dest);
var setCache =
IfThen(NotEqual(srcParam, Constant(null)), set);
destinationFunc = Block(new[] {dest}, Assign(dest, destinationFunc), setCache, dest);
}
return destinationFunc;
}
protected override void Establish_context()
{
_configuration = new Configuration(new TypeMapFactory(), MapperRegistry.AllMappers());
_configuration.CreateMap<Source, Destination>();
_expected = _configuration.FindTypeMapFor(null, typeof(Source), typeof(Destination));
}
public IModelSQLEmit CreateModelSQLEmit(IObjectMapInfoCache cache)
{
ITypeMap tm = new TypeMap();
ISQLTranslator tr = new SQLTranslator();
IModelColumnsBuilder cb = new ModelColumnsBuilder(tr, tm);
return new ModelSQLEmit(cache, tr, tm, cb);
}
private static MemberAssignment BindCustomProjectionExpression(PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionResolutionResult result)
{
var visitor = new ParameterReplacementVisitor(result.ResolutionExpression);
var replaced = visitor.Visit(propertyTypeMap.CustomProjection.Body);
return Expression.Bind(propertyMap.DestinationProperty.MemberInfo, replaced);
}
public override void MapByType( Type t, TypeMap otm )
{
this.Context = otm;
XmlDocument document = new XmlDocument();
document.Load( this.MappingDocument );
XmlNode node = document.SelectSingleNode( String.Format( "//type-map[@type={0}]", t.Name ) );
otm.Table = node.Attributes["table"].InnerText;
}
public void First()
{
var map = new TypeMap();
ushort id;
Assert.IsTrue (map.GetTypeId (typeof (string), out id));
Assert.AreEqual (0, id);
}
public static NamedTypeSymbol Construct(this NamedTypeSymbol type, params TypeSymbol[] arguments)
{
Debug.Assert(type != null);
Debug.Assert(arguments != null);
TypeMap map = new TypeMap(ReadOnlyArray<TypeSymbol>.CreateFrom(type.ConstructedFrom.TypeParameters),
arguments.AsReadOnly());
return map.SubstituteNamedType(type.ConstructedFrom);
}
public void Configure(TypeMap typeMap)
{
var sourcePropertyConfig = typeMap.FindOrCreateSourceMemberConfigFor(_sourceMember);
foreach (var action in _sourceMemberActions)
{
action(sourcePropertyConfig);
}
}
public SPParameterConfig(SPParameter parameter, TypeMap map)
{
Definition = parameter;
FriendlyName = NamingHelpers.SplitObjectName(Definition.Name);
IsRequired = Definition.DefaultValue == null;
Type= map.GetCodeType(Definition.TypeInfo.TypeName);
SampleValue = Definition.DefaultValue as String;
Enabled = true;
}
public void When_creating_a_new_context_from_an_existing_context_Should_preserve_context_type_map()
{
var map = new TypeMap(new TypeInfo(typeof(int)), new TypeInfo(typeof(string)), MemberList.Destination);
var context = new ResolutionContext(map, 5, typeof(int), typeof(string), new MappingOperationOptions());
ResolutionContext newContext = context.CreateValueContext(10);
newContext.GetContextTypeMap().ShouldNotBeNull();
}
internal SPConfig(SPInfo definition, ISPLoader loader, TypeMap typeMap)
{
_core = definition;
_loader = loader;
_typeMap = typeMap;
//Defaults:
FriendlyName = NamingHelpers.SplitObjectName(definition.Name);
Enabled = true;
}
public TypeMapPlanBuilder(IConfigurationProvider configurationProvider, TypeMapRegistry typeMapRegistry, TypeMap typeMap)
{
_configurationProvider = configurationProvider;
_typeMapRegistry = typeMapRegistry;
_typeMap = typeMap;
_source = Parameter(typeMap.SourceType, "src");
_initialDestination = Parameter(typeMap.DestinationTypeToUse, "dest");
_context = Parameter(typeof(ResolutionContext), "ctxt");
_destination = Variable(_initialDestination.Type, "typeMapDestination");
}
public void ToString_Always_Succeeds()
{
//Arrange
var typeMap = new TypeMap(typeof(string), typeof(int));
//Act
string actual = typeMap.ToString();
//Assert
Assert.AreEqual<string>(string.Format("{{{0}, {1}}}", typeof(string), typeof(int)), actual);
}
public void Add_GoodValues_Succeeds()
{
//Arrange
var typeMapCollection = new TypeMapCollection();
var typeMap = new TypeMap(typeof(Type), typeof(Type));
//Act
typeMapCollection.Add(typeMap);
//Assert
Assert.AreEqual<TypeMapBase>(typeMap, typeMapCollection.Get(typeof(Type), typeof(Type)));
}
public void CtorTypeMap()
{
var map = new TypeMap();
ushort id;
map.GetTypeId (typeof (string), out id);
map.GetTypeId (typeof (int), out id);
var c = new MockClientConnection (new MockConnectionProvider (MockProtocol.Instance));
var context = new SerializationContext (c, MockProtocol.Instance, map);
Assert.AreSame (map, context.TypeMap);
}
internal static bool HaveSameParameterTypes(ReadOnlyArray<ParameterSymbol> params1, TypeMap typeMap1, ReadOnlyArray<ParameterSymbol> params2, TypeMap typeMap2, bool considerRefOutDifference, bool considerCustomModifiers)
{
Contract.ThrowIfNotEquals(params1.Count, params2.Count);
var numParams = params1.Count;
for (int i = 0; i < numParams; i++)
{
var param1 = params1[i];
var param2 = params2[i];
var type1 = SubstituteType(typeMap1, param1.Type);
var type2 = SubstituteType(typeMap2, param2.Type);
//the runtime compares custom modifiers using (effectively) SequenceEqual
if (considerCustomModifiers)
{
if (!type1.IsSameType(type2, ignoreDynamic: true) || !param1.CustomModifiers.SequenceEqual(param2.CustomModifiers))
{
return false;
}
}
else if (!type1.IsSameType(type2, ignoreCustomModifiers: true, ignoreDynamic: true))
{
return false;
}
var refKind1 = param1.RefKind;
var refKind2 = param2.RefKind;
// Metadata signatures don't distinguish ref/out, but C# does - even when comparing metadata method signatures.
if (considerRefOutDifference)
{
if (refKind1 != refKind2)
{
return false;
}
}
else
{
if ((refKind1 == RefKind.None) != (refKind2 == RefKind.None))
{
return false;
}
}
}
return true;
}
public void TestSerializationAndDeserialization()
{
var map = new TypeMap();
map.Entries.Add(new TypeInfo());
map.Entries.Add(new TypeInfo());
map.Source = "Test Source";
var f = Path.GetTempFileName();
map.Save(f);
var map2 = TypeMap.Load(f);
Assert.IsNotNull(map2);
Assert.IsTrue(map.Source == map2.Source);
Assert.IsTrue(map.Entries.Count == map2.Entries.Count());
}
public void Get_GoodValues_ReturnsTypeMap()
{
//Arrange
var typeMapCollection = new TypeMapCollection();
var typeMap = new TypeMap(typeof(Type), typeof(Type));
typeMapCollection.Add(typeMap);
//Act
var actual = typeMapCollection.Get(typeof(Type), typeof(Type));
var value = typeMapCollection.Get(typeof(Type), typeof(string));
//Assert
Assert.AreEqual<TypeMapBase>(typeMap, actual);
Assert.IsNull(value);
}
public void Multiple()
{
var map = new TypeMap();
ushort id, id2;
Assert.IsTrue (map.GetTypeId (typeof (string), out id));
Assert.AreEqual (0, id);
Assert.IsFalse (map.GetTypeId (typeof (string), out id2));
Assert.AreEqual (id, id2);
Assert.IsTrue (map.GetTypeId (typeof (int), out id));
Assert.AreNotEqual (id2, id);
Assert.IsFalse (map.GetTypeId (typeof (int), out id2));
Assert.AreEqual (id, id2);
}
public void Ctor()
{
var dict = new Dictionary<Type, ushort> { { typeof (string), 0 }, { typeof (int), 1 } };
TypeMap map = null;
Assert.DoesNotThrow (() => map = new TypeMap (dict));
Type type;
Assert.IsTrue (map.TryGetType (0, out type));
Assert.AreEqual (typeof (string), type);
Assert.IsTrue (map.TryGetType (1, out type));
Assert.AreEqual (typeof (int), type);
ushort id;
Assert.IsFalse (map.GetTypeId (typeof (string), out id));
Assert.AreEqual (0, id);
Assert.IsFalse (map.GetTypeId (typeof (int), out id));
Assert.AreEqual (1, id);
}
public static ConditionalExpression CheckContext(TypeMap typeMap, Expression context)
{
if(typeMap.MaxDepth > 0 || typeMap.PreserveReferences)
{
var mapper = Property(context, "Mapper");
return IfThen(Property(context, "IsDefault"), Assign(context, Invoke(CreateContext, mapper)));
}
return null;
}
static PubSubTests()
{
TypeMap.AddType <TestEvent>("test-event");
}
internal static TypeSymbol SubstituteType(TypeMap typeMap, TypeSymbol typeSymbol)
{
return typeMap == null ? typeSymbol : typeMap.SubstituteType(typeSymbol);
}
protected override void Because_of()
{
_map = _factory.CreateTypeMap(typeof(Source), typeof(Destination), _mappingOptions, MemberList.Destination);
}
private static List <MemberBinding> CreateMemberBindings(IMappingEngine mappingEngine, Type typeIn, TypeMap typeMap,
Expression instanceParameter)
{
var bindings = new List <MemberBinding>();
foreach (var propertyMap in typeMap.GetPropertyMaps().Where(pm => pm.CanResolveValue()))
{
var result = propertyMap.ResolveExpression(typeIn, instanceParameter);
var destinationMember = propertyMap.DestinationProperty.MemberInfo;
MemberAssignment bindExpression;
if (propertyMap.DestinationPropertyType.IsAssignableFrom(result.Type))
{
bindExpression = Expression.Bind(destinationMember, result.ResolutionExpression);
}
else if (propertyMap.DestinationPropertyType.GetInterfaces().Any(t => t.Name == "IEnumerable") &&
propertyMap.DestinationPropertyType != typeof(string))
{
Type destinationListType = propertyMap.DestinationPropertyType.GetGenericArguments().First();
Type sourceListType = null;
// is list
sourceListType = result.Type.GetGenericArguments().First();
//var newVariableName = "t" + (i++);
var transformedExpression = CreateMapExpression(mappingEngine, sourceListType, destinationListType);
MethodCallExpression selectExpression = Expression.Call(
typeof(Enumerable),
"Select",
new[] { sourceListType, destinationListType },
result.ResolutionExpression,
transformedExpression);
if (typeof(IList <>).MakeGenericType(destinationListType).IsAssignableFrom(propertyMap.DestinationPropertyType))
{
MethodCallExpression toListCallExpression = Expression.Call(
typeof(Enumerable),
"ToList",
new Type[] { destinationListType },
selectExpression);
// todo .ToArray()
bindExpression = Expression.Bind(destinationMember, toListCallExpression);
}
else
{
// destination type implements ienumerable, but is not an ilist. allow deferred enumeration
bindExpression = Expression.Bind(destinationMember, selectExpression);
}
}
else if (result.Type != propertyMap.DestinationPropertyType &&
// avoid nullable etc.
propertyMap.DestinationPropertyType.BaseType != typeof(ValueType) &&
propertyMap.DestinationPropertyType.BaseType != typeof(Enum))
{
var transformedExpression = CreateMapExpression(mappingEngine, result.Type,
propertyMap.DestinationPropertyType,
result.ResolutionExpression);
bindExpression = Expression.Bind(destinationMember, transformedExpression);
}
else
{
throw new AutoMapperMappingException("Unable to create a map expression from " + result.Type + " to " + propertyMap.DestinationPropertyType);
}
bindings.Add(bindExpression);
}
return(bindings);
}
public SynthesizedSubstitutedTypeParameterSymbol(Symbol owner, TypeMap map, TypeParameterSymbol substitutedFrom)
: base(owner, map, substitutedFrom)
{
}
public TypeMapPlanBuilder(IConfigurationProvider configurationProvider, TypeMapRegistry typeMapRegistry, TypeMap typeMap)
{
_configurationProvider = configurationProvider;
_typeMapRegistry = typeMapRegistry;
_typeMap = typeMap;
_source = Parameter(typeMap.SourceType, "src");
_initialDestination = Parameter(typeMap.DestinationTypeToUse, "dest");
_context = Parameter(typeof(ResolutionContext), "ctxt");
_destination = Variable(_initialDestination.Type, "typeMapDestination");
}
/// <summary>
/// Translate a statement that declares a given set of locals. Also allocates and frees hoisted temps as
/// required for the translation.
/// </summary>
/// <param name="locals">The set of locals declared in the original version of this statement</param>
/// <param name="wrapped">A delegate to return the translation of the body of this statement</param>
private BoundStatement PossibleIteratorScope(ImmutableArray <LocalSymbol> locals, Func <BoundStatement> wrapped)
{
if (locals.IsDefaultOrEmpty)
{
return(wrapped());
}
var hoistedUserDefinedLocals = ArrayBuilder <SynthesizedFieldSymbolBase> .GetInstance();
foreach (var local in locals)
{
if (!NeedsProxy(local))
{
continue;
}
// Ref synthesized variables have proxies that are allocated in VisitAssignmentOperator.
if (local.RefKind != RefKind.None)
{
Debug.Assert(local.SynthesizedLocalKind == SynthesizedLocalKind.AwaitSpill);
continue;
}
Debug.Assert(local.SynthesizedLocalKind == SynthesizedLocalKind.None ||
local.SynthesizedLocalKind.IsLongLived());
CapturedSymbolReplacement proxy;
if (!proxies.TryGetValue(local, out proxy))
{
proxy = new CapturedToFrameSymbolReplacement(GetOrAllocateHoistedField(TypeMap.SubstituteType(local.Type)), isReusable: true);
proxies.Add(local, proxy);
}
if (local.SynthesizedLocalKind == SynthesizedLocalKind.None)
{
hoistedUserDefinedLocals.Add(((CapturedToFrameSymbolReplacement)proxy).HoistedField);
}
}
var translatedStatement = wrapped();
var variableCleanup = ArrayBuilder <BoundAssignmentOperator> .GetInstance();
// produce cleanup code for all fields of locals defined by this block
// as well as all proxies allocated by VisitAssignmentOperator within this block:
foreach (var local in locals)
{
CapturedSymbolReplacement proxy;
if (!proxies.TryGetValue(local, out proxy))
{
continue;
}
var simpleProxy = proxy as CapturedToFrameSymbolReplacement;
if (simpleProxy != null)
{
AddVariableCleanup(variableCleanup, simpleProxy.HoistedField);
if (proxy.IsReusable)
{
FreeHoistedField(simpleProxy.HoistedField);
}
}
else
{
foreach (var field in ((CapturedToExpressionSymbolReplacement)proxy).HoistedFields)
{
AddVariableCleanup(variableCleanup, field);
if (proxy.IsReusable)
{
FreeHoistedField(field);
}
}
}
}
if (variableCleanup.Count != 0)
{
translatedStatement = F.Block(
translatedStatement,
F.Block(variableCleanup.SelectAsArray((e, f) => (BoundStatement)f.ExpressionStatement(e), F)));
}
variableCleanup.Free();
// wrap the node in an iterator scope for debugging
if (hoistedUserDefinedLocals.Count != 0)
{
translatedStatement = F.Block(new BoundIteratorScope(F.Syntax, hoistedUserDefinedLocals.ToImmutable(), translatedStatement));
}
hoistedUserDefinedLocals.Free();
return(translatedStatement);
}
private TypeMap FindTypeMap(object source, object destination, Type sourceType, Type destinationType, string profileName)
{
TypeMap typeMap = FindExplicitlyDefinedTypeMap(sourceType, destinationType);
if (typeMap == null && destinationType.IsNullableType())
{
typeMap = FindExplicitlyDefinedTypeMap(sourceType, destinationType.GetTypeOfNullable());
}
if (typeMap == null)
{
typeMap = _typeMaps.FirstOrDefault(x => x.SourceType == sourceType && x.GetDerivedTypeFor(sourceType) == destinationType);
if (typeMap == null)
{
foreach (var sourceInterface in sourceType.GetInterfaces())
{
typeMap = ((IConfigurationProvider)this).FindTypeMapFor(source, destination, sourceInterface, destinationType);
if (typeMap == null)
{
continue;
}
var derivedTypeFor = typeMap.GetDerivedTypeFor(sourceType);
if (derivedTypeFor != destinationType)
{
typeMap = CreateTypeMap(sourceType, derivedTypeFor, profileName, typeMap.ConfiguredMemberList);
}
break;
}
if ((sourceType.BaseType() != null) && (typeMap == null))
{
typeMap = ((IConfigurationProvider)this).FindTypeMapFor(source, destination, sourceType.BaseType(), destinationType);
}
}
}
if (typeMap == null && sourceType.IsGenericType() && destinationType.IsGenericType())
{
var sourceGenericDefinition = sourceType.GetGenericTypeDefinition();
var destGenericDefinition = destinationType.GetGenericTypeDefinition();
if (sourceGenericDefinition == null || destGenericDefinition == null)
{
return(null);
}
var genericTypePair = new TypePair(sourceGenericDefinition, destGenericDefinition);
CreateTypeMapExpression genericTypeMapExpression;
if (_typeMapExpressionCache.TryGetValue(genericTypePair, out genericTypeMapExpression))
{
typeMap = CreateTypeMap(sourceType, destinationType, genericTypeMapExpression.ProfileName,
genericTypeMapExpression.MemberList);
var mappingExpression = CreateMappingExpression(typeMap, destinationType);
genericTypeMapExpression.Accept(mappingExpression);
}
}
return(typeMap);
}
public MemberAssignment Build(IMappingEngine mappingEngine, PropertyMap propertyMap, TypeMap propertyTypeMap,
ExpressionRequest request, ExpressionResolutionResult result,
IDictionary <ExpressionRequest, int> typePairCount)
{
return(BindAssignableExpression(propertyMap, result));
}
public bool IsMatch(PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionResolutionResult result)
{
return(propertyMap.DestinationPropertyType.IsAssignableFrom(result.Type));
}
public override bool VisitPointerType(PointerType pointer, TypeQualifiers quals)
{
if (!VisitType(pointer, quals))
{
return(false);
}
var pointee = pointer.Pointee.Desugar();
PrimitiveType primitive;
var param = Context.Parameter;
if (param != null && (param.IsOut || param.IsInOut) &&
pointee.IsPrimitiveType(out primitive))
{
Context.Return.Write(Context.ReturnVarName);
return(true);
}
if (pointee.IsPrimitiveType(out primitive))
{
var returnVarName = Context.ReturnVarName;
if (pointer.GetFinalQualifiedPointee().Qualifiers.IsConst !=
Context.ReturnType.Qualifiers.IsConst)
{
var nativeTypePrinter = new CppTypePrinter {
PrintTypeQualifiers = false
};
var returnType = Context.ReturnType.Type.Desugar();
var constlessPointer = new PointerType()
{
IsDependent = pointer.IsDependent,
Modifier = pointer.Modifier,
QualifiedPointee = new QualifiedType(returnType.GetPointee())
};
var nativeConstlessTypeName = constlessPointer.Visit(nativeTypePrinter, new TypeQualifiers());
returnVarName = string.Format("const_cast<{0}>({1})",
nativeConstlessTypeName, Context.ReturnVarName);
}
if (pointer.Pointee is TypedefType)
{
var desugaredPointer = new PointerType()
{
IsDependent = pointer.IsDependent,
Modifier = pointer.Modifier,
QualifiedPointee = new QualifiedType(pointee)
};
var nativeTypePrinter = new CppTypePrinter();
var nativeTypeName = desugaredPointer.Visit(nativeTypePrinter, quals);
Context.Return.Write("reinterpret_cast<{0}>({1})", nativeTypeName,
returnVarName);
}
else
{
Context.Return.Write(returnVarName);
}
return(true);
}
TypeMap typeMap = null;
Context.Context.TypeMaps.FindTypeMap(pointee, out typeMap);
Class @class;
if (pointee.TryGetClass(out @class) && typeMap == null)
{
var instance = (pointer.IsReference) ? "&" + Context.ReturnVarName
: Context.ReturnVarName;
WriteClassInstance(@class, instance);
return(true);
}
return(pointer.QualifiedPointee.Visit(this));
}
public override void SetTypeMetadata(BinaryTypeInfo typeInfo, TypeMap typeMap, BinarySerializerOptions options)
{
typeInfo.Type = TypeEnum.Vector3;
typeInfo.SerializeType = ClassType.Object;
}
public override Symbol VisitNamedType(NamedTypeSymbol sourceType)
{
var originalDef = sourceType.OriginalDefinition;
if ((object)originalDef != (object)sourceType)
{
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
var typeArguments = sourceType.GetAllTypeArguments(ref useSiteDiagnostics);
var otherDef = (NamedTypeSymbol)this.Visit(originalDef);
if ((object)otherDef == null)
{
return(null);
}
var otherTypeParameters = otherDef.GetAllTypeParameters();
bool translationFailed = false;
var otherTypeArguments = typeArguments.SelectAsArray((t, v) =>
{
var newType = (TypeSymbol)v.Visit(t.Type);
if ((object)newType == null)
{
// For a newly added type, there is no match in the previous generation, so it could be null.
translationFailed = true;
newType = t.Type;
}
return(new TypeWithModifiers(newType, v.VisitCustomModifiers(t.CustomModifiers)));
}, this);
if (translationFailed)
{
// For a newly added type, there is no match in the previous generation, so it could be null.
return(null);
}
// TODO: LambdaFrame has alpha renamed type parameters, should we rather fix that?
var typeMap = new TypeMap(otherTypeParameters, otherTypeArguments, allowAlpha: true);
return(typeMap.SubstituteNamedType(otherDef));
}
else if (sourceType.IsTupleType)
{
var otherDef = (NamedTypeSymbol)this.Visit(sourceType.TupleUnderlyingType);
if ((object)otherDef == null || !otherDef.IsTupleOrCompatibleWithTupleOfCardinality(sourceType.TupleElementTypes.Length))
{
return(null);
}
return(otherDef);
}
Debug.Assert(sourceType.IsDefinition);
var otherContainer = this.Visit(sourceType.ContainingSymbol);
// Containing type will be missing from other assembly
// if the type was added in the (newer) source assembly.
if ((object)otherContainer == null)
{
return(null);
}
switch (otherContainer.Kind)
{
case SymbolKind.Namespace:
if (AnonymousTypeManager.IsAnonymousTypeTemplate(sourceType))
{
Debug.Assert((object)otherContainer == (object)_otherAssembly.GlobalNamespace);
AnonymousTypeValue value;
this.TryFindAnonymousType(sourceType, out value);
return((NamedTypeSymbol)value.Type);
}
else if (sourceType.IsAnonymousType)
{
return(this.Visit(AnonymousTypeManager.TranslateAnonymousTypeSymbol(sourceType)));
}
else
{
return(FindMatchingNamespaceMember((NamespaceSymbol)otherContainer, sourceType, AreNamedTypesEqual));
}
case SymbolKind.NamedType:
return(FindMatchingNamedTypeMember((NamedTypeSymbol)otherContainer, sourceType, AreNamedTypesEqual));
default:
throw ExceptionUtilities.UnexpectedValue(otherContainer.Kind);
}
}
private static Expression CreateAssignmentFunc(
TypeMap typeMap,
IConfigurationProvider configurationProvider,
TypeMapRegistry registry,
ParameterExpression srcParam,
ParameterExpression destParam,
ParameterExpression ctxtParam,
Expression destinationFunc,
ref ParameterExpression contextToReuse)
{
var assignTypeMap = Assign(MakeMemberAccess(ctxtParam, typeof (ResolutionContext).GetProperty("TypeMap")),
Constant(typeMap));
var beforeMap = Call(ctxtParam, typeof (ResolutionContext).GetMethod("BeforeMap"), ToObject(destParam));
ParameterExpression propertyContext = contextToReuse;
var typeMaps = typeMap.GetPropertyMaps()
.Where(pm => pm.CanResolveValue())
.Select(pm => TryPropertyMap(pm, configurationProvider, registry, srcParam, destParam, ctxtParam, ref propertyContext))
.ToList();
contextToReuse = propertyContext;
var afterMap = Call(ctxtParam, typeof (ResolutionContext).GetMethod("AfterMap"), ToObject(destParam));
var actions = typeMaps;
foreach (var beforeMapAction in typeMap.BeforeMapActions)
{
actions.Insert(0, beforeMapAction.ReplaceParameters(srcParam, destParam, ctxtParam));
}
actions.Insert(0, beforeMap);
actions.Insert(0, destinationFunc);
actions.Insert(0, assignTypeMap);
ParameterExpression[] variables;
if(propertyContext != null)
{
var createPropertyContext = CreatePropertyContext(propertyContext, ctxtParam);
actions.Insert(0, createPropertyContext);
variables = new[] { propertyContext };
}
else
{
variables = new ParameterExpression[0];
}
actions.Add(afterMap);
actions.AddRange(
typeMap.AfterMapActions.Select(
afterMapAction => afterMapAction.ReplaceParameters(srcParam, destParam, ctxtParam)));
actions.Add(destParam);
return Block(variables, actions);
}
internal EEMethodSymbol(
EENamedTypeSymbol container,
string name,
Location location,
MethodSymbol sourceMethod,
ImmutableArray <LocalSymbol> sourceLocals,
ImmutableArray <LocalSymbol> sourceLocalsForBinding,
ImmutableDictionary <string, DisplayClassVariable> sourceDisplayClassVariables,
GenerateMethodBody generateMethodBody)
{
Debug.Assert(sourceMethod.IsDefinition);
Debug.Assert(TypeSymbol.Equals((TypeSymbol)sourceMethod.ContainingSymbol, container.SubstitutedSourceType.OriginalDefinition, TypeCompareKind.ConsiderEverything2));
Debug.Assert(sourceLocals.All(l => l.ContainingSymbol == sourceMethod));
_container = container;
_name = name;
_locations = ImmutableArray.Create(location);
// What we want is to map all original type parameters to the corresponding new type parameters
// (since the old ones have the wrong owners). Unfortunately, we have a circular dependency:
// 1) Each new type parameter requires the entire map in order to be able to construct its constraint list.
// 2) The map cannot be constructed until all new type parameters exist.
// Our solution is to pass each new type parameter a lazy reference to the type map. We then
// initialize the map as soon as the new type parameters are available - and before they are
// handed out - so that there is never a period where they can require the type map and find
// it uninitialized.
var sourceMethodTypeParameters = sourceMethod.TypeParameters;
var allSourceTypeParameters = container.SourceTypeParameters.Concat(sourceMethodTypeParameters);
var getTypeMap = new Func <TypeMap>(() => this.TypeMap);
_typeParameters = sourceMethodTypeParameters.SelectAsArray(
(tp, i, arg) => (TypeParameterSymbol) new EETypeParameterSymbol(this, tp, i, getTypeMap),
(object)null);
_allTypeParameters = container.TypeParameters.Concat(_typeParameters);
this.TypeMap = new TypeMap(allSourceTypeParameters, _allTypeParameters);
EENamedTypeSymbol.VerifyTypeParameters(this, _typeParameters);
var substitutedSourceType = container.SubstitutedSourceType;
this.SubstitutedSourceMethod = sourceMethod.AsMember(substitutedSourceType);
if (sourceMethod.Arity > 0)
{
this.SubstitutedSourceMethod = this.SubstitutedSourceMethod.Construct(_typeParameters.As <TypeSymbol>());
}
TypeParameterChecker.Check(this.SubstitutedSourceMethod, _allTypeParameters);
// Create a map from original parameter to target parameter.
var parameterBuilder = ArrayBuilder <ParameterSymbol> .GetInstance();
var substitutedSourceThisParameter = this.SubstitutedSourceMethod.ThisParameter;
var substitutedSourceHasThisParameter = (object)substitutedSourceThisParameter != null;
if (substitutedSourceHasThisParameter)
{
_thisParameter = MakeParameterSymbol(0, GeneratedNames.ThisProxyFieldName(), substitutedSourceThisParameter);
Debug.Assert(TypeSymbol.Equals(_thisParameter.Type, this.SubstitutedSourceMethod.ContainingType, TypeCompareKind.ConsiderEverything2));
parameterBuilder.Add(_thisParameter);
}
var ordinalOffset = (substitutedSourceHasThisParameter ? 1 : 0);
foreach (var substitutedSourceParameter in this.SubstitutedSourceMethod.Parameters)
{
var ordinal = substitutedSourceParameter.Ordinal + ordinalOffset;
Debug.Assert(ordinal == parameterBuilder.Count);
var parameter = MakeParameterSymbol(ordinal, substitutedSourceParameter.Name, substitutedSourceParameter);
parameterBuilder.Add(parameter);
}
_parameters = parameterBuilder.ToImmutableAndFree();
var localsBuilder = ArrayBuilder <LocalSymbol> .GetInstance();
var localsMap = PooledDictionary <LocalSymbol, LocalSymbol> .GetInstance();
foreach (var sourceLocal in sourceLocals)
{
var local = sourceLocal.ToOtherMethod(this, this.TypeMap);
localsMap.Add(sourceLocal, local);
localsBuilder.Add(local);
}
this.Locals = localsBuilder.ToImmutableAndFree();
localsBuilder = ArrayBuilder <LocalSymbol> .GetInstance();
foreach (var sourceLocal in sourceLocalsForBinding)
{
LocalSymbol local;
if (!localsMap.TryGetValue(sourceLocal, out local))
{
local = sourceLocal.ToOtherMethod(this, this.TypeMap);
localsMap.Add(sourceLocal, local);
}
localsBuilder.Add(local);
}
this.LocalsForBinding = localsBuilder.ToImmutableAndFree();
// Create a map from variable name to display class field.
var displayClassVariables = PooledDictionary <string, DisplayClassVariable> .GetInstance();
foreach (var pair in sourceDisplayClassVariables)
{
var variable = pair.Value;
var oldDisplayClassInstance = variable.DisplayClassInstance;
// Note: we don't call ToOtherMethod in the local case because doing so would produce
// a new LocalSymbol that would not be ReferenceEquals to the one in this.LocalsForBinding.
var oldDisplayClassInstanceFromLocal = oldDisplayClassInstance as DisplayClassInstanceFromLocal;
var newDisplayClassInstance = (oldDisplayClassInstanceFromLocal == null) ?
oldDisplayClassInstance.ToOtherMethod(this, this.TypeMap) :
new DisplayClassInstanceFromLocal((EELocalSymbol)localsMap[oldDisplayClassInstanceFromLocal.Local]);
variable = variable.SubstituteFields(newDisplayClassInstance, this.TypeMap);
displayClassVariables.Add(pair.Key, variable);
}
_displayClassVariables = displayClassVariables.ToImmutableDictionary();
displayClassVariables.Free();
localsMap.Free();
_generateMethodBody = generateMethodBody;
}
private static Expression CreateMapperFunc(
TypeMap typeMap,
ParameterExpression srcParam,
ParameterExpression destParam,
ParameterExpression ctxtParam,
Expression assignmentFunc)
{
var mapperFunc = assignmentFunc;
if (typeMap.Condition != null)
{
mapperFunc =
Condition(Invoke(typeMap.Condition, ctxtParam),
mapperFunc, Default(typeMap.DestinationType));
//mapperFunc = (source, context, destFunc) => _condition(context) ? inner(source, context, destFunc) : default(TDestination);
}
if (typeMap.MaxDepth > 0)
{
mapperFunc = Condition(Invoke(_passesDepthCheckExpression, ctxtParam, Constant(typeMap.MaxDepth)),
mapperFunc,
Default(typeMap.DestinationType));
//mapperFunc = (source, context, destFunc) => PassesDepthCheck(context, typeMap.MaxDepth) ? inner(source, context, destFunc) : default(TDestination);
}
if (typeMap.Profile.AllowNullDestinationValues && typeMap.SourceType.IsClass())
{
mapperFunc =
Condition(Equal(srcParam, Default(typeMap.SourceType)),
Default(typeMap.DestinationType), mapperFunc);
//mapperFunc = (source, context, destFunc) => source == default(TSource) ? default(TDestination) : inner(source, context, destFunc);
}
if (typeMap.PreserveReferences)
{
var cache = Variable(typeMap.DestinationType, "cachedDestination");
var condition = Condition(
AndAlso(
NotEqual(srcParam, Constant(null)),
AndAlso(
Equal(destParam, Constant(null)),
Call(Property(ctxtParam, "InstanceCache"),
typeof (Dictionary<object, object>).GetMethod("ContainsKey"), srcParam)
)),
Assign(cache,
ToType(Property(Property(ctxtParam, "InstanceCache"), "Item", srcParam), typeMap.DestinationType)),
Assign(cache, mapperFunc)
);
mapperFunc = Block(new[] {cache}, condition, cache);
}
return mapperFunc;
}
public static Exception PropertyConfigurationException(TypeMap typeMap, params string[] unmappedPropertyNames)
=> new AutoMapperConfigurationException(new[] { new AutoMapperConfigurationException.TypeMapConfigErrors(typeMap, unmappedPropertyNames, true) });
public void Map_ThirdToSecondLevelFlattening_Succeeds()
{
//Arrange
var array = new TypeMap[]
{
MapBuilder.Instance.CreateMap<SubSubEntity, SubFlattenedThirdToSecondLevelModel>().Map
};
var array2 = new TypeMap[]
{
MapBuilder.Instance.CreateMap<SubEntity, SubFlattenedThirdToSecondLevelModel>()
.MapProperty((SubEntity p) => p.SubSubEntity, null, array).Map
};
var map = MapBuilder.Instance.CreateMap<MainEntity, FlattenedThirdToSecondLevelModel>()
.MapProperty((MainEntity p) => p.SubEntity, (FlattenedThirdToSecondLevelModel p) => p.SubEntityModel, array2).Map;
var mainEntity = CommonHelper.CreateMainEntityWithAllProperties(false);
var customMappingContext = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
var flattenedThirdToSecondLevelModel = Mapper<MapperTesting.MapperTester>.Instance
.Map<FlattenedThirdToSecondLevelModel>(mainEntity, customMappingContext);
var flattenedThirdToSecondLevelModel2 = Mapper<MapperTesting.MapperTester>.Instance
.Map<FlattenedThirdToSecondLevelModel>(mainEntity, new FlattenedThirdToSecondLevelModel(), customMappingContext);
var flattenedThirdToSecondLevelModel3 = Mapper<MapperTesting.MapperTester>.Instance
.Map(mainEntity, typeof(FlattenedThirdToSecondLevelModel), customMappingContext) as FlattenedThirdToSecondLevelModel;
var array3 = new FlattenedThirdToSecondLevelModel[]
{
flattenedThirdToSecondLevelModel,
flattenedThirdToSecondLevelModel2,
flattenedThirdToSecondLevelModel3
};
//Assert
for (int i = 0; i < array3.Length; i++)
{
var flattenedThirdToSecondLevelModel4 = array3[i];
AssertSimpleFlattenedEntityModel(mainEntity.SubEntity.SubSubEntity,
flattenedThirdToSecondLevelModel4.SubEntityModel, "SubSubEntity");
}
}
public bool IsMatch(MemberMap memberMap, TypeMap memberTypeMap, Expression resolvedSource) => memberMap.DestinationType.IsAssignableFrom(resolvedSource.Type);
public MemberAssignment Build(IConfigurationProvider configuration, PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionRequest request, ExpressionResolutionResult result, ConcurrentDictionary <ExpressionRequest, int> typePairCount)
{
return(BindNullableExpression(propertyMap, result));
}
public static TypeMap[] GetIncludedTypeMaps(this IGlobalConfiguration configuration, TypeMap typeMap) => configuration.GetIncludedTypeMaps(typeMap.IncludedDerivedTypes);
public void VisitDelegate(CompiledDelegate @delegate, TypeMap map, Assembly assembly, CodeFile file)
{
@delegate.CollectionTyped = Tools.CreateDelegate(Tools.ToCollectionDelegateType(map), assembly, file);
}
internal static BoundNode RewriteLambda(BoundLambda node, TypeCompilationState compilationState, TypeMap typeMap, DiagnosticBag diagnostics)
{
try
{
var r = new ExpressionLambdaRewriter(compilationState, typeMap, node.Syntax, diagnostics);
var result = r.VisitLambdaInternal(node);
if (node.Type != result.Type)
{
diagnostics.Add(ErrorCode.ERR_MissingPredefinedMember, node.Syntax.Location, r.ExpressionType, "Lambda");
}
return(result);
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
return(node);
}
}
public static LambdaExpression BuildMapperFunc(TypeMap typeMap, IConfigurationProvider configurationProvider, TypeMapRegistry typeMapRegistry)
{
if (typeMap.SourceType.IsGenericTypeDefinition() || typeMap.DestinationType.IsGenericTypeDefinition())
{
return(null);
}
var srcParam = Parameter(typeMap.SourceType, "src");
var destParam = Parameter(typeMap.DestinationType, "dest");
var ctxtParam = Parameter(typeof(ResolutionContext), "ctxt");
if (typeMap.Substitution != null)
{
return(Lambda(typeMap.Substitution.ReplaceParameters(srcParam, destParam, ctxtParam), srcParam,
destParam, ctxtParam));
}
if (typeMap.TypeConverterType != null)
{
Type type;
if (typeMap.TypeConverterType.IsGenericTypeDefinition())
{
var genericTypeParam = typeMap.SourceType.IsGenericType()
? typeMap.SourceType.GetTypeInfo().GenericTypeArguments[0]
: typeMap.DestinationType.GetTypeInfo().GenericTypeArguments[0];
type = typeMap.TypeConverterType.MakeGenericType(genericTypeParam);
}
else
{
type = typeMap.TypeConverterType;
}
// (src, dest, ctxt) => ((ITypeConverter<TSource, TDest>)ctxt.Options.CreateInstance<TypeConverterType>()).Convert(src, ctxt);
var converterInterfaceType = typeof(ITypeConverter <,>).MakeGenericType(typeMap.SourceType,
typeMap.DestinationType);
return(Lambda(
Call(
Convert(
Call(
MakeMemberAccess(ctxtParam, typeof(ResolutionContext).GetProperty("Options")),
typeof(MappingOperationOptions).GetMethod("CreateInstance")
.MakeGenericMethod(type)
),
converterInterfaceType),
converterInterfaceType.GetMethod("Convert"),
srcParam, ctxtParam
),
srcParam, destParam, ctxtParam));
}
if (typeMap.CustomMapper != null)
{
return(Lambda(typeMap.CustomMapper.ReplaceParameters(srcParam, destParam, ctxtParam), srcParam,
destParam, ctxtParam));
}
if (typeMap.CustomProjection != null)
{
return(Lambda(typeMap.CustomProjection.ReplaceParameters(srcParam), srcParam, destParam, ctxtParam));
}
ParameterExpression contextToReuse = null;
var destinationFunc = CreateDestinationFunc(typeMap, typeMapRegistry, srcParam, destParam, ctxtParam, ref contextToReuse);
var assignmentFunc = CreateAssignmentFunc(typeMap, configurationProvider, typeMapRegistry, srcParam, destParam, ctxtParam, destinationFunc, ref contextToReuse);
var mapperFunc = CreateMapperFunc(typeMap, srcParam, destParam, ctxtParam, assignmentFunc);
var lambdaExpr = Lambda(mapperFunc, srcParam, destParam, ctxtParam);
return(lambdaExpr);
}
public CppFullMemberFormatter(TypeMap map) : base(map)
{
}
public bool IsMatch(PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionResolutionResult result)
{
return propertyMap.DestinationPropertyType == typeof(string);
}
public MemberAssignment Build(IConfigurationProvider configuration, PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionRequest request, ExpressionResolutionResult result, IDictionary <ExpressionRequest, int> typePairCount, LetPropertyMaps letPropertyMaps) => BindMappedTypeExpression(configuration, propertyMap, request, result, typePairCount, letPropertyMaps);
internal static bool TryCreate(SyntheticBoundNodeFactory F, MethodSymbol method, TypeMap typeMap, out AsyncMethodBuilderMemberCollection collection)
{
if (method.IsIterator)
{
var builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncIteratorMethodBuilder);
Debug.Assert((object)builderType != null);
TryGetBuilderMember <MethodSymbol>(
F,
WellKnownMember.System_Runtime_CompilerServices_AsyncIteratorMethodBuilder__Create,
builderType,
customBuilder: false,
out MethodSymbol createBuilderMethod);
if (createBuilderMethod is null)
{
collection = default;
return(false);
}
return(TryCreate(
F,
customBuilder: false,
builderType: builderType,
resultType: F.SpecialType(SpecialType.System_Void),
createBuilderMethod: createBuilderMethod,
taskProperty: null,
setException: null, // unused
setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncIteratorMethodBuilder__Complete, // AsyncIteratorMethodBuilder.Complete is the corresponding method to AsyncTaskMethodBuilder.SetResult
awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncIteratorMethodBuilder__AwaitOnCompleted,
awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncIteratorMethodBuilder__AwaitUnsafeOnCompleted,
start: WellKnownMember.System_Runtime_CompilerServices_AsyncIteratorMethodBuilder__MoveNext_T,
setStateMachine: null, // unused
collection: out collection));
}
if (method.IsAsyncReturningVoid())
{
var builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncVoidMethodBuilder);
Debug.Assert((object)builderType != null);
MethodSymbol createBuilderMethod;
bool customBuilder = false;
TryGetBuilderMember <MethodSymbol>(
F,
WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__Create,
builderType,
customBuilder,
out createBuilderMethod);
if ((object)createBuilderMethod == null)
{
collection = default;
return(false);
}
return(TryCreate(
F,
customBuilder: customBuilder,
builderType: builderType,
resultType: F.SpecialType(SpecialType.System_Void),
createBuilderMethod: createBuilderMethod,
taskProperty: null,
setException: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetException,
setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetResult,
awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__AwaitOnCompleted,
awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__AwaitUnsafeOnCompleted,
start: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__Start_T,
setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncVoidMethodBuilder__SetStateMachine,
collection: out collection));
}
object methodLevelBuilder = null;
if (method.IsAsyncEffectivelyReturningTask(F.Compilation))
{
var returnType = (NamedTypeSymbol)method.ReturnType;
NamedTypeSymbol builderType;
MethodSymbol createBuilderMethod = null;
PropertySymbol taskProperty = null;
bool useMethodLevelBuilder = method.HasAsyncMethodBuilderAttribute(out methodLevelBuilder);
bool customBuilder;
object builderArgument;
if (useMethodLevelBuilder)
{
customBuilder = true;
builderArgument = methodLevelBuilder;
}
else
{
customBuilder = returnType.IsCustomTaskType(out builderArgument);
}
if (customBuilder)
{
builderType = ValidateBuilderType(F, builderArgument, returnType.DeclaredAccessibility, isGeneric: false, useMethodLevelBuilder);
if ((object)builderType != null)
{
taskProperty = GetCustomTaskProperty(F, builderType, returnType);
createBuilderMethod = GetCustomCreateMethod(F, builderType);
}
}
else
{
builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncTaskMethodBuilder);
Debug.Assert((object)builderType != null);
TryGetBuilderMember <MethodSymbol>(
F,
WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__Create,
builderType,
customBuilder,
out createBuilderMethod);
TryGetBuilderMember <PropertySymbol>(
F,
WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__Task,
builderType,
customBuilder,
out taskProperty);
}
if ((object)builderType == null ||
(object)createBuilderMethod == null ||
(object)taskProperty == null)
{
collection = default;
return(false);
}
return(TryCreate(
F,
customBuilder: customBuilder,
builderType: builderType,
resultType: F.SpecialType(SpecialType.System_Void),
createBuilderMethod: createBuilderMethod,
taskProperty: taskProperty,
setException: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetException,
setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetResult,
awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__AwaitOnCompleted,
awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__AwaitUnsafeOnCompleted,
start: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__Start_T,
setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder__SetStateMachine,
collection: out collection));
}
if (method.IsAsyncEffectivelyReturningGenericTask(F.Compilation))
{
var returnType = (NamedTypeSymbol)method.ReturnType;
var resultType = returnType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.Single().Type;
if (resultType.IsDynamic())
{
resultType = F.SpecialType(SpecialType.System_Object);
}
if (typeMap != null)
{
resultType = typeMap.SubstituteType(resultType).Type;
}
returnType = returnType.ConstructedFrom.Construct(resultType);
NamedTypeSymbol builderType;
MethodSymbol createBuilderMethod = null;
PropertySymbol taskProperty = null;
bool useMethodLevelBuilder = method.HasAsyncMethodBuilderAttribute(out methodLevelBuilder);
bool customBuilder;
object builderArgument;
if (useMethodLevelBuilder)
{
customBuilder = true;
builderArgument = methodLevelBuilder;
}
else
{
customBuilder = returnType.IsCustomTaskType(out builderArgument);
}
if (customBuilder)
{
builderType = ValidateBuilderType(F, builderArgument, returnType.DeclaredAccessibility, isGeneric: true, useMethodLevelBuilder);
if ((object)builderType != null)
{
builderType = builderType.ConstructedFrom.Construct(resultType);
taskProperty = GetCustomTaskProperty(F, builderType, returnType);
createBuilderMethod = GetCustomCreateMethod(F, builderType);
}
}
else
{
builderType = F.WellKnownType(WellKnownType.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T);
Debug.Assert((object)builderType != null);
builderType = builderType.Construct(resultType);
TryGetBuilderMember <MethodSymbol>(
F,
WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__Create,
builderType,
customBuilder,
out createBuilderMethod);
TryGetBuilderMember <PropertySymbol>(
F,
WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__Task,
builderType,
customBuilder,
out taskProperty);
}
if ((object)builderType == null ||
(object)taskProperty == null ||
(object)createBuilderMethod == null)
{
collection = default;
return(false);
}
return(TryCreate(
F,
customBuilder: customBuilder,
builderType: builderType,
resultType: resultType,
createBuilderMethod: createBuilderMethod,
taskProperty: taskProperty,
setException: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetException,
setResult: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetResult,
awaitOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__AwaitOnCompleted,
awaitUnsafeOnCompleted: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__AwaitUnsafeOnCompleted,
start: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__Start_T,
setStateMachine: WellKnownMember.System_Runtime_CompilerServices_AsyncTaskMethodBuilder_T__SetStateMachine,
collection: out collection));
}
throw ExceptionUtilities.UnexpectedValue(method);
}
public bool IsMatch(PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionResolutionResult result) => propertyTypeMap != null && propertyTypeMap.CustomMapExpression == null;
public bool IsMatch(MemberMap memberMap, TypeMap memberTypeMap, Expression resolvedSource) => memberTypeMap != null;
public bool IsMatch(PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionResolutionResult result) => propertyMap.DestinationType.IsAssignableFrom(result.Type) && propertyTypeMap == null;
public static LambdaExpression BuildMapperFunc(TypeMap typeMap, IConfigurationProvider configurationProvider, TypeMapRegistry typeMapRegistry)
{
if (typeMap.SourceType.IsGenericTypeDefinition() || typeMap.DestinationType.IsGenericTypeDefinition())
return null;
var srcParam = Parameter(typeMap.SourceType, "src");
var destParam = Parameter(typeMap.DestinationType, "dest");
var ctxtParam = Parameter(typeof (ResolutionContext), "ctxt");
if (typeMap.Substitution != null)
{
return Lambda(typeMap.Substitution.ReplaceParameters(srcParam, destParam, ctxtParam), srcParam,
destParam, ctxtParam);
}
if (typeMap.TypeConverterType != null)
{
Type type;
if (typeMap.TypeConverterType.IsGenericTypeDefinition())
{
var genericTypeParam = typeMap.SourceType.IsGenericType()
? typeMap.SourceType.GetTypeInfo().GenericTypeArguments[0]
: typeMap.DestinationType.GetTypeInfo().GenericTypeArguments[0];
type = typeMap.TypeConverterType.MakeGenericType(genericTypeParam);
}
else type = typeMap.TypeConverterType;
// (src, dest, ctxt) => ((ITypeConverter<TSource, TDest>)ctxt.Options.CreateInstance<TypeConverterType>()).Convert(src, ctxt);
var converterInterfaceType = typeof (ITypeConverter<,>).MakeGenericType(typeMap.SourceType,
typeMap.DestinationType);
return Lambda(
Call(
Convert(
Call(
MakeMemberAccess(ctxtParam, typeof (ResolutionContext).GetProperty("Options")),
typeof (MappingOperationOptions).GetMethod("CreateInstance")
.MakeGenericMethod(type)
),
converterInterfaceType),
converterInterfaceType.GetMethod("Convert"),
srcParam, ctxtParam
),
srcParam, destParam, ctxtParam);
}
if (typeMap.CustomMapper != null)
{
return Lambda(typeMap.CustomMapper.ReplaceParameters(srcParam, destParam, ctxtParam), srcParam,
destParam, ctxtParam);
}
if (typeMap.CustomProjection != null)
{
return Lambda(typeMap.CustomProjection.ReplaceParameters(srcParam), srcParam, destParam, ctxtParam);
}
ParameterExpression contextToReuse = null;
var destinationFunc = CreateDestinationFunc(typeMap, typeMapRegistry, srcParam, destParam, ctxtParam, ref contextToReuse);
var assignmentFunc = CreateAssignmentFunc(typeMap, configurationProvider, typeMapRegistry, srcParam, destParam, ctxtParam, destinationFunc, ref contextToReuse);
var mapperFunc = CreateMapperFunc(typeMap, srcParam, destParam, ctxtParam, assignmentFunc);
var lambdaExpr = Lambda(mapperFunc, srcParam, destParam, ctxtParam);
return lambdaExpr;
}
private Expression CreateMapExpressionCore(ExpressionRequest request, Expression instanceParameter, TypePairCount typePairCount, TypeMap typeMap, LetPropertyMaps letPropertyMaps)
{
var bindings = new List <MemberBinding>();
var depth = GetDepth(request, typePairCount);
if (typeMap.MaxDepth > 0 && depth >= typeMap.MaxDepth)
{
if (typeMap.Profile.AllowNullDestinationValues)
{
return(null);
}
}
else
{
bindings = CreateMemberBindings(request, typeMap, instanceParameter, typePairCount, letPropertyMaps);
}
Expression constructorExpression = DestinationConstructorExpression(typeMap, instanceParameter);
if (instanceParameter is ParameterExpression)
{
constructorExpression = ((LambdaExpression)constructorExpression).ReplaceParameters(instanceParameter);
}
var visitor = new NewFinderVisitor();
visitor.Visit(constructorExpression);
var expression = MemberInit(
visitor.NewExpression,
bindings.ToArray()
);
return(expression);
}
private static Expression CreateNewDestinationFunc(
TypeMap typeMap,
TypeMapRegistry typeMapRegistry,
ParameterExpression srcParam,
ParameterExpression ctxtParam,
ref ParameterExpression contextToReuse)
{
if (typeMap.DestinationCtor != null)
return typeMap.DestinationCtor.ReplaceParameters(srcParam, ctxtParam);
if (typeMap.ConstructDestinationUsingServiceLocator)
return Call(MakeMemberAccess(ctxtParam, typeof (ResolutionContext).GetProperty("Options")),
typeof (MappingOperationOptions).GetMethod("CreateInstance")
.MakeGenericMethod(typeMap.DestinationType)
);
if (typeMap.ConstructorMap?.CanResolve == true)
return typeMap.ConstructorMap.BuildExpression(typeMapRegistry, srcParam, ctxtParam, ref contextToReuse);
if (typeMap.DestinationType.IsInterface())
{
#if PORTABLE
Block(typeof (object),
Throw(
Constant(
new PlatformNotSupportedException("Mapping to interfaces through proxies not supported."))),
Constant(null));
#else
var ctor = Call(Constant(ObjectCreator.DelegateFactory), typeof(DelegateFactory).GetMethod("CreateCtor", new[] { typeof(Type) }), Call(New(typeof(ProxyGenerator)), typeof(ProxyGenerator).GetMethod("GetProxyType"), Constant(typeMap.DestinationType)));
return Invoke(ctor);
#endif
}
if (typeMap.DestinationType.IsAbstract())
return Constant(null);
if (typeMap.DestinationType.IsGenericTypeDefinition())
return Constant(null);
return DelegateFactory.GenerateConstructorExpression(typeMap.DestinationType);
}
private Expression CreateMapExpressionCore(ExpressionRequest request, Expression instanceParameter, TypePairCount typePairCount, LetPropertyMaps letPropertyMaps, out TypeMap typeMap)
{
typeMap = _configurationProvider.ResolveTypeMap(request.SourceType, request.DestinationType);
if (typeMap == null)
{
throw QueryMapperHelper.MissingMapException(request.SourceType, request.DestinationType);
}
if (typeMap.CustomProjection != null)
{
return(typeMap.CustomProjection.ReplaceParameters(instanceParameter));
}
return(CreateMapExpressionCore(request, instanceParameter, typePairCount, typeMap, letPropertyMaps));
}
public void Map_NestedWithPropertyMapsWithSimple_Succeeds()
{
//Arrange
var array = new TypeMap[]
{
MapBuilder.Instance.CreateMap<SubSubEntity, SubSubEntityModel>().Map
};
var array2 = new TypeMap[]
{
MapBuilder.Instance.CreateMap<SubEntity, SubEntityModel>().MapProperty((SubEntity p) =>
p.SubSubEntity, (SubEntityModel p) => p.SubSubEntity, array).MapProperty((SubEntity p) =>
p.SubSubEntityArrayToArray, (SubEntityModel p) => p.SubSubEntityArrayToArray, array)
.MapProperty((SubEntity p) => p.SubSubEntityArrayToList, (SubEntityModel p) =>
p.SubSubEntityArrayToList, array).MapProperty((SubEntity p) => p.SubSubEntityListToArray,
(SubEntityModel p) => p.SubSubEntityListToArray, array).MapProperty((SubEntity p) =>
p.SubSubEntityListToList, (SubEntityModel p) => p.SubSubEntityListToList, array).Map
};
var map = MapBuilder.Instance.CreateMap<MainEntity, MainEntityModel>().MapProperty((MainEntity p) =>
p.SubEntity, (MainEntityModel p) => p.SubEntity, array2).MapProperty((MainEntity p) =>
p.SubEntityArrayToArray, (MainEntityModel p) => p.SubEntityArrayToArray, array2)
.MapProperty((MainEntity p) => p.SubEntityArrayToList, (MainEntityModel p) =>
p.SubEntityArrayToList, array2).MapProperty((MainEntity p) => p.SubEntityListToArray,
(MainEntityModel p) => p.SubEntityListToArray, array2).MapProperty((MainEntity p) =>
p.SubEntityListToList, (MainEntityModel p) => p.SubEntityListToList, array2).Map;
var entity = CommonHelper.CreateMainEntityWithAllProperties(false);
var context = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
MainEntityModel[] array3 = ActMapping(entity, context);
//Asserts
for (int i = 0; i < array3.Length; i++)
{
MainEntityModel model = array3[i];
AssertEntityModel(entity, model);
}
}
public bool IsMatch(PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionResolutionResult result)
{
return(propertyMap.DestinationPropertyType.IsNullableType() &&
!result.Type.IsNullableType());
}
protected override void Because_of()
{
_map = _factory.CreateTypeMap(typeof(Source), typeof(Destination), _mappingOptions, MemberList.Destination);
}
public Expression Project(IGlobalConfiguration configuration, MemberMap memberMap, TypeMap memberTypeMap, in ProjectionRequest request, Expression resolvedSource, LetPropertyMaps letPropertyMaps)
