public IBox <WeakGenericTypeDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
// uhhh it is werid that I have to do this
lines.Select(x => x.TransformInner(y => y.Run(context, stack.Add(myScope)))).ToArray();
return(new Box <WeakGenericTypeDefinition>(myScope.Converter.Convert(context, myScope, stack).Is2OrThrow()));
}
public IOrType <WeakObjectDefinition, WeakRootScope> Convert(Tpn.TypeSolution typeSolution, Tpn.TypeProblem2.Object from, IEnumerable <Tpn.ITypeProblemNode> context)
{
return(OrType.Make <WeakObjectDefinition, WeakRootScope>(new WeakRootScope(
typeSolution.GetObjectType(from, context),
assigns,
entryPoint)));
}
// do these really need to be IBox? they seeme to generally be filled...
// mayble IPossibly...
public IBox <WeakObjectDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
var finalElements = nextElements.Select(x => x.SwitchReturns <IOrType <IBox <WeakAssignOperation>, IError> >(
y => {
var res = y.Run(context, stack.Add(myScope)).GetValue();
if (res is WeakAssignOperation weakAssign)
{
return(OrType.Make <IBox <WeakAssignOperation>, IError>(new Box <WeakAssignOperation>(weakAssign)));
}
else
{
return(OrType.Make <IBox <WeakAssignOperation>, IError>(Error.Other("lines in an object must me assignments")));
}
},
y => OrType.Make <IBox <WeakAssignOperation>, IError>(y))).ToArray();
box.Fill(finalElements);
var objectOr = myScope.Converter.Convert(context, myScope, stack);//; context.GetObject(myScope);
if (objectOr.Is1(out var v1))
{
return(new Box <WeakObjectDefinition>(v1));
}
throw new Exception("wrong or");
}
public IBox <TFrontendCodeElement> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
var res = make(
left.TransformInner(x => x.Run(context, stack)),
right.TransformInner(x => x.Run(context, stack)));
return(res);
}
public IBox <WeakMemberReference> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
if (context.TryGetMember(stack.Last().SafeCastTo(out Tpn.IStaticScope _) /* this is a lazy cast*/, memberName, stack, out var member))
{
return(new Box <WeakMemberReference>(new WeakMemberReference(new Box <IOrType <WeakMemberDefinition, IError> >(member)))); // don't love the Is1OrThrow here
}
throw new Exception("I don't think this should happen, if it does I guess we need to put an IError somewhere");
}
public IFrontendType <IVerifiableType> Convert(Tpn.TypeSolution typeSolution, Tpn.TypeProblem2.OrType from, IEnumerable <Tpn.ITypeProblemNode> context)
{
// TODO
// it is a bit werid that this return a type reference
// structaully a WeakTypeReference is just a type-or-error
// and that is what I need here
return(new WeakTypeReference(typeSolution.GetOrType(from, context)));
//return typeSolution.GetOrType(from, context);
}
public MethodType Convert(Tpn.TypeSolution typeSolution, Tpn.TypeProblem2.MethodType from, IEnumerable <Tpn.ITypeProblemNode> context)
{
return(typeSolution.GetMethodType(from, context).Is1OrThrow());
// I don't think this is safe see:
// {D27D98BA-96CF-402C-824C-744DACC63FEE}
//return
// new MethodType(
// typeSolution.GetType(OrType.Make<Tpn.IVirtualFlowNode,IError>(typeSolution.GetFlowNode(from.Input.GetOrThrow()))),
// typeSolution.GetType(OrType.Make<Tpn.IVirtualFlowNode, IError>(typeSolution.GetFlowNode(from.Returns.GetOrThrow()))));
}
public IBox <WeakImplementationDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
linesBox.Fill(nextElements.Select(x => x.TransformInner(y => y.Run(context, stack.Add(outer).Add(inner)))).ToArray());
var res = outer.Converter.Convert(context, outer, stack);
if (res.Is2(out var v2))
{
return(new Box <WeakImplementationDefinition>(v2));
}
throw new Exception("wrong!");
}
public IBox <WeakMethodDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
box.Fill(nextElements.Select(x => x.TransformInner(y => y.Run(context, stack.Add(method)))).ToArray());
var res = method.Converter.Convert(context, method, stack);
if (res.Is1(out var v1))
{
return(new Box <WeakMethodDefinition>(v1));
}
throw new Exception("wrong!");
}
public IBox <WeakEntryPointDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
var finalForm = converted.Select(x => x.TransformInner(y => y.Run(context, stack.Add(scope)))).ToArray();
box.Fill(finalForm);
var res = scope.Converter.Convert(context, scope, stack);
if (res.Is3(out var v3))
{
return(new Box <WeakEntryPointDefinition>(v3));
}
throw new Exception("wrong!");
}
// do these really need to be IBox? they seeme to generally be filled...
// mayble IPossibly...
public IBox <WeakRootScope> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
assignmentsBox.Fill(nextElements.Select(x => x.TransformInner(y => y.Run(context, stack.Add(myScope)))).ToArray());
entryBox.Fill(nextEntry.TransformInner(x => x.Run(context, stack.Add(myScope))));
ranTypes.Select(x => x.TransformInner(y => y.Run(context, stack.Add(myScope)))).ToArray();
ranGenericTypes.Select(x => x.TransformInner(y => y.Run(context, stack.Add(myScope)))).ToArray();
var objectOr = myScope.Converter.Convert(context, myScope, stack);
if (objectOr.Is2(out var v2))
{
return(new Box <WeakRootScope>(v2));
}
throw new Exception("wrong or");
}
public IBox <WeakPathOperation> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
var leftRes = left.TransformInner(x => x.Run(context, stack));
var res = new Box <WeakPathOperation>(new WeakPathOperation(
leftRes,
member.SwitchReturns(
x => OrType.Make <IBox <IFrontendCodeElement>, IError>(new FuncBox <IFrontendCodeElement>(() => {
// TODO
// I don't I should need to ask the solution for the member def, the left's return type should give me that
// why doesn't TryGetMember return a member definition!
// probably because of Ortypes
// I thinkg TypeSolution TryGetMember is really just for TypeProblem2.Method and TypeProblem2.Scope
// maybe I am thinking about this wrong and scopeCache only need to exist during TypeSolution's constructor
var returns = leftRes.Is1OrThrow().GetValue().CastTo <IReturn>().Returns().Is1OrThrow();
// smells
if (returns.SafeIs(out Tac.SyntaxModel.Elements.AtomicTypes.RefType refType))
{
returns = refType.inner.Is1OrThrow();
}
var memberDef = returns.TryGetMember(key, new List <(IFrontendType <IVerifiableType>, IFrontendType <IVerifiableType>)>());
//context.TryGetMember(,key)
return(new WeakMemberReference(new Box <IOrType <WeakMemberDefinition, IError> >(memberDef.Is1OrThrow())));
//WeakMemberReference memberRef = leftRes.Is1OrThrow().GetValue().CastTo<WeakMemberReference>();
//var memberDef = memberRef.MemberDefinition.GetValue().Type.GetValue().Is1OrThrow().TryGetMember(key, new List<(IFrontendType<IVerifiableType>, IFrontendType<IVerifiableType>)>());
////context.TryGetMember(,key)
//return new WeakMemberReference(new Box<WeakMemberDefinition>(memberDef.Is1OrThrow().Is1OrThrow()));
})),
y => OrType.Make <IBox <IFrontendCodeElement>, IError>(Error.Cascaded("", y)))));
return(res);
}
public IBox <WeakEmptyInstance> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
return(new Box <WeakEmptyInstance>(new WeakEmptyInstance()));
}
public IBox <WeakRealizeMethodOperation> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
throw new NotImplementedException();
}
public IOrType <WeakTypeDefinition, WeakGenericTypeDefinition, Tac.SyntaxModel.Elements.AtomicTypes.IPrimitiveType> Convert(Tpn.TypeSolution typeSolution, Tpn.TypeProblem2.Type from, IEnumerable <Tpn.ITypeProblemNode> context)
{
return(OrType.Make <WeakTypeDefinition, WeakGenericTypeDefinition, Tac.SyntaxModel.Elements.AtomicTypes.IPrimitiveType>(PrimitiveType));
}
public IOrType <WeakTypeDefinition, WeakGenericTypeDefinition, Tac.SyntaxModel.Elements.AtomicTypes.IPrimitiveType> Convert(Tpn.TypeSolution typeSolution, Tpn.TypeProblem2.Type from, IEnumerable <Tpn.ITypeProblemNode> context)
{
//if (typeParmereIndex.Is(out var index)) {
// new GenericTypeParameterPlacholder(index, typeSolution.);
//}
//var placeHolders = Tpn.TypeSolution.HasPlacholders(from);
if (from.Generics.Any())
{
return(OrType.Make <WeakTypeDefinition, WeakGenericTypeDefinition, Tac.SyntaxModel.Elements.AtomicTypes.IPrimitiveType>(
new WeakGenericTypeDefinition(
from.Key,
typeSolution.GetHasMemberType(from, context),
from.Generics.Select(x => typeSolution.GetGenericPlaceholder(x.Value, context)).ToArray())));// from.Generics.Select(x=>Possibly.Is< IGenericTypeParameterPlacholder>(x.Value.Converter.Convert(typeSolution,x.Value))).ToArray()));
}
return(OrType.Make <WeakTypeDefinition, WeakGenericTypeDefinition, Tac.SyntaxModel.Elements.AtomicTypes.IPrimitiveType>(
new WeakTypeDefinition(typeSolution.GetHasMemberType(from, context))));//, key ?
}
public IBox <WeakBlockDefinition> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
box.Fill(nextElements.Select(x => x.TransformInner(y => y.Run(context, stack.Add(myScope)))).ToArray());
return(new Box <WeakBlockDefinition>(myScope.Converter.Convert(context, myScope, stack).Is1OrThrow()));
}
public IOrType <WeakBlockDefinition, WeakScope, WeakEntryPointDefinition> Convert(Tpn.TypeSolution typeSolution, Tpn.TypeProblem2.Scope from, IEnumerable <Tpn.ITypeProblemNode> context)
{
return(OrType.Make <WeakBlockDefinition, WeakScope, WeakEntryPointDefinition>(typeSolution.GetWeakScope(from, context)));
}
public IOrType <WeakMethodDefinition, WeakImplementationDefinition, WeakEntryPointDefinition, WeakGenericMethodDefinition> Convert(Tpn.TypeSolution typeSolution, Tpn.TypeProblem2.Method from, IEnumerable <Tpn.ITypeProblemNode> context)
{
var inputKey = from.PrivateMembers.Single(x => x.Value == from.Input.GetOrThrow());
var scope = typeSolution.GetWeakScope(from, context);
return(OrType.Make <WeakMethodDefinition, WeakImplementationDefinition, WeakEntryPointDefinition, WeakGenericMethodDefinition>(new WeakEntryPointDefinition(
typeSolution.GetType(from.Returns.GetOrThrow(), context),
scope.membersList.Single(x => x.Key.Equals(inputKey.Key)),
body,
OrType.Make <WeakScope, IError>(scope),
Array.Empty <IIsPossibly <IConvertableFrontendCodeElement <ICodeElement> > >())));
}
public IOrType <WeakBlockDefinition, WeakScope, WeakEntryPointDefinition> Convert(Tpn.TypeSolution typeSolution, Tpn.TypeProblem2.Scope from, IEnumerable <Tpn.ITypeProblemNode> context)
{
return(OrType.Make <WeakBlockDefinition, WeakScope, WeakEntryPointDefinition>(
new WeakBlockDefinition(
body,
OrType.Make <WeakScope, IError>(typeSolution.GetWeakScope(from, context)),
Array.Empty <IIsPossibly <IFrontendCodeElement> >())));
}
public IBox <WeakConstantNumber> Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
return(new Box <WeakConstantNumber>(new WeakConstantNumber(Possibly.Is(dub))));
}
public IBox <IFrontendType <IVerifiableType> > Run(Tpn.TypeSolution context, IEnumerable <Tpn.ITypeProblemNode> stack)
{
// Is1OrThrow is wrong here!
// this has to pass the or type onwards
return(new FuncBox <IFrontendType <IVerifiableType> >(() => context.GetType(type, stack).Is1OrThrow()));
}
public IFrontendType <IVerifiableType> Convert(Tpn.TypeSolution typeSolution, Tpn.TypeProblem2.TypeReference from, IEnumerable <Tpn.ITypeProblemNode> context)
{
// I don't think this is safe see:
// {D27D98BA-96CF-402C-824C-744DACC63FEE}
return(new WeakTypeReference(typeSolution.GetType(from, context)));
}
