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 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 WeakTypeDefinition ConvertToType <TBaking>(IAssembly <TBaking> assembly)
where TBaking : IBacking
{
// is it ok to create a scope here?
// yeah i think so
// it is not like you are going to be mocking scope
// i mean it is not a pure data objet
// what is the cost to passing it in?
var scope = new PopulatableScope();
foreach (var member in assembly.Scope.Members)
{
if (!scope.TryAddMember(DefintionLifetime.Instance, member.Key, new Box <IIsPossibly <WeakMemberDefinition> >(Possibly.Is(MemberDefinition(member)))))
{
throw new Exception("😨 member should not already exist");
}
}
//foreach (var type in assembly.Scope.Types)
//{
// if (type.Type is IInterfaceType interfaceType)
// {
// if (!scope.TryAddType(type.Key, new Box<IIsPossibly<IConvertableFrontendType<IVerifiableType>>>(Possibly.Is(TypeDefinition(interfaceType)))))
// {
// throw new Exception("type should not already exist");
// }
// }
//}
//foreach (var genericType in assembly.Scope.GenericTypes)
//{
// if (genericType.Type is IGenericInterfaceDefinition genericInterface)
// {
// if (!scope.TryAddGeneric(genericType.Key.Name, new Box<IIsPossibly<IFrontendGenericType>>(Possibly.Is(GenericTypeDefinition(genericInterface)))))
// {
// throw new Exception("type should not already exist");
// }
// }
//}
var resolvelizableScope = scope.GetResolvelizableScope();
var resolvableScope = resolvelizableScope.FinalizeScope();
return(new WeakTypeDefinition(resolvableScope, Possibly.Is(new ImplicitKey())));
}
