public Nothing MethodDefinition(IInternalMethodDefinition co)
{
var next = Push(co);
co.ParameterDefinition.Convert(next);
if (co.OutputType.SafeIs(out IInterfaceType type))
{
type.Convert(next);
}
foreach (var entry in co.Scope.Members.Values.Select(x => x.Value).Except(new[] { co.ParameterDefinition }))
{
lookup.AddLocal(OrType.Make <IEntryPointDefinition, IImplementationDefinition, IInternalMethodDefinition, IRootScope>(co), entry);
}
lookup.AddArgument(OrType.Make <IImplementationDefinition, IInternalMethodDefinition, IEntryPointDefinition>(co), co.ParameterDefinition);
if (extensionLookup.methodLookup.TryGetValue(co, out var found))
{
foreach (var member in found.closureMember.Keys)
{
lookup.AddField(OrType.Make <IEntryPointDefinition, IImplementationDefinition, IInternalMethodDefinition>(co), member);
}
}
next.Walk(co.Body);
return(new Nothing());
}
public Nothing MethodDefinition(IInternalMethodDefinition co)
{
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.methodLookup.TryGetValue(co, out var closure))
{
foreach (var member in closure.closureMember)
{
PopulateMap(typeBuilder, map, member);
}
}
realizedMethodLookup.Add(OrType.Make <IInternalMethodDefinition, IImplementationDefinition, IEntryPointDefinition>(co), new RealizedMethod(map, typeBuilder, constructor));
Walk(co.Body, co);
return(new Nothing());
}
public IReadOnlyList <IMemberDefinition> MethodDefinition(IInternalMethodDefinition method)
{
UpdateDefinedBy(method.Scope, OrType.Make <IInternalMethodDefinition, IImplementationDefinition, IEntryPointDefinition, IBlockDefinition, IRootScope, IObjectDefiniton>(method));
return(extensionLookup.methodLookup.GetOrAdd(method, () => {
var implementationClosure = Walk(method.Body);
return new WhoDefinedMember(implementationClosure
.Except(staticMembers)
.Except(method.Scope.Members.Select(x => x.Value.Value))
.ToDictionary(x => x, x => definedBy[x]));
}).closureMember.Keys.ToArray());
}
public IInterpetedOperation MethodDefinition(IInternalMethodDefinition codeElement)
{
if (backing.TryGetValue(codeElement, out var res))
{
return(res);
}
else
{
var op = new InterpetedMethodDefinition();
backing.Add(codeElement, op);
op.Init(
MemberDefinition(codeElement.ParameterDefinition).CastTo <InterpetedMemberDefinition>(),
codeElement.Body.Select(x => x.Convert(this)).ToArray(),
new InterpetedScopeTemplate(codeElement.Scope, codeElement.Scope.ToVerifiableType()),
codeElement.Returns().CastTo <IMethodType>());
return(op);
}
}
private IInterpetedOperation <IInterpetedAnyType> MethodDefinition <TIn, TOut>(IInternalMethodDefinition codeElement)
where TIn : class, IInterpetedAnyType
where TOut : class, IInterpetedAnyType
{
if (backing.TryGetValue(codeElement, out var res))
{
return(res);
}
else
{
var op = new InterpetedMethodDefinition <TIn, TOut>();
backing.Add(codeElement, op);
op.Init(
MemberDefinition(codeElement.ParameterDefinition).Cast <InterpetedMemberDefinition <TIn> >(),
codeElement.Body.Select(x => x.Convert(this)).ToArray(),
new InterpetedScopeTemplate(codeElement.Scope, codeElement.Scope.ToVerifiableType()),
codeElement.Returns().Cast <IMethodType>());
if (codeElement.IsEntryPoint)
{
// sloppy this should be on the prop
if (EntryPoint == null)
{
EntryPoint = op.Cast <IInterpetedOperation <IInterpetedMethod <IInterpedEmpty, IInterpedEmpty> > >();
}
else
{
new Exception("we already have an entry point");
}
}
return(op);
}
}
public IInterpetedOperation <IInterpetedAnyType> MethodDefinition(IInternalMethodDefinition codeElement)
{
var method = GetMethod(new Type[] { TypeMap.MapType(codeElement.InputType), TypeMap.MapType(codeElement.OutputType) }, nameof(MethodDefinition));
return(method.Invoke(this, new object[] { codeElement }).Cast <IInterpetedOperation <IInterpetedAnyType> >());
}
