public void IfPossibleBuildPhase2(ILConversion conversion, ConvertedTypeDefinition_I converted)
{
if (converted.SourceTypeReference.FullName ==
"Root.Code.Containers.E01D.Runtimic.RuntimicContainerB_I`1"
)
{
// Does get here
}
// There is not just building work to be done. There is actually pre and post being working to be done. The dependency check is to verify if there is any
// post build work to be done.
List <ConvertedTypeDefinition_I> dependencies = CheckForBuildDependencies(conversion, converted, BuildPhaseKind.MembersDefined);
if (dependencies.Count < 1)
{
BuildPhase2AndDependencies(conversion, converted);
}
else
{
for (int i = 0; i < dependencies.Count; i++)
{
var dependency = dependencies[i];
converted.ConversionState.Phase2Dependencies.Add(dependency);
dependency.ConversionState.Phase2Dependents.Add(converted);
}
}
}
public ILConversionResult Convert(ILConversion conversion, Type[] types)
{
conversion.Input.TypesToConvert = types;
conversion.Input.Options = CreateDefaultConversionOptions();
return(Convert(conversion));
}
public ILConversionResult Convert(ILConversion conversion, TypeReference typeReference)
{
conversion.Input.TypeReferencesToConvert = new [] { typeReference };
conversion.Input.Options = CreateDefaultConversionOptions();
return(Convert(conversion));
}
private bool BuildRoutineBody(ILConversion conversion, ConvertedRoutineMask_I routine)
{
if (!routine.MethodReference.IsDefinition)
{
return(true);
}
var methodDefinition = (MethodDefinition)routine.MethodReference;
if (!methodDefinition.HasBody)
{
return(true);
}
if (!(routine is ConvertedRoutine convertedRoutine))
{
throw new Exception($"Expected the routine to be of type type {typeof(ConvertedRoutine)}");
}
if (convertedRoutine.EmitState == null)
{
convertedRoutine.EmitState = new ConvertedRoutineEmitState();
}
if (routine.MethodReference.FullName ==
"T Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Instructions.InstructionTest_CastClass::Get(Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Types.Interface1)"
)
{
}
if (!WithoutILGenerator.BuildBody(conversion, convertedRoutine))
{
return(false);
}
if (routine is ConvertedEmittedConstructor emittedConstructor)
{
var emitState = convertedRoutine.EmitState.Body;
emittedConstructor.ConstructorBuilder.InitLocals = methodDefinition.Body.InitLocals;
emittedConstructor.ConstructorBuilder.SetMethodBody(
emitState.InstructionStream.Buffer,
emitState.MaxStack,
emitState.LocalSignature,
emitState.ExceptionHandlers,
emitState.TokenFixups);
}
else if (routine is ConvertedBuiltMethod emittedMethod)
{
var emitState = convertedRoutine.EmitState.Body;
emittedMethod.MethodBuilder.InitLocals = methodDefinition.Body.InitLocals;
emittedMethod.MethodBuilder.SetMethodBody(
emitState.InstructionStream.Buffer,
emitState.MaxStack,
emitState.LocalSignature,
emitState.ExceptionHandlers,
emitState.TokenFixups);
}
return(true);
}
public ILConversionResult Convert(ILConversion conversion, Assembly[] assemblies, ILConversionOptions conversionOptions)
{
conversion.Input.AssembliesToConvert = assemblies;
conversion.Input.Options = conversionOptions;
return(Convert(conversion));
}
public void Add(ILConversion conversion, ConvertedGenericParameterTypeDefinitions_I definitions, List <ConvertedGenericParameterTypeDefinition> inputList)
{
for (int i = 0; i < inputList.Count; i++)
{
Add(conversion, definitions, inputList[i]);
}
}
public void BuildMethods(ILConversion conversion, ConvertedGenericTypeDefinition_I input)
{
if (!(input is BoundTypeDefinitionWithMethodsMask_I convertedTypeWithMethods))
{
return;
}
if (input.UnderlyingType.IsGenericTypeDefinition)
{
throw new System.Exception("You cannot call a method that is part of a generic type definition. Using this method info will cause a method invocation exeception. ");
}
var blueprintMethods = Bound.Metadata.Members.Methods.Getting.GetMethods(input.Blueprint);
for (int i = 0; i < blueprintMethods.Count; i++)
{
var blueprintMethod = blueprintMethods[i];
var blueprintUnderlyingMethodInfo = blueprintMethod.UnderlyingMethod;
// This MUST use typebuilder.GetMethod and not
// input.Blueprint.UnderlyingType, as different MethodInfo objects are returned.
var genericInstanceMethodInfo = TypeBuilder.GetMethod(input.UnderlyingType, blueprintUnderlyingMethodInfo);
var methodDefinition = (MethodDefinition)blueprintMethod.MethodReference;
var methodReference = Cecil.Methods.Building.MethodDefinitions.
MakeGenericInstanceTypeMethodReference(conversion.RuntimicSystem, (GenericInstanceType)input.SourceTypeReference, methodDefinition);
var methodEntry = BuildMethod(conversion, input, genericInstanceMethodInfo, methodReference);
AddMethodToConverted(convertedTypeWithMethods, methodEntry);
}
}
public void EnsureInterfaces(ILConversion conversion, ConvertedTypeDefinition_I converted)
{
if (!(converted.SupportsInterfaceTypeList() && converted is SemanticTypeWithInterfaceTypeList_I tewii))
{
return;
}
var typeDefinition = (TypeDefinition)converted.SourceTypeReference;
var interfaceTypes = typeDefinition.Interfaces;
for (int i = 0; i < interfaceTypes.Count; i++)
{
var interfaceImplementation = interfaceTypes[i];
var interfaceType = interfaceImplementation.InterfaceType;
var item = Execution.Types.Ensuring.Ensure(conversion, interfaceType, null, null);
if (!(item is BoundTypeDefinitionMask_I boundInterface))
{
throw new Exception("When creating a conversion model, the base type needs to be a bound type.");
}
converted.TypeBuilder.AddInterfaceImplementation(boundInterface.UnderlyingType);
var resolutionName = Types.Naming.GetResolutionName(item);
tewii.Interfaces.ByResolutionName.Add(resolutionName, (SemanticInterfaceTypeMask_I)item);
Types.Dependencies.Add(converted, item);
}
}
public SemanticConstructorMask_I GetConstructor(ILConversion conversion, BoundTypeDefinitionWithConstructorsMask_I declaringType, MethodReference methodSignature)
{
//var sig = (IMethodSignature) methodReference;
var constructors = declaringType.Constructors;
// If there is just a single constructor, return it.
if (constructors.All.Count == 1)
{
return(constructors.All[0]);
}
for (int i = 0; i < constructors.All.Count; i++)
{
var constructor = constructors.All[i];
// TODO: Eventually change to match up RIDs or something like that instead.
// Member References should be matched up front right after all modules and assemblies are loaded, so they do not have to be rematched later.
if (!Routines.Finding.ParameterMatching.VerifyParameters(conversion, constructor.MethodReference, methodSignature))
{
continue;
}
return(constructor);
}
return(null);
}
private List <MethodDefinition> FindMatchingMethod(ILConversion conversion, ConvertedGenericTypeDefinition_I input, Collection <MethodDefinition> methodDefinitions, MethodInfo method)
{
var name = method.Name;
List <MethodDefinition> canidatesBasedUponName = new List <MethodDefinition>();
for (int i = 0; i < methodDefinitions.Count; i++)
{
var methodDefinition = methodDefinitions[i];
if (methodDefinition.Name == name)
{
canidatesBasedUponName.Add(methodDefinition);
}
}
if (canidatesBasedUponName.Count == 0)
{
throw new Exception($"Could not find a method matching the method name {name}.");
}
if (canidatesBasedUponName.Count == 1)
{
return(canidatesBasedUponName);
}
throw new Exception($"Found more than one method matching the method name {name}.");
}
private void DefineTypeParameterBuildersIfPresent(ILConversion conversion, ConvertedTypeDefinition_I convertedType)
{
if (!convertedType.IsGeneric())
{
return;
}
var gtd = (ConvertedGenericTypeDefinition_I)convertedType;
if (!gtd.HasTypeParameters())
{
return;
}
var ctwtb = (ConvertedTypeDefinitionWithTypeBuilder_I)convertedType;
var tpList = gtd.TypeParameters.All;
var names = Types.TypeParameters.GetNames(conversion, gtd);
var genericParameters = convertedType.TypeBuilder.DefineGenericParameters(names);
gtd.TypeParameters.Builders = genericParameters;
for (var i = 0; i < tpList.Count; i++)
{
var tp = (ConvertedGenericParameterTypeDefinition)tpList[i];
tp.Builder = genericParameters[i];
tp.UnderlyingType = genericParameters[i];
}
}
public void Ensure(ILConversion conversion, Stream[] streams)
{
foreach (var stream in streams)
{
Ensure(conversion, stream);
}
}
public Type[] GetSystemParameterTypes(ILConversion conversion, SemanticTypeMask_I[] methodEntryParameterTypes)
{
if (methodEntryParameterTypes == null)
{
return(null);
}
Type[] types = new Type[methodEntryParameterTypes.Length];
for (int i = 0; i < types.Length; i++)
{
var boundType = (BoundTypeDefinitionMask_I)methodEntryParameterTypes[i];
if (boundType.UnderlyingType == null)
{
throw new Exception("Underlying type is null");
}
types[i] = boundType.UnderlyingType;
}
return(types);
}
private void BuildPhase2AndDependencies(ILConversion conversion, ConvertedTypeDefinition_I converted)
{
// Build all members
BuildPhase2(conversion, converted);
if (converted.SourceTypeReference.FullName ==
"Root.Code.Containers.E01D.Runtimic.RuntimicContainerB_I`1"
)
{
// Does get here
}
// Give a chance for all dependencies to build all members
var dependents = converted.ConversionState.Phase2Dependents;
for (int i = 0; i < dependents.Count; i++)
{
var dependent = dependents[i];
dependent.ConversionState.Phase2Dependencies.Remove(converted);
if (dependent.ConversionState.Phase2Dependencies.Count == 0)
{
BuildPhase2AndDependencies(conversion, dependent);
}
}
converted.ConversionState.Phase2Dependents.Clear();
BuildPhase3(conversion, converted);
}
private bool EmitOpCodes(ILConversion conversion, ConvertedRoutine routine)
{
var methodDefinition = (MethodDefinition)routine.MethodReference;
var bodyState = routine.EmitState.Body;
if (bodyState.InstructionStream == null)
{
bodyState.InstructionStream = new ConvertedILStream
{
Buffer = new byte[methodDefinition.Body.CodeSize],
ModuleBuilder = routine.DeclaringType.Module.ModuleBuilder
};
}
for (int iInstruction = bodyState.CurrentInstruction; iInstruction < methodDefinition.Body.Instructions.Count; bodyState.CurrentInstruction = ++iInstruction)
{
var instructionDefinition = methodDefinition.Body.Instructions[iInstruction];
if (!EmitOpCode(conversion, routine, methodDefinition, bodyState.InstructionStream, instructionDefinition))
{
return(false);
}
}
return(true);
}
public void BuildField(ILConversion conversion, ConvertedTypeDefinition_I input, FieldDefinition field)
{
if (!(input is ConvertedTypeDefinitionWithFields_I typeWithFields))
{
throw new Exception("Trying to build a field on a type that does not support fields.");
}
var fieldAttributes = GetFieldAttributes(field);
var boundFieldType = Execution.Types.Ensuring.EnsureToType(conversion, field.FieldType, out BoundTypeDefinitionMask_I semanticFieldType);
var builder = typeWithFields.TypeBuilder.DefineField(field.Name, boundFieldType, fieldAttributes);
if (field.HasConstant)
{
builder.SetConstant(field.Constant);
}
var convertedField = new ConvertedField()
{
FieldType = semanticFieldType,
Conversion = conversion,
FieldDefinition = field,
FieldBuilder = builder,
UnderlyingField = builder,
Name = field.Name,
};
typeWithFields.Fields.ByName.Add(convertedField.Name, convertedField);
CustomAttributes.BuildCustomAttributes(conversion, input, convertedField);
}
public void Emit(ILConversion conversion, ConvertedILStream stream, OpCode opCode, String str)
{
var stringToken = stream.ModuleBuilder.GetStringConstant(str).Token;
InternalEmit(conversion, stream, opCode);
Emit(stream, stringToken);
}
public ConvertedLocalVariableSignature CreateLocalVariableSignature(ILConversion conversion)
{
return(new ConvertedLocalVariableSignature()
{
Conversion = conversion
});
}
public void Build(ILConversion conversion, ConvertedGenericTypeDefinition_I convertedGeneric)
{
#region Example Code Case - ClassWithGenericField<string>
// An example of a type that does not have generics: ClassWithGenericField<string>
// public class ClassWithGenericField<T>
// {
// public T GenericField;
// public void Execute()
// {
// }
// }
#endregion
Fields.Building.Generic.BuildFields(conversion, convertedGeneric);
//if (convertedGeneric.SourceTypeReference.FullName ==
// "Root.Testing.Code.Apis.E01D.Runtimic.Emitting.Conversion.TestApi`1<TContainer>")
//{
//}
// Example : "Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Types.GenericClassWithMethods`1<System.Object>"
Routines.Building.BuildRoutines(conversion, convertedGeneric);
}
public SemanticModuleMask_I GetModuleEntry(ILConversion conversion, ModuleDefinition moduleDefinition)
{
// Get the module for the type creation. If the type is orginal or mscorlib, then treated specially.
var assemblyEntry = Assemblies.Getting.GetAssembly(conversion, moduleDefinition.Assembly);
return(GetModuleEntry(assemblyEntry, moduleDefinition));
}
public bool BuildInstructions(ILConversion conversion, ConvertedTypeDefinition_I convertedType)
{
if (conversion.Configuration.UseILGenerator)
{
//return WithILGenerator.GenerateIL(conversion, convertedType);
throw new NotSupportedException("The use of the IL generator is no longer supported.");
}
if (!(convertedType is ConvertedTypeWithRoutines_I convertedWithRoutines))
{
return(true);
}
if (convertedWithRoutines.RoutinesEmitState == null)
{
convertedWithRoutines.RoutinesEmitState = new ConvertedRoutinesEmitState();
}
var currentRoutineToEmit = convertedWithRoutines.RoutinesEmitState.CurrentRoutineToEmit;
for (int i = currentRoutineToEmit; i < convertedWithRoutines.Routines.Count; convertedWithRoutines.RoutinesEmitState.CurrentRoutineToEmit = ++i)
{
var routine = convertedWithRoutines.Routines[i];
if (!BuildRoutineBody(conversion, routine))
{
return(false);
}
}
return(true);
}
public string GetAssemblyName(ILConversion conversion, string assemblyName, Guid guid)
{
bool isConverted = Assemblies.Query.IsConverted(conversion, assemblyName);
if (assemblyName.Contains(","))
{
var parts = assemblyName.Split(',');
assemblyName = parts[0];
}
if (!conversion.Configuration.AddAssemblyPrefixAndSuffix)
{
return(assemblyName);
}
var prefix = string.Empty;
if (isConverted)
{
prefix = conversion.Configuration.BuilderAccess == AssemblyBuilderAccess.RunAndCollect ? "collectible_" : "converted_";
}
if (guid == Guid.Empty)
{
return($"{prefix}{assemblyName}");
}
return($"{prefix}{assemblyName}_{guid.ToString("N")}");
}
public ILConversionResult Convert(ILConversion conversion, Assembly[] assemblies)
{
conversion.Input.AssembliesToConvert = assemblies;
conversion.Input.Options = CreateDefaultConversionOptions();
return(Convert(conversion));
}
/// <summary>
/// Adds builds all of the members and adds them to the type.
/// </summary>
/// <param name="conversion"></param>
/// <param name="converted"></param>
public void Build(ILConversion conversion, ConvertedTypeDefinition_I converted)
{
// DESIGN NOTE:
// Add all members to the type.
Members.TypeParameters.Building.EnsureTypeParametersIfAny(conversion, converted);
Types.Ensuring.Gathering.EnsureBaseType(conversion, converted);
Types.Ensuring.Gathering.EnsureInterfaces(conversion, converted);
// FIX: needs to take generic arguments into account
Types.Ensuring.Gathering.GetNestedTypes(conversion, converted);
Fields.Building.NonGeneric.BuildFields(conversion, converted);
Routines.Building.BuildRoutines(conversion, converted);
Properties.Building.BuildsProperties(conversion, converted);
Events.Building.BuildEvents(conversion, converted);
CustomAttributes.BuildCustomAttributes(conversion, converted);
// DESIGN NOTE:
// Do not place the building of instructions within this phase. The instructions can need
// generic instances of the class being built. The generic instances need the methods that orginate from
// this phase. But they cannot get them till this phase is complete, and they can add their own members.
//Instructions.Building.BuildInstructions(conversion, converted);
}
private void CreateDesiredOutput(ILConversion conversion, Type[] convertedList, Assembly[] assemblies)
{
switch (conversion.Input.Kind)
{
case InputOutputKind.Unknown:
{
throw new Exception("Input output kind unknown not a supported input.");
}
case InputOutputKind.Types:
{
conversion.Result.Output = new ILConversionTypesOutput()
{
Assemblies = assemblies,
Types = convertedList,
};
break;
}
case InputOutputKind.Streams:
case InputOutputKind.Assemblies:
{
conversion.Result.Output = new ILConversionAssembliesOutput()
{
Assemblies = assemblies
};
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
public ParameterBuilder CreateParameterBuilder(ILConversion conversion, ConvertedRoutine routine, ConvertedRoutineParameter parameter)
{
ParameterBuilder builder = null;
var attributes = GetParameterAttributes(parameter.ParameterDefinition);
if (routine.IsConstructor())
{
var constructor = (ConvertedEmittedConstructor)routine;
builder = constructor.ConstructorBuilder.DefineParameter(parameter.Position, attributes, parameter.Name);
}
else
{
var method = (ConvertedBuiltMethod)routine;
builder = method.MethodBuilder.DefineParameter(parameter.Position, attributes, parameter.Name);
}
if ((attributes & ParameterAttributes.HasDefault) > 0)
{
builder.SetConstant(parameter.ParameterDefinition.Constant);
}
CustomAttributes.BuildCustomAttributes(conversion, parameter);
return(builder);
}
public ILConversionResult Convert(ILConversion conversion, Type[] types, ILConversionOptions conversionOptions)
{
conversion.Input.TypesToConvert = types;
conversion.Input.Options = conversionOptions;
return(Convert(conversion));
}
public void BuildRoutines(ILConversion conversion, ConvertedTypeDefinitionMask_I input)
{
if (input.SourceTypeReference is GenericInstanceType genericInstance)
{
Methods.Building.RuntimeCreated.BuildMethods(conversion, (ConvertedGenericTypeDefinition_I)input);
Constructors.Building.RuntimeCreated.BuildConstructors(conversion, (ConvertedGenericTypeDefinition_I)input);
}
else
{
// Done on purpose to find errors
var typeDefinition = (TypeDefinition)input.SourceTypeReference;
if (!typeDefinition.HasMethods)
{
return;
}
for (int i = 0; i < typeDefinition.Methods.Count; i++)
{
var method = typeDefinition.Methods[i];
BuildRoutine(conversion, input, method);
}
}
}
public ILConversionResult Convert(ILConversion conversion, TypeReference typeReference, ILConversionOptions conversionOptions)
{
conversion.Input.TypeReferencesToConvert = new[] { typeReference };;
conversion.Input.Options = conversionOptions;
return(Convert(conversion));
}
public ConvertedAssemblyNode EnsureNode(ILConversion conversion, StructuralAssemblyNode inputStructuralNode)
{
if (conversion.MetadataModel.Assemblies.ByMetadataId.TryGetValue(inputStructuralNode.MetadataId, out ConvertedAssemblyNode convertedAssemblyNode))
{
return(convertedAssemblyNode);
}
var guid = Guid.NewGuid();
var fullName = Assemblies.Naming.GetAssemblyName(conversion, inputStructuralNode.FullName, guid);
convertedAssemblyNode = new ConvertedAssemblyNode()
{
Guid = guid,
Id = Runtimic.Identification.IssueId(conversion.RuntimicSystem),
InputStructuralNode = inputStructuralNode,
MetadataId = inputStructuralNode.MetadataId,
InputFullName = inputStructuralNode.FullName,
FullName = fullName
};
conversion.MetadataModel.Assemblies.ById.Add(convertedAssemblyNode.Id, convertedAssemblyNode);
conversion.MetadataModel.Assemblies.ByMetadataId.Add(inputStructuralNode.MetadataId, convertedAssemblyNode);
conversion.MetadataModel.Assemblies.ByName.Add(convertedAssemblyNode.FullName, convertedAssemblyNode);
conversion.MetadataModel.Assemblies.BySourceName.Add(convertedAssemblyNode.InputFullName, convertedAssemblyNode);
convertedAssemblyNode.ConvertedAssembly = Assemblies.Creation.CreateConvertedAssembly(conversion, convertedAssemblyNode.FullName, convertedAssemblyNode);
return(convertedAssemblyNode);
}
