private static void Toke_CodeElements(IWrappedTestCase sample)
{
var elementMatchingContest = new ElementMatchingContext();
var scopePopulators = elementMatchingContest.ParseFile(sample.Token as FileToken);
var stack = new PopulatableScope();
var populateScopeContex = new PopulateScopeContext();
var referanceResolvers = scopePopulators.Select(populateScope => populateScope.Run(stack, populateScopeContex)).ToArray();
var resolvelizable = stack.GetResolvelizableScope();
var resolvalbe = resolvelizable.FinalizeScope();
var finalizeScopeContext = new FinalizeScopeContext();
var populateBoxes = referanceResolvers.Select(reranceResolver => reranceResolver.Run(resolvalbe, finalizeScopeContext)).ToArray();
var resolveReferanceContext = new ResolveReferanceContext();
var result = populateBoxes.Select(reranceResolver => reranceResolver.Run(resolvalbe, resolveReferanceContext)).ToArray().Single().GetOrThrow().Cast <WeakModuleDefinition>();
var target = sample.Module;
var context = TransformerExtensions.NewConversionContext();
var converted = result.Convert(context);
converted.ValueEqualOrThrow(target);
}
public IInterpetedResult <IInterpetedMember <TOut> > Invoke(IInterpetedMember <TIn> input)
{
var res = Scope.Create();
res.GetMember <TIn>(ParameterDefinition.Key).Cast <IInterpetedMemberSet <TIn> >().Set(input.Value);
var scope = Context.Child(res);
foreach (var line in Body)
{
var result = line.Interpet(scope);
if (result.IsReturn(out var resMember, out var value))
{
return(InterpetedResult.Create(resMember.Cast <IInterpetedMember <TOut> >()));
}
}
// does this work??
// wierd stuff around the way I am doing types
// life would be so much simpler if I just pulled it all out
// I should just pull it all out
// clearly I should
//
if (typeof(IInterpedEmpty).IsAssignableFrom(typeof(TOut)))
{
var hack = TypeManager.Empty();
return(InterpetedResult.Create(Member <TOut>(hack.Convert(TransformerExtensions.NewConversionContext()), hack.Cast <TOut>())));
}
throw new System.Exception("method did not return!");
}
public IOrType <IProject <TAssembly, TBacking>, IReadOnlyList <IError> > Parse <TAssembly, TBacking>(string text, IReadOnlyList <TAssembly> dependencies, string name)
where TAssembly : IAssembly <TBacking>
{
var tokenizer = new Tokenizer(StaticSymbolsRegistry.SymbolsRegistry.Symbols.Except(new[] { SymbolsRegistry.StaticSubtractSymbol }).ToArray());
var tokens = tokenizer.Tokenize(text);
var elementMatchingContest = new ElementMatchingContext();
var scopePopulator = elementMatchingContest.ParseFile(tokens);
var dependencyConverter = new DependencyConverter();
var problem = new Tpn.TypeProblem2(new WeakScopeConverter(), scopePopulator, prob => {
foreach (var dependency in dependencies)
{
var type = prob.builder.CreateTypeExternalType(prob.Dependency, new WeakTypeDefinitionConverter(), dependency.Scope);
foreach (var memberPair in dependency.Scope.Members)
{
var innerType = ConvertType(prob.builder, type, OrType.Make <IVerifiableType, IError>(memberPair.Type));
innerType.Switch(x =>
{
prob.builder.CreatePublicMember(type, type, memberPair.Key, OrType.Make <IKey, IError>(x));
}, y =>
{
prob.builder.CreatePublicMember(type, memberPair.Key, y);
});
}
prob.builder.CreatePrivateMember(prob.Dependency, dependency.Key, OrType.Make <Tpn.TypeProblem2.MethodType, Tpn.TypeProblem2.Type, Tpn.TypeProblem2.Object, Tpn.TypeProblem2.OrType, Tpn.TypeProblem2.InferredType, Tpn.TypeProblem2.GenericTypeParameter, IError>(type));
}
});
var populateScopeContex = new SetUpContext(problem.builder);
var referanceResolver = scopePopulator.Run(problem.ModuleRoot, populateScopeContex).Resolve;
var solution = problem.Solve();
var rootScope = referanceResolver.Run(solution, new List <Tpn.ITypeProblemNode>()
{
problem.Dependency,
problem.ModuleRoot
}).GetValue();
var errors = rootScope.Validate().ToArray();
if (errors.Any())
{
return(OrType.Make <IProject <TAssembly, TBacking>, IReadOnlyList <IError> >(errors));
}
var dependencyScope = problem.Dependency.Converter.Convert(solution, problem.Dependency, Array.Empty <Tpn.ITypeProblemNode>()).Is2OrThrow();
var context = TransformerExtensions.NewConversionContext();
return(OrType.Make <IProject <TAssembly, TBacking>, IReadOnlyList <IError> >(new Project <TAssembly, TBacking>(rootScope.Convert(context), dependencies, dependencyScope.Convert(context))));
}
internal static IRootScope Convert(FileToken fileToken)
{
var result = ConvertToWeak(fileToken);
var context = TransformerExtensions.NewConversionContext();
var converted = result.Convert(context);
return(converted);
}
public static IProject <TBacking> Parse <TBacking>(string text, IReadOnlyList <IAssembly <TBacking> > dependencies, string name)
where TBacking : IBacking
{
var tokenizer = new Parser.Tokenizer(StaticSymbolsRegistry.SymbolsRegistry.Symbols.ToArray());
var tokens = tokenizer.Tokenize(text);
var elementMatchingContest = new ElementMatchingContext();
var scopePopulators = elementMatchingContest.ParseFile(tokens);
var dependencyConverter = new DependencyConverter();
var dependendcyScope = new PopulatableScope();
foreach (var dependency in dependencies)
{
var convertedDependency = dependencyConverter.ConvertToType <TBacking>(dependency);
if (!dependendcyScope.TryAddMember(DefintionLifetime.Instance, dependency.Key, new Box <IIsPossibly <WeakMemberDefinition> >(Possibly.Is(
new WeakMemberDefinition(true, dependency.Key, Possibly.Is(
new WeakTypeReference(
Possibly.Is(
new Box <IIsPossibly <IConvertableFrontendType <IVerifiableType> > >(
Possibly.Is <IConvertableFrontendType <IVerifiableType> >(
convertedDependency))))))))))
{
throw new Exception("could not add dependency!");
}
}
var scope = new PopulatableScope(dependendcyScope);
var populateScopeContex = new PopulateScopeContext();
var referanceResolvers = scopePopulators.Select(populateScope => populateScope.Run(scope, populateScopeContex)).ToArray();
var resolvableDependencyScope = dependendcyScope.GetResolvelizableScope().FinalizeScope();
var resolvalbe = scope.GetResolvelizableScope().FinalizeScope(resolvableDependencyScope);
var finalizeScopeContext = new FinalizeScopeContext();
var populateBoxes = referanceResolvers.Select(reranceResolver => reranceResolver.Run(resolvalbe, finalizeScopeContext)).ToArray();
var resolveReferenceContext = new ResolveReferanceContext();
var module = new WeakModuleDefinition(
resolvalbe,
populateBoxes.Select(reranceResolver => reranceResolver.Run(resolvalbe, resolveReferenceContext)).ToArray(),
new NameKey(name));
var resolveReferanceContext = new ResolveReferanceContext();
var context = TransformerExtensions.NewConversionContext();
return(new Project <TBacking>(module.Convert <IModuleDefinition>(context), dependencies));
}
public IInterpetedResult <IInterpetedMember <IInterpetedScope> > Interpet(InterpetedContext interpetedContext)
{
var scope = ScopeTemplate.Create();
var context = interpetedContext.Child(scope);
foreach (var line in StaticInitialization)
{
line.Interpet(context);
}
return(InterpetedResult.Create(TypeManager.Member(scope.Convert(TransformerExtensions.NewConversionContext()), scope)));
}
public IInterpetedResult <IInterpetedMember <IInterpetedMethod <TIn, TOut> > > Interpet(InterpetedContext interpetedContext)
{
var thing = TypeManager.InternalMethod <TIn, TOut>(
ParameterDefinition,
Body,
interpetedContext,
Scope,
MethodType);
return(InterpetedResult.Create(
TypeManager.Member(
thing.Convert(TransformerExtensions.NewConversionContext()),
thing)));
}
public IBuildIntention <IImplementationDefinition> GetBuildIntention(IConversionContext context)
{
var(toBuild, maker) = ImplementationDefinition.Create();
return(new BuildIntention <IImplementationDefinition>(toBuild, () =>
{
maker.Build(
TransformerExtensions.Convert <IVerifiableType>(OutputType.GetOrThrow(), context),
ContextDefinition.IfIs(x => x.GetValue()).GetOrThrow().Convert(context),
ParameterDefinition.IfIs(x => x.GetValue()).GetOrThrow().Convert(context),
Scope.Convert(context),
MethodBody.Select(x => x.GetOrThrow().ConvertElementOrThrow(context)).ToArray(),
StaticInitialzers.Select(x => x.ConvertElementOrThrow(context)).ToArray());
}));
}
public bool TrySet(IInterpetedAnyType o)
{
// having to find TransformerExtensions.NewConversionContext is cognative load
// and I always use TransformerExtensions.NewConversionContext
// what even is the point of passing it
var incommingType = o.Convert(TransformerExtensions.NewConversionContext());
// also don't like passing in false here
// forces me to know too much about that is going on under the hood
if (VerifiableType.TheyAreUs(incommingType, false))
{
Set(o.Cast <T>());
return(true);
}
return(false);
}
public IInterpetedResult <IInterpetedMember <IInterpetedMethod <TMethodIn, TMethodOut> > > Invoke(IInterpetedMember <TIn> input)
{
var context = InterpetedContext.Child(TypeManager.InstanceScope((contextDefinition.Key, input)));
var thing = InternalMethod <TMethodIn, TMethodOut>(
ParameterDefinition,
Body,
context,
Scope,
MethodType.CreateAndBuild(
ImplementationType.InputType,
ImplementationType.OutputType));
return
(InterpetedResult.Create(
Member(
thing.Convert(TransformerExtensions.NewConversionContext()),
thing)));
}
public IInterpetedResult <IInterpetedMember> Invoke(IInterpetedMember input)
{
var context = InterpetedContext.Child(TypeManager.InstanceScope((contextDefinition.Key, input)));
ImplementationType.OutputType.SafeIs(out MethodType outputMethod);
var thing = InternalMethod(
ParameterDefinition,
Body,
context,
Scope,
Tac.Model.Instantiated.MethodType.CreateAndBuild(
outputMethod.InputType,
outputMethod.OutputType));
return
(InterpetedResult.Create(
Member(
thing.Convert(TransformerExtensions.NewConversionContext()),
thing)));
}
public void Test()
{
var testCase = new MirrorPointImplementation();
var conversionContext = new Definitions();
var module = testCase.RootScope.Convert(conversionContext).SafeCastTo(out Tac.Backend.Interpreted.Syntaz_Model_Interpeter.Elements.InterpetedRootScope _);
var(scope, res) = module.InterpetWithExposedScope(InterpetedContext.Root());
Assert.False(res.IsReturn(out var _, out var value));
var implementation = scope.GetMember(new NameKey("mirror")).Value.Has <IInterpetedMethod>();
var context = TypeManager.InstanceScope(
(new NameKey("x"), TypeManager.AnyMember(TypeManager.Double(5))),
(new NameKey("y"), TypeManager.AnyMember(TypeManager.Double(7))));
{
Assert.False(implementation.Invoke(TypeManager.Member(context.Convert(TransformerExtensions.NewConversionContext()), context)).IsReturn(out var _, out var method));
method !.Value.Has <IInterpetedMethod>().Invoke(TypeManager.EmptyMember(TypeManager.Empty()));
}
Assert.Equal(7, context.GetMember(new NameKey("x")).Value.Has <IBoxedDouble>().Value);
Assert.Equal(5, context.GetMember(new NameKey("y")).Value.Has <IBoxedDouble>().Value);
{
Assert.False(implementation.Invoke(TypeManager.Member(context.Convert(TransformerExtensions.NewConversionContext()), context)).IsReturn(out var _, out var method));
method !.Value.Has <IInterpetedMethod>().Invoke(TypeManager.EmptyMember(TypeManager.Empty()));
}
Assert.Equal(5, context.GetMember(new NameKey("x")).Value.Has <IBoxedDouble>().Value);
Assert.Equal(7, context.GetMember(new NameKey("y")).Value.Has <IBoxedDouble>().Value);
}
public IInterpetedResult <IInterpetedMember <IInterpetedMethod <TIn, TOut> > > Interpet(InterpetedContext interpetedContext)
{
var thing = TypeManager.ExternalMethod(Backing, MethodType);
return(InterpetedResult.Create(TypeManager.Member(thing.Convert(TransformerExtensions.NewConversionContext()), thing)));
}
public IInterpetedResult <IInterpetedMember> Invoke(IInterpetedMember input)
{
var thing = Backing(input.Value);
return(InterpetedResult.Create(Member(thing.Convert(TransformerExtensions.NewConversionContext()), thing)));
}
public void Test()
{
var testCase = new MirrorPointImplementation();
var conversionContext = new Definitions();
var module = testCase.Module.Convert(conversionContext);
var res = module.Interpet(InterpetedContext.Root());
Assert.False(res.IsReturn(out var _, out var value));
var scope = value.Value.Cast <IInterpetedScope>();
var implementation = scope.GetMember <IInterpetedAnyType>(new NameKey("mirror")).Value.Cast <IInterpetedImplementation <IInterpetedScope, IInterpedEmpty, IInterpedEmpty> >();
var context = TypeManager.InstanceScope(
(new NameKey("x"), TypeManager.AnyMember(TypeManager.Double(5))),
(new NameKey("y"), TypeManager.AnyMember(TypeManager.Double(7))));
{
Assert.False(implementation.Invoke(TypeManager.Member <IInterpetedScope>(context.Convert(TransformerExtensions.NewConversionContext()), context)).IsReturn(out var _, out var method));
method.Value.Invoke(TypeManager.EmptyMember(TypeManager.Empty()));
}
Assert.Equal(7, context.GetMember <IInterpetedAnyType>(new NameKey("x")).Value.Cast <IBoxedDouble>().Value);
Assert.Equal(5, context.GetMember <IInterpetedAnyType>(new NameKey("y")).Value.Cast <IBoxedDouble>().Value);
{
Assert.False(implementation.Invoke(TypeManager.Member <IInterpetedScope>(context.Convert(TransformerExtensions.NewConversionContext()), context)).IsReturn(out var _, out var method));
method.Value.Invoke(TypeManager.EmptyMember(TypeManager.Empty()));
}
Assert.Equal(5, context.GetMember <IInterpetedAnyType>(new NameKey("x")).Value.Cast <IBoxedDouble>().Value);
Assert.Equal(7, context.GetMember <IInterpetedAnyType>(new NameKey("y")).Value.Cast <IBoxedDouble>().Value);
}
