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); }