public IResolvelizeScope <WeakImplementationDefinition, ISetUpMethod> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var outer = context.TypeProblem.CreateMethod(scope);
var inner = context.TypeProblem.CreateMethod(outer);
var realizeContext = contextDefinition.Run(outer, context);
var outerResultMember = context.TypeProblem.CreateMember(new ImplicitKey());
var outerMethod = outer.SetInputOutput(realizeContext.SetUpSideNode, outerResultMember);
var parameter = parameterDefinition.Run(scope, context);
var outputResolves = output.Run(scope, context);
var innerMethod = inner.SetInputOutput(parameter.SetUpSideNode, outputResolves.SetUpSideNode);
outerMethod.AssignToReturns(innerMethod);
return(new ImplementationDefinitionFinalizeScope(
outerMethod,
realizeContext,
parameter,
elements.Select(y => y.Run(innerMethod, context)).ToArray(),
outputResolves
));
}
public IResolvelizeScope <WeakAssignOperation> Run(IPopulatableScope scope, IPopulateScopeContext context)
{
left.GetReturnedType().AcceptsType(right.GetReturnedType());
return(new WeakAssignOperationFinalizeScope(
left.Run(scope, context),
right.Run(scope, context)));
}
public IResolvelizeScope <WeakPathOperation> Run(IPopulatableScope scope, IPopulateScopeContext context)
{
left.GetReturnedType().HasMember(new NameKey(name));
return(new WeakPathOperationFinalizeScope(
left.Run(scope, context),
name));
}
public IResolvelizeScope <TFrontendCodeElement, ISetUpValue> Run(IDefineMembers scope, IPopulateScopeContext context)
{
context.TypeProblem.CreateValue();
return(new BinaryFinalizeScope(
left.Run(scope, context),
right.Run(scope, context),
make));
}
public IResolvelizeScope <WeakMethodDefinition, ISetUpMethod> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var methodBuilder = context.TypeProblem.CreateMethod(scope);
var parameterResolve = parameterDefinition.Run(methodBuilder, context);
methodBuilder.Member(parameterResolve.SetUpSideNode);
var outputResolve = parameterDefinition.Run(methodBuilder, context);
methodBuilder.Member(outputResolve.SetUpSideNode);
var method = methodBuilder.SetInputOutput(parameterResolve.SetUpSideNode, outputResolve.SetUpSideNode);
return(new MethodDefinitionFinalizeScope(
method,
parameterResolve,
elements.Select(x => x.Run(method, context)).ToArray(),
outputResolve,
isEntryPoint));
}
public IResolvelizeScope <IWeakTypeReference> Run(IPopulatableScope scope, IPopulateScopeContext context)
{
// TODO
// this is something I don't much like
// right runs first because of assign
// in assign you might have something like
// method [int;int] input { input < ? 2 if { 1 return; } else { input - 1 > fac * input return; } } =: fac
// if the left runs first than fac will not be found
// and so it will add it to the scope
// but if the right is run first
// fac works
// if I add an assign that goes the other way...
// this will break
// part of me just thinks
// force 'var' on member definition
return(new BinaryFinalizeScope(
left.Run(scope, context),
right.Run(scope, context),
make));
}
public IResolvelizeScope <TFrontendCodeElement> Run(IPopulatableScope scope, IPopulateScopeContext context)
{
return(new TrailingFinalizeScope(left.Run(scope, context), make));
}