override public void LeaveBlockExpression(BlockExpression node)
{
var closureEntity = GetEntity(node) as InternalMethod;
if (closureEntity == null)
return;
var collector = new ForeignReferenceCollector();
{
collector.CurrentMethod = closureEntity.Method;
collector.CurrentType = (IType)closureEntity.DeclaringType;
closureEntity.Method.Body.Accept(collector);
if (collector.ContainsForeignLocalReferences)
{
BooClassBuilder closureClass = CreateClosureClass(collector, closureEntity);
closureClass.ClassDefinition.LexicalInfo = node.LexicalInfo;
collector.AdjustReferences();
ReplaceCurrentNode(
CodeBuilder.CreateMemberReference(
collector.CreateConstructorInvocationWithReferencedEntities(
closureClass.Entity),
closureEntity));
}
else
{
Expression expression = CodeBuilder.CreateMemberReference(closureEntity);
expression.LexicalInfo = node.LexicalInfo;
TypeSystemServices.GetConcreteExpressionType(expression);
ReplaceCurrentNode(expression);
}
}
}
BooClassBuilder CreateClosureClass(ForeignReferenceCollector collector, InternalMethod closure)
{
Method method = closure.Method;
TypeDefinition parent = method.DeclaringType;
parent.Members.Remove(method);
BooClassBuilder builder = collector.CreateSkeletonClass(closure.Name, method.LexicalInfo);
parent.Members.Add(builder.ClassDefinition);
builder.ClassDefinition.Members.Add(method);
method.Name = "Invoke";
if (method.IsStatic)
{
// need to adjust paremeter indexes (parameter 0 is now self)
foreach (ParameterDeclaration parameter in method.Parameters)
{
((InternalParameter)parameter.Entity).Index += 1;
}
}
method.Modifiers = TypeMemberModifiers.Public;
var coll = new GenericTypeCollector(CodeBuilder);
coll.Process(builder.ClassDefinition);
return(builder);
}
BooClassBuilder CreateClosureClass(ForeignReferenceCollector collector, InternalMethod closure)
{
Method method = closure.Method;
TypeDefinition parent = method.DeclaringType;
parent.Members.Remove(method);
BooClassBuilder builder = collector.CreateSkeletonClass(closure.Name, method.LexicalInfo);
parent.Members.Add(builder.ClassDefinition);
builder.ClassDefinition.Members.Add(method);
method.Name = "Invoke";
if (method.IsStatic)
{
// need to adjust paremeter indexes (parameter 0 is now self)
foreach (ParameterDeclaration parameter in method.Parameters)
{
((InternalParameter)parameter.Entity).Index += 1;
}
}
method.Modifiers = TypeMemberModifiers.Public;
var coll = new GenericTypeCollector(CodeBuilder);
coll.Process(builder.ClassDefinition);
return builder;
}
override public void LeaveBlockExpression(BlockExpression node)
{
InternalMethod closureEntity = (InternalMethod)GetEntity(node);
using (ForeignReferenceCollector collector = new ForeignReferenceCollector())
{
collector.CurrentMethod = closureEntity.Method;
collector.CurrentType = (IType)closureEntity.DeclaringType;
collector.Initialize(_context);
collector.Visit(closureEntity.Method.Body);
if (collector.ContainsForeignLocalReferences)
{
BooClassBuilder closureClass = CreateClosureClass(collector, closureEntity);
collector.AdjustReferences();
ReplaceCurrentNode(
CodeBuilder.CreateMemberReference(
collector.CreateConstructorInvocationWithReferencedEntities(
closureClass.Entity),
closureEntity));
}
else
{
Expression expression = CodeBuilder.CreateMemberReference(closureEntity);
TypeSystemServices.GetConcreteExpressionType(expression);
ReplaceCurrentNode(expression);
}
}
}
public GeneratorExpressionProcessor(CompilerContext context,
ForeignReferenceCollector collector,
GeneratorExpression node)
{
_collector = collector;
_generator = node;
Initialize(context);
}
public GeneratorExpressionProcessor(CompilerContext context,
ForeignReferenceCollector collector,
GeneratorExpression node)
{
_collector = collector;
_generator = node;
Initialize(context);
}
public override void LeaveBlockExpression(BlockExpression node)
{
var closureEntity = GetEntity(node) as InternalMethod;
if (closureEntity == null)
{
return;
}
var collector = new ForeignReferenceCollector();
{
collector.CurrentMethod = closureEntity.Method;
collector.CurrentType = closureEntity.DeclaringType;
closureEntity.Method.Body.Accept(collector);
if (collector.ContainsForeignLocalReferences)
{
BooClassBuilder closureClass = CreateClosureClass(collector, closureEntity);
if (closureEntity is InternalGenericMethod)
{
closureEntity = GetEntity(closureEntity.Method) as InternalMethod;
}
closureClass.ClassDefinition.LexicalInfo = node.LexicalInfo;
collector.AdjustReferences();
if (_mapper != null)
{
closureClass.ClassDefinition.Accept(new GenericTypeMapper(_mapper));
}
ReplaceCurrentNode(
CodeBuilder.CreateMemberReference(
collector.CreateConstructorInvocationWithReferencedEntities(
closureClass.Entity,
node.GetAncestor <Method>()),
closureEntity));
}
else
{
_mapper = closureEntity.Method["GenericMapper"] as GeneratorTypeReplacer;
if (_mapper != null)
{
closureEntity.Method.Accept(new GenericTypeMapper(_mapper));
}
IMethod entity = closureEntity;
if (entity.GenericInfo != null)
{
entity = MapGenericMethod(entity, node.GetAncestor <Method>().GenericParameters);
}
Expression expression = CodeBuilder.CreateMemberReference(entity);
expression.LexicalInfo = node.LexicalInfo;
TypeSystemServices.GetConcreteExpressionType(expression);
ReplaceCurrentNode(expression);
}
}
}
public override void LeaveGeneratorExpression(GeneratorExpression node)
{
var collector = new ForeignReferenceCollector();
collector.CurrentType = (IType) AstUtil.GetParentClass(node).Entity;
collector.Visit(node);
var processor = new GeneratorExpressionProcessor(Context, collector, node);
processor.Run();
ReplaceCurrentNode(processor.CreateEnumerableConstructorInvocation());
}
override public void LeaveGeneratorExpression(GeneratorExpression node)
{
var collector = new ForeignReferenceCollector();
collector.CurrentType = (IType)AstUtil.GetParentClass(node).Entity;
node.Accept(collector);
var processor = new GeneratorExpressionProcessor(Context, collector, node);
processor.Run();
ReplaceCurrentNode(processor.CreateEnumerableConstructorInvocation());
}
override public void LeaveGeneratorExpression(GeneratorExpression node)
{
using (ForeignReferenceCollector collector = new ForeignReferenceCollector())
{
collector.CurrentType = (IType)AstUtil.GetParentClass(node).Entity;
collector.Initialize(_context);
collector.Visit(node);
GeneratorExpressionProcessor processor = new GeneratorExpressionProcessor(_context, collector, node);
processor.Run();
ReplaceCurrentNode(processor.CreateEnumerableConstructorInvocation());
}
}
public override void LeaveGeneratorExpression(GeneratorExpression node)
{
var collector = new ForeignReferenceCollector {
CurrentType = TypeContaining(node)
};
node.Accept(collector);
var processor = new GeneratorExpressionProcessor(Context, collector, node);
processor.Run();
ReplaceCurrentNode(processor.CreateEnumerableConstructorInvocation());
}
override public void LeaveBlockExpression(BlockExpression node)
{
var closureEntity = GetEntity(node) as InternalMethod;
if (closureEntity == null)
{
return;
}
var collector = new ForeignReferenceCollector();
{
collector.CurrentMethod = closureEntity.Method;
collector.CurrentType = (IType)closureEntity.DeclaringType;
closureEntity.Method.Body.Accept(collector);
if (collector.ContainsForeignLocalReferences)
{
BooClassBuilder closureClass = CreateClosureClass(collector, closureEntity);
closureClass.ClassDefinition.LexicalInfo = node.LexicalInfo;
collector.AdjustReferences();
ReplaceCurrentNode(
CodeBuilder.CreateMemberReference(
collector.CreateConstructorInvocationWithReferencedEntities(
closureClass.Entity),
closureEntity));
}
else
{
Expression expression = CodeBuilder.CreateMemberReference(closureEntity);
expression.LexicalInfo = node.LexicalInfo;
TypeSystemServices.GetConcreteExpressionType(expression);
ReplaceCurrentNode(expression);
}
}
}
override public void LeaveGeneratorExpression(GeneratorExpression node)
{
var collector = new ForeignReferenceCollector { CurrentType = TypeContaining(node) };
node.Accept(collector);
var processor = new GeneratorExpressionProcessor(Context, collector, node);
processor.Run();
ReplaceCurrentNode(processor.CreateEnumerableConstructorInvocation());
}
