private static void CheckTypeForGenericParams( IType type, HashSet <string> genericsSet, BooClassBuilder builder, GeneratorTypeReplacer mapper) { if (type is IGenericParameter) { if (!genericsSet.Contains(type.Name)) { builder.AddGenericParameter(type.Name); genericsSet.Add(type.Name); } if (!mapper.ContainsType(type)) { mapper.Replace( type, (IType)builder.ClassDefinition.GenericParameters .First(gp => gp.Name.Equals(type.Name)).Entity); } } else { var genType = type as IConstructedTypeInfo; if (genType != null) { foreach (var arg in genType.GenericArguments) { CheckTypeForGenericParams(arg, genericsSet, builder, mapper); } } } }
private static void CheckMethodGenerics(Method call, ClassDefinition node) { if (node.GenericParameters.Count > 0) { var tf = new GenericTypeFinder(); call.Body.Accept(tf); var results = tf.Results.ToArray(); if (results.Length > 0) { var replacer = new GeneratorTypeReplacer(); foreach (var gtype in results) { var replacement = node.GenericParameters.FirstOrDefault(gp => gp.Name == gtype.Name); if (replacement != null) { replacer.Replace(gtype, (IType)replacement.Entity); } } if (replacer.Any) { call.Body.Accept(new GenericTypeMapper(replacer)); } } } }
protected virtual void CreateStateMachine() { _stateMachineClass = CodeBuilder.CreateClass(StateMachineClassName); _stateMachineClass.AddAttribute(CodeBuilder.CreateAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute))); _stateMachineClass.LexicalInfo = this.LexicalInfo; foreach (var param in _genericParams) { var replacement = _stateMachineClass.AddGenericParameter(param); _methodToStateMachineMapper.Replace((IType)param.Entity, (IType)replacement.Entity); } SetupStateMachine(); CreateStateMachineConstructor(); SaveStateMachineClass(_stateMachineClass.ClassDefinition); CreateMoveNext(); }
private void MapMethodGenerics(BooClassBuilder builder, Method method) { Debug.Assert(_mapper != null); var classParams = builder.ClassDefinition.GenericParameters; foreach (var genParam in method.GenericParameters) { var replacement = classParams.FirstOrDefault(p => p.Name.Equals(genParam.Name)); if (replacement != null && genParam != replacement.Entity) { _mapper.Replace((IType)genParam.Entity, (IType)replacement.Entity); } } method.GenericParameters.Clear(); method.Entity = new InternalMethod(Environments.My <InternalTypeSystemProvider> .Instance, method); }
public override void OnMemberReferenceExpression(MemberReferenceExpression node) { base.OnMemberReferenceExpression(node); var member = node.Entity as IMember; if (member != null) { var type = member.Type; var mappedType = _replacer.MapType(type); if (mappedType != type) { _replacer.Replace(type, mappedType); node.ExpressionType = mappedType; ReplaceMappedEntity(node, mappedType); } } }
private void BuildTypeMap(ClassDefinition newClass) { string lastName = null; IType lastType = null; int i = 0; foreach (var newParam in _collector.Matches.Cast <IGenericParameter>().OrderBy(t => t.GenericParameterPosition)) { if (!newParam.Name.Equals(lastName)) { lastName = newParam.Name; var genParam = CodeBuilder.CreateGenericParameterDeclaration(i, newParam.Name); newClass.GenericParameters.Add(genParam); lastType = (IType)genParam.Entity; ++i; } _mapper.Replace(newParam, lastType); } }
private void MapGenerics(ClassDefinition cd) { var finder = new GenericTypeFinder(); foreach (var member in cd.Members) { member.Accept(finder); } _mapper = _mapper ?? new GeneratorTypeReplacer(); var genParams = cd.GenericParameters; foreach (var genType in finder.Results) { var replacement = genParams.FirstOrDefault(p => p.Name.Equals(genType.Name)); if (replacement != null && genType != replacement.Entity) { _mapper.Replace(genType, (IType)replacement.Entity); } } }
private static IMethod RemapMethod(Node node, GenericMappedMethod gmm, IType[] genParams) { var sourceMethod = gmm.SourceMember; if (sourceMethod.GenericInfo != null) { throw new CompilerError(node, "Mapping generic methods in generators is not implemented yet"); } var baseType = sourceMethod.DeclaringType; var genericInfo = baseType.GenericInfo; if (genericInfo == null) { throw new CompilerError(node, "Mapping generic nested types in generators is not implemented yet"); } var genericArgs = ((IGenericArgumentsProvider)gmm.DeclaringType).GenericArguments; var collector = new TypeCollector(type => type is IGenericParameter); foreach (var arg in genericArgs) { collector.Visit(arg); } var mapper = new GeneratorTypeReplacer(); foreach (var genParam in collector.Matches) { var mappedArg = genParams.SingleOrDefault(gp => gp.Name == genParam.Name); if (mappedArg != null) { mapper.Replace(genParam, mappedArg); } } var newType = (IConstructedTypeInfo) new GenericConstructedType( baseType, genericArgs.Select(mapper.MapType).ToArray()); return((IMethod)newType.Map(sourceMethod)); }