public IIsPossibly <IWeakTypeReference> Run(IResolvableScope scope, IResolveReferenceContext context)
{
var res = make(
left.Run(scope, context),
right.Run(scope, context));
return(res);
}
public IIsPossibly <WeakPathOperation> Run(IResolvableScope scope, IResolveReferenceContext context)
{
var res = Possibly.Is(new WeakPathOperation(
left.Run(scope, context),
Possibly.Is(new WeakMemberReference(left.GetReturnedType().GetMemberDefinition(new NameKey(name))))));
return(res);
}
public IIsPossibly <TFrontendCodeElement> Run(IResolvableScope scope, IResolveReferenceContext context)
{
var res = make(
left.Run(scope, context),
right.Run(scope, context));
return(res);
}
public IIsPossibly <WeakAssignOperation> Run(IResolvableScope scope, IResolveReferenceContext context)
{
var leftRes = left.Run(scope, context);
var res = Possibly.Is(new WeakAssignOperation(
leftRes,
right.Run(scope, context)));
return(res);
}
public IIsPossibly <WeakBlockDefinition> Run(IResolvableScope _, IResolveReferenceContext context)
{
return
(Possibly.Is(
new WeakBlockDefinition(
resolveReferance.Select(x => x.Run(scope, context)).ToArray(),
scope,
new IIsPossibly <IConvertableFrontendCodeElement <ICodeElement> > [0])));
}
public IIsPossibly <WeakObjectDefinition> Run(IResolvableScope _, IResolveReferenceContext context)
{
var innerRes = new WeakObjectDefinition(
scope,
elements.Select(x => x.Run(scope, context).Cast <IIsPossibly <WeakAssignOperation> >()).ToArray());
var res = Possibly.Is(innerRes);
return(res);
}
public IIsPossibly <WeakMethodDefinition> Run(IResolvableScope _, IResolveReferenceContext context)
{
return
(Possibly.Is(
new WeakMethodDefinition(
output.Run(methodScope, context),
parameter.Run(methodScope, context).IfIs(x => x.MemberDefinition),
lines.Select(x => x.Run(methodScope, context)).ToArray(),
methodScope,
new IIsPossibly <IConvertableFrontendCodeElement <ICodeElement> > [0], isEntryPoint)));
}
public IIsPossibly <WeakModuleDefinition> Run(IResolvableScope _, IResolveReferenceContext context)
{
var innerRes = new WeakModuleDefinition(
scope,
resolveReferance.Select(x => x.Run(scope, context)).ToArray(),
nameKey);
var res = Possibly.Is(innerRes);
return(res);
}
public IIsPossibly <WeakMemberReference> Run(IResolvableScope scope, IResolveReferenceContext context)
{
memberDefinitionBox.Fill(
Possibly.Is(
new WeakMemberDefinition(
isReadonly,
memberName,
type.Run(scope, context))));
return(Possibly.Is(new WeakMemberReference(Possibly.Is(memberDefinitionBox))));
}
public IIsPossibly <WeakGenericTypeDefinition> Run(IResolvableScope _, IResolveReferenceContext context)
{
// hmm getting the template down here is hard
// scope mostly comes from context
// why is that?
var nextLines = lines.Select(x => x.Run(this.scope, context)).ToArray();
return(box.Fill(Possibly.Is(new WeakGenericTypeDefinition(
Possibly.Is(nameKey),
this.scope,
genericParameters.Select(x => Possibly.Is(x)).ToArray()))));
}
public IIsPossibly <WeakConstantString> Run(IResolvableScope scope, IResolveReferenceContext context)
{
return(Possibly.Is(new WeakConstantString(Possibly.Is(str))));
}
public IIsPossibly <WeakTypeReference> Run(IResolvableScope scope, IResolveReferenceContext context)
{
return(Possibly.Is(new WeakTypeReference(scope.PossiblyGetType(key))));
}
public IIsPossibly <WeakConstantBool> Run(IResolvableScope scope, IResolveReferenceContext context)
{
return(Possibly.Is(new WeakConstantBool(Possibly.Is(dub))));
}
public IIsPossibly <WeakEmptyInstance> Run(IResolvableScope _, IResolveReferenceContext context)
{
return(Possibly.Is(new WeakEmptyInstance()));
}
public IIsPossibly <WeakImplementationDefinition> Run(IResolvableScope _, IResolveReferenceContext context)
{
var innerRes = new WeakImplementationDefinition(
contextDefinition.Run(methodScope, context).IfIs(x => x.MemberDefinition),
parameterDefinition.Run(methodScope, context).IfIs(x => x.MemberDefinition),
output.Run(methodScope, context),
elements.Select(x => x.Run(methodScope, context)).ToArray(),
methodScope,
new IConvertableFrontendCodeElement <ICodeElement> [0]);
var res = Possibly.Is(innerRes);
return(res);
}
public IIsPossibly <IWeakTypeReference> Run(IResolvableScope _, IResolveReferenceContext context)
{
definitionBox.Fill(Possibly.Is(new WeakTypeDefinition(resolvableScope, Possibly.Is(key))));
return(Possibly.Is(typeReferance));
}
public IIsPossibly <WeakMemberReference> Run(IResolvableScope scope, IResolveReferenceContext context)
{
return(Possibly.Is(new WeakMemberReference(scope.PossiblyGetMember(false, key))));
}
