public Nothing ImplementationDefinition(IImplementationDefinition codeElement)
{
var name = GenerateName();
var typeBuilder = moduleBuilder.DefineType(name);
var constructor = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new System.Type[] { });
var myConstructorIL = constructor.GetILGenerator();
myConstructorIL.Emit(OpCodes.Ldarg_0);
myConstructorIL.Emit(OpCodes.Call, typeof(object).GetConstructors().First());
myConstructorIL.Emit(OpCodes.Ret);
var map = new Dictionary <IMemberDefinition, IOrType <FieldInfo, (FieldInfo funcField, FieldInfo path), EnclosedObjectMember> >();
if (extensionLookup.implementationLookup.TryGetValue(codeElement, out var closure))
{
foreach (var member in closure.closureMember)
{
PopulateMap(typeBuilder, map, member);
}
}
{
var field = typeBuilder.DefineField(TranslateName(codeElement.ContextDefinition.Key.SafeCastTo(out NameKey _).Name), TranslateType(codeElement.ContextDefinition.Type), FieldAttributes.Public);
map[codeElement.ContextDefinition] = OrType.Make <FieldInfo, (FieldInfo funcField, FieldInfo path), EnclosedObjectMember>(field);
}
realizedMethodLookup.Add(OrType.Make <IInternalMethodDefinition, IImplementationDefinition, IEntryPointDefinition>(codeElement), new RealizedMethod(map, typeBuilder, constructor));
Walk(codeElement.MethodBody, codeElement);
return(new Nothing());
}
public IReadOnlyList <IMemberDefinition> ImplementationDefinition(IImplementationDefinition implementation)
{
UpdateDefinedBy(implementation.Scope, OrType.Make <IInternalMethodDefinition, IImplementationDefinition, IEntryPointDefinition, IBlockDefinition, IRootScope, IObjectDefiniton>(implementation));
return(extensionLookup.implementationLookup.GetOrAdd(implementation, () => {
var implementationClosure = Walk(implementation.MethodBody);
return new WhoDefinedMember(implementationClosure
.Except(staticMembers)
.Except(implementation.IntermediateScope.Members.Select(x => x.Value.Value))
.ToDictionary(x => x, x => definedBy[x]));
}).closureMember.Keys.ToArray());
}
public IInterpetedOperation ImplementationDefinition(IImplementationDefinition codeElement)
{
if (backing.TryGetValue(codeElement, out var res))
{
return(res);
}
else
{
var op = new InterpetedImplementationDefinition();
backing.Add(codeElement, op);
op.Init(
MemberDefinition(codeElement.ParameterDefinition).CastTo <InterpetedMemberDefinition>(),
MemberDefinition(codeElement.ContextDefinition).CastTo <InterpetedMemberDefinition>(),
codeElement.MethodBody.Select(x => x.Convert(this)).ToArray(),
new InterpetedScopeTemplate(codeElement.Scope, codeElement.Scope.ToVerifiableType()),
codeElement.Returns().CastTo <IMethodType>());
return(op);
}
}
private IInterpetedOperation <IInterpetedAnyType> ImplementationDefinition <TContext, TIn, TOut>(IImplementationDefinition codeElement)
where TContext : class, IInterpetedAnyType
where TIn : class, IInterpetedAnyType
where TOut : class, IInterpetedAnyType
{
if (backing.TryGetValue(codeElement, out var res))
{
return(res);
}
else
{
var op = new InterpetedImplementationDefinition <TContext, TIn, TOut>();
backing.Add(codeElement, op);
op.Init(
MemberDefinition(codeElement.ParameterDefinition).Cast <InterpetedMemberDefinition <TIn> >(),
MemberDefinition(codeElement.ContextDefinition).Cast <InterpetedMemberDefinition <TContext> >(),
codeElement.MethodBody.Select(x => x.Convert(this)).ToArray(),
new InterpetedScopeTemplate(codeElement.Scope, codeElement.Scope.ToVerifiableType()),
codeElement.Returns().Cast <IImplementationType>());
return(op);
}
}
public IInterpetedOperation <IInterpetedAnyType> ImplementationDefinition(IImplementationDefinition codeElement)
{
var method = GetMethod(new Type[] { TypeMap.MapType(codeElement.ContextDefinition.Type), TypeMap.MapType(codeElement.ParameterDefinition.Type), TypeMap.MapType(codeElement.OutputType) }, nameof(ImplementationDefinition));
return(method.Invoke(this, new object[] { codeElement }).Cast <IInterpetedOperation <IInterpetedAnyType> >());
}
