public IResolvelizeScope <WeakConstantBool, ISetUpValue> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var boolType = context.TypeProblem.CreateTypeReference(new NameKey("bool"));
var value = context.TypeProblem.CreateValue(boolType);
return(new ConstantBoolFinalizeScope(dub, value));
}
public IResolvelizeScope <WeakBlockDefinition, ISetUpScope> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var myScope = context.TypeProblem.CreateScope(scope);
return(new FinalizeScopeBlockDefinition(
myScope,
Elements.Select(x => x.Run(myScope, context)).ToArray()));
}
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 <WeakEmptyInstance, ISetUpValue> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var emptyType = context.TypeProblem.CreateTypeReference(new NameKey("empty"));
var value = context.TypeProblem.CreateValue(emptyType);
return(new EmptyInstanceFinalizeScope(value));
}
public IResolvelizeScope <WeakMemberReference, ISetUpMember> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var type = this.type.Run(scope, context);
var member = context.TypeProblem.CreateMember(memberName, type.SetUpSideNode.Key);
return(new MemberDefinitionFinalizeScope(
memberName,
isReadonly,
type,
memberDefinitionBox, member));
}
public IResolvelizeScope <IWeakTypeReference, ISetUpType> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var type = context.TypeProblem.CreateType(scope, key);
scope.Type(type);
// what the heck? these are not passed anywhere?
elements.Select(x => x.Run(type, context)).ToArray();
return(new TypeDefinitionFinalizeScope(
type,
definitionBox,
typeReferance,
key));
}
public IResolvelizeScope <TFrontendCodeElement> Run(IPopulatableScope scope, IPopulateScopeContext context)
{
return(new TrailingFinalizeScope(left.Run(scope, context), make));
}
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 <WeakPathOperation> Run(IPopulatableScope scope, IPopulateScopeContext context)
{
left.GetReturnedType().HasMember(new NameKey(name));
return(new WeakPathOperationFinalizeScope(
left.Run(scope, context),
name));
}
public IResolvelizeScope <WeakMemberReference, ISetUpMember> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var nameKey = new NameKey(memberName);
var member = context.TypeProblem.CreateMember(nameKey);
scope.Cast <ISetUpScope>().MightHaveMember(member);
return(new MemberFinalizeScope(nameKey, member));
}
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 <WeakTypeReference, ISetUpTypeReference> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var type = context.TypeProblem.CreateTypeReference(key);
return(new TypeReferanceFinalizeScope(
key, type));
}
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 <WeakConstantString, ISetUpValue> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var stringType = context.TypeProblem.CreateTypeReference(new NameKey("string"));
var value = context.TypeProblem.CreateValue(stringType);
return(new ConstantStringFinalizeScope(str, value));
}
public IResolvelizeScope <WeakGenericTypeDefinition, ISetUpType> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var myScope = context.TypeProblem.CreateGenericType(scope, nameKey, genericParameters.Select(x => x.Key).ToArray());
var nextLines = lines.Select(x => x.Run(myScope, context)).ToArray();
return(new GenericTypeDefinitionFinalizeScope(nameKey, myScope, box, genericParameters, nextLines));
}
public IResolvelizeScope <WeakModuleDefinition, ISetUpObject> Run(IDefineMembers scope, IPopulateScopeContext context)
{
var myScope = context.TypeProblem.CreateObject(scope);
return(new ModuleDefinitionFinalizeScope(
myScope,
elements.Select(x => x.Run(myScope, context)).ToArray(),
nameKey));
}
public IResolvelizeScope <TFrontendCodeElement, ISetUpValue> Run(IDefineMembers scope, IPopulateScopeContext context)
{
context.TypeProblem.CreateValue();
return(new BinaryFinalizeScope(
left.Run(scope, context),
right.Run(scope, context),
make));
}
