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) { }
/// <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()); }
public Expression Project(IGlobalConfiguration configuration, MemberMap memberMap, TypeMap memberTypeMap, in ProjectionRequest request, Expression resolvedSource, LetPropertyMaps letPropertyMaps)