private void BuildConstraints(ILConversion conversion, ConvertedGenericParameterTypeDefinition typeParameter)
{
var typeParamterType = typeParameter.Definition;
var constraints = typeParamterType.Constraints;
//var executionConstraints = new ExecutionTypeParameterConstraintMask_I[constraints.Count];
for (int i = 0; i < constraints.Count; i++)
{
var constraint = constraints[i];
//ConvertedTypeParameterConstraint semanticConstraint;
if (Cecil.Types.IsClass(conversion.RuntimicSystem, constraint))
{
var x = new ConvertedClassTypeParameterConstraint()
{
Attributes = typeParameter.Attributes,
Class = (ExecutionTypeDefinitionMask_I)Execution.Types.Ensuring.Ensure(conversion, constraint, null, null)
};
typeParameter.BaseTypeConstraint = x;
//semanticConstraint = x;
}
else
{
var x = new ConvertedInterfaceTypeParameterConstraint()
{
Attributes = typeParameter.Attributes,
Interface = (ExecutionTypeDefinitionMask_I)Execution.Types.Ensuring.Ensure(conversion, constraint, null, null)
};
//semanticConstraint = x;
typeParameter.InterfaceTypeConstraints.Add(x);
}
//executionConstraints[i] = semanticConstraint;
}
}
public void Add(ILConversion conversion, ConvertedGenericParameterTypeDefinitionsMask_I definitions, ConvertedGenericParameterTypeDefinition typeParameter)
{
if (typeParameter.TypeParameterKind == TypeParameterKind.Unknown)
{
throw new Exception("Type parameter kind is set to unknown");
}
if (typeParameter.Position < 0)
{
throw new Exception("Position cannot be a negative number. Make sure it is set to value greater than or equal to zero when creating the parameter.");
}
definitions.ByName.Add(typeParameter.Name, typeParameter);
definitions.ByPosition.Add(typeParameter.Position, typeParameter);
definitions.All.Add(typeParameter);
}
public void Add(ILConversion conversion, ConvertedTypeDefinitionWithTypeParameters_I convertedType, ConvertedGenericParameterTypeDefinition typeParameter)
{
if (convertedType.AssemblyQualifiedName ==
"Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Types.ClassWithGenericFieldAndMethodReference`1, E01D.Pal.Apps.Common, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
)
{
}
Members.TypeParameters.Add(conversion, convertedType.TypeParameters, typeParameter);
}
public void EnsureTypeParametersIfAny(ILConversion conversion, ConvertedTypeDefinition_I converted)
{
TypeReference inputType = converted.SourceTypeReference;
if (!inputType.HasGenericParameters)
{
return;
}
var parameters = inputType.GenericParameters;
var generic = (ConvertedGenericTypeDefinition_I)converted;
for (var i = 0; i < parameters.Count; i++)
{
var parameter = parameters[i];
var typeParameter = new ConvertedGenericParameterTypeDefinition()
{
Attributes = Cecil.Metadata.Members.GenericParameters.GetTypeParameterAttributes(parameter),
Name = parameter.Name,
FullName = parameter.FullName,
Position = parameter.Position,
TypeParameterKind = Cecil.Metadata.Members.GenericParameters.GetTypeParameterKind(parameter.Type),
Definition = parameter,
SourceTypeReference = parameter,
};
typeParameter.ConversionState.BuildPhase = BuildPhaseKind.TypeCreated;
Types.TypeParameters.Add(conversion, generic, typeParameter);
}
var names = Types.TypeParameters.GetNames(conversion, generic);
// NEED BUILDERS BEFORE C
generic.TypeParameters.Builders = converted.TypeBuilder.DefineGenericParameters(names);
for (var i = 0; i < parameters.Count; i++)
{
var typeParameter = (ConvertedGenericParameterTypeDefinition)generic.TypeParameters.All[i];
typeParameter.Builder = generic.TypeParameters.Builders[i];
typeParameter.UnderlyingType = typeParameter.Builder;
var genericParameterAttributes = Cecil.Metadata.Members.GenericParameters.GetGenericParameterAttributes(typeParameter.Attributes);
typeParameter.Builder.SetGenericParameterAttributes(genericParameterAttributes);
}
// DO THIS SEPERATELY, as the constraints could be self referencing, and it needs the parameters to be added to this type to find them.
// THUS THE CREATE AND ADD OPERATIONS NEED TO BE DONE FIRST. This is the same reason why the add is called on ensuring before anything else.
for (var i = 0; i < parameters.Count; i++)
{
var typeParameter = (ConvertedGenericParameterTypeDefinition)generic.TypeParameters.All[i];
BuildConstraints(conversion, typeParameter);
}
for (var i = 0; i < parameters.Count; i++)
{
var typeParameter = (ConvertedGenericParameterTypeDefinition)generic.TypeParameters.All[i];
if (typeParameter.InterfaceTypeConstraints != null && typeParameter.InterfaceTypeConstraints.Count > 0)
{
var interfaceTypes = GetInterfaceTypeConstraints(conversion, typeParameter.InterfaceTypeConstraints);
typeParameter.Builder.SetInterfaceConstraints(interfaceTypes);
}
var baseTypeConstraint = GetBaseTypeConstraint(conversion, typeParameter.BaseTypeConstraint);
if (baseTypeConstraint != null)
{
typeParameter.Builder.SetBaseTypeConstraint(baseTypeConstraint);
}
Types.Building.UpdateBuildPhase(typeParameter, BuildPhaseKind.TypeCreated);
}
}
public void Add(ILConversion conversion, ConvertedBuiltMethod method, ConvertedGenericParameterTypeDefinition typeParameter)
{
Members.TypeParameters.Add(conversion, method.TypeParameters, typeParameter);
}
public void AddGenericParameters(ILConversion conversion, ConvertedTypeDefinitionMask_I input, ConvertedBuiltMethod methodEntry)
{
var methodDefinition = methodEntry.MethodReference;
if (!methodDefinition.HasGenericParameters)
{
return;
}
List <string> genericParameterNamesList = new List <string>();
foreach (var parameter in methodDefinition.GenericParameters)
{
var genericParamaterTypeDefintionEntry = new ConvertedGenericParameterTypeDefinition()
{
Attributes = Cecil.Metadata.Members.GenericParameters.GetTypeParameterAttributes(parameter),
Name = parameter.Name,
FullName = parameter.FullName,
Position = parameter.Position,
TypeParameterKind = GetTypeParameterKind(parameter.Type),
Definition = parameter,
SourceTypeReference = parameter,
DeclaringTypeDefinitionEntry = methodEntry.DeclaringType,
ResolutionName = Cecil.Types.Naming.GetResolutionName(parameter)
};
genericParamaterTypeDefintionEntry.ConversionState.BuildPhase = BuildPhaseKind.TypeCreated;
genericParameterNamesList.Add(genericParamaterTypeDefintionEntry.Name);
Methods.TypeParameters.Add(conversion, methodEntry, genericParamaterTypeDefintionEntry);
}
var genericParameterNames = genericParameterNamesList.ToArray();
GenericTypeParameterBuilder[] genericTypeParameterBuilders = methodEntry.MethodBuilder.DefineGenericParameters(genericParameterNames);
methodEntry.TypeParameters.Builders = genericTypeParameterBuilders;
foreach (var builder in genericTypeParameterBuilders)
{
var name = builder.Name;
var genericTypeParameterEntry = Methods.TypeParameters.GetOrThrow(conversion, methodEntry, name);
var definition = genericTypeParameterEntry.Definition;
var attributes = GetGenericParameterAttributes(definition);
builder.SetGenericParameterAttributes(attributes);
genericTypeParameterEntry.Builder = builder;
if (definition.HasConstraints)
{
List <Type> interfaceConstraintTypes = new List <Type>();
foreach (var constraint in definition.Constraints)
{
bool isClassConstraint = Cecil.Types.IsClass(conversion.RuntimicSystem, constraint);
var semanticConstraint = Execution.Types.Ensuring.EnsureBound(conversion, constraint, null);
if (isClassConstraint)
{
builder.SetBaseTypeConstraint(semanticConstraint.UnderlyingType);
}
else
{
interfaceConstraintTypes.Add(semanticConstraint.UnderlyingType);
}
}
if (interfaceConstraintTypes.Count > 0)
{
builder.SetInterfaceConstraints(interfaceConstraintTypes.ToArray());
}
}
genericTypeParameterEntry.UnderlyingType = builder;
}
}
