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));
}
