private void AddGenericArguments(InfrastructureRuntimicModelMask_I model, GenericInstanceMethod resolvedMethodReference, TypeReference[] typeArgumentReferences)
{
for (int i = 0; i < typeArgumentReferences.Length; i++)
{
resolvedMethodReference.GenericArguments.Add(typeArgumentReferences[i]);
}
}
public ModuleDefinition GetModuleFromType(InfrastructureRuntimicModelMask_I semanticModel, string resolutionName)
{
throw new System.Exception("Debug");
// var node = Unified.Types.Get(semanticModel, resolutionName);
//return node?.ModuleNode?.ModuleDefinition;
}
public void AddAssemblyEntry(InfrastructureRuntimicModelMask_I semanticModel, SemanticAssemblyMask_I entry)
{
throw new System.Exception("Not supported currently.");
//semanticModel.Semantic.Assemblies.ByResolutionName.Add(entry.ResolutionName(), entry);
//Infrastructure.Models.Structural.AddAssemblyDefinition(semanticModel, entry.AssemblyDefinition);
}
public MethodReference GetMethodReference(InfrastructureRuntimicModelMask_I model, Mono.Collections.Generic.Collection <MethodDefinition> methods, MethodInfo method)
{
// DEBUGGING: This is the current issue
var methodDefinition = Methods.Getting.FromMethodInfos.Definitions.GetMethodDefinition(model, methods, method);
return(Methods.Building.MethodDefinitions.MakeGenericInstanceTypeMethodReference(model, methodDefinition, method.DeclaringType));
}
public BoundMethod BuildMethod(InfrastructureRuntimicModelMask_I model, BoundTypeDefinition_I input, MethodInfo method)
{
BoundMethod boundMethod;
if (method.GetGenericArguments().Length > 0)
{
boundMethod = new BoundGenericInstanceMethod
{
DeclaringType = input,
MethodAttributes = method.Attributes,
Name = method.Name,
UnderlyingMethod = method
};
}
else
{
boundMethod = new BoundNonGenericInstanceMethod
{
DeclaringType = input,
MethodAttributes = method.Attributes,
Name = method.Name,
UnderlyingMethod = method
};
}
return(boundMethod);
}
public MethodReference MakeGenericInstanceMethod(InfrastructureRuntimicModelMask_I model, TypeReference declaringType, MethodReference methodReference, MethodInfo method)
{
Type[] typeArguments = method.GetGenericArguments();
TypeReference[] typeArgumentReferences = ResolveGenericArguments(model, typeArguments);
var resolvedMethodReference = new GenericInstanceMethod(methodReference)
{
ReturnType = ResolveTypeParameterIfPresent(model, methodReference.ReturnType, typeArgumentReferences),
};
AddGenericArguments(model, resolvedMethodReference, typeArgumentReferences);
for (int i = 0; i < methodReference.Parameters.Count; i++)
{
var inputParameter = methodReference.Parameters[i];
var inputParameterType = inputParameter.ParameterType;
var outputParameterType = ResolveTypeParameterIfPresent(model, inputParameterType, typeArgumentReferences);
var outputParameter = Parameters.Create(inputParameter, outputParameterType);
if (inputParameter.IsOut != outputParameter.IsOut)
{
throw new Exception("Did not make correctly");
}
resolvedMethodReference.Parameters.Add(outputParameter);
}
return(resolvedMethodReference);
}
public SemanticTypeDefinition CreateType(InfrastructureRuntimicModelMask_I model, SemanticModuleMask_I moduleEntry, System.Type typeReference)
{
//var convertedType = (SemanticTypeDefinition)this.Infrastructure.Semantic.Metadata.Members.Types.Creation.CreateType
//<SemanticGenericArrayTypeDefinition,
// SemanticGenericStructTypeDefinition,
// SemanticGenericDelegateTypeDefinition,
// SemanticGenericClassTypeDefinition,
// SemanticGenericInterfaceTypeDefinition,
// SemanticGenericNestedStructTypeDefinition,
// SemanticGenericNestedDelegateTypeDefinition,
// SemanticGenericNestedArrayTypeDefinition,
// SemanticGenericNestedClassTypeDefinition,
// SemanticGenericNestedInterfaceTypeDefinition,
// SemanticNestedEnumTypeDefinition,
// SemanticNestedStructTypeDefinition,
// SemanticNestedDelegateTypeDefinition,
// SemanticNestedArrayTypeDefinition,
// SemanticNestedClassTypeDefinition,
// SemanticNestedInterfaceTypeDefinition,
// SemanticSimpleClTypeDefinition,
// SemanticEnumTypeDefinition,
// SemanticStructTypeDefinition,
// SemanticDelegateTypeDefinition,
// SemanticArrayTypeDefinition,
// SemanticClassTypeDefinition,
// SemanticInterfaceTypeDefinition>(model, moduleEntry, typeReference);
throw new System.NotImplementedException();
}
public MethodReference GetMethodReference(InfrastructureRuntimicModelMask_I model, TypeReference typeReference, MethodInfo method)
{
// Get the type definition that corresponds to the type reference. This will store all the methods that are available.
var typeDefinition = Types.Getting.GetDefinition(model, typeReference);
return(GetMethodReference(model, typeDefinition, method));
}
public BoundConstructorDefinition BuildConstructor(InfrastructureRuntimicModelMask_I model, BoundTypeDefinition_I input, ConstructorInfo constructor)
{
return(new BoundConstructorDefinition
{
DeclaringType = input,
ConstructorAttributes = constructor.Attributes,
Name = constructor.Name,
UnderlyingConstructor = constructor
});
}
public TypeReference ResolveTypeParameterIfPresent(InfrastructureRuntimicModelMask_I model, TypeReference typeReferenceToResolve, TypeReference[] parametersInOrder)
{
if (!typeReferenceToResolve.IsGenericParameter)
{
return(typeReferenceToResolve);
}
throw new NotImplementedException();
}
public SemanticTypeMask_I Get(InfrastructureRuntimicModelMask_I semanticModel, SemanticModuleMask_I module, TypeReference input)
{
string resolutionName = Types.Naming.GetResolutionName(input);
if (!module.Types.ByResolutionName.TryGetValue(resolutionName, out SemanticTypeMask_I typeEntry))
{
return(null);
}
return(typeEntry);
}
public TypeReference ResolveTypeParameterIfPresent(InfrastructureRuntimicModelMask_I model, Type typeToResolve)
{
if (!typeToResolve.IsGenericParameter)
{
return(Types.Getting.GetInternalTypeReference(model, typeToResolve));
}
//var x = typeToResolve.GetType();
throw new NotImplementedException();
}
private TypeReference[] ResolveGenericArguments(InfrastructureRuntimicModelMask_I model, Type[] typeArguments)
{
TypeReference[] references = new TypeReference[typeArguments.Length];
for (int i = 0; i < typeArguments.Length; i++)
{
references[i] = ResolveTypeParameterIfPresent(model, typeArguments[i]);
}
return(references);
}
public TypeReference EnsureReference(InfrastructureRuntimicModelMask_I model, TypeReference inputReference, out UnifiedTypeNode unifiedNode)
{
//string resolutionName = Types.Naming.GetResolutionName(inputReference);
//var result = Types.Getting.GetStoredTypeReference(model, resolutionName, out unifiedNode);
//if (result != null) return result;
//if (inputReference.IsGenericInstance)
//{
// GenericInstanceType genericInstance = (GenericInstanceType) inputReference;
// var genericArguments = genericInstance.GenericArguments;
// var genericTypeDefinition = genericInstance.ElementType;
// var genericTypeDefinition1 = EnsureReference(model, genericTypeDefinition, out UnifiedTypeNode genericUnifiedNode);
// var genericArgumentReferences = new TypeReference[genericArguments.Count];
// for (int i = 0; i < genericArguments.Count; i++)
// {
// genericArgumentReferences[i] = EnsureReference(model, genericArguments[i]);
// }
// result = genericTypeDefinition1.MakeGenericInstanceType(genericArgumentReferences);
// var assemblyNode = Assemblies.Ensuring.Ensure(model, inputReference.Scope);
// //var moduleNode = Unified.Modules.Get(model, type.Module.Name);
// throw new Exception("Debug");
// //Unified.Types.Extend(model, assemblyNode, moduleNode, result);
//}
//else
//{
// // This should load the assembly, module and types into the model.
// Assemblies.Ensuring.Ensure(model, inputReference.Scope);
// result = Types.Getting.GetStoredTypeReference(model, resolutionName, out unifiedNode);
// if (result == null)
// {
// throw new Exception($"Type definition for {resolutionName} is not loaded.");
// }
//}
//return result;
throw new Exception("");
}
public void BuildMethods(InfrastructureRuntimicModelMask_I model, BoundTypeDefinition_I input)
{
if (!(input is BoundTypeDefinitionWithMethodsMask_I boundTypeWithMethods))
{
return;
}
if (input.FullName == "Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Types.GenericClassWithMembersThatTakeInGenericClassParameters`1<T>")
{
}
// Done on purpose to find errors
var methods = input.UnderlyingType.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
List <BoundMethod> boundMethods = new List <BoundMethod>(methods.Length);
for (int i = 0; i < methods.Length; i++)
{
var method = methods[i];
var boundMethod = BuildMethod(model, input, method);
if (!boundTypeWithMethods.Methods.ByName.TryGetValue(boundMethod.Name, out List <SemanticMethodMask_I> methodList))
{
methodList = new List <SemanticMethodMask_I>();
boundTypeWithMethods.Methods.ByName.Add(boundMethod.Name, methodList);
}
methodList.Add(boundMethod);
boundMethods.Add(boundMethod);
// NULL CHECK: Possibly null if a generic instance
input.Module?.MethodsByMetadataToken.Add(method.MetadataToken, boundMethod);
}
// Get the type definition that corresponds to the type reference. This will store all the methods that are available.
var declaringTypeDefinition = Cecil.Metadata.Members.Types.Getting.GetDefinition(model, input.SourceTypeReference);
// Ensure all the methods are added to prevent this problem:
#region
#endregion
for (int i = 0; i < boundMethods.Count; i++)
{
var boundMethod = boundMethods[i];
// Search the declaring type definition for the method definition that matches the method info.
boundMethod.MethodReference = Cecil.Metadata.Members.Methods.Getting.FromMethodInfos.References.GetMethodReference(model, declaringTypeDefinition.Methods, boundMethod.UnderlyingMethod);
}
}
public SemanticFieldMask_I Get(InfrastructureRuntimicModelMask_I model, SemanticTypeDefinitionMask_I declaringType, string fieldName)
{
if (!(declaringType is SemanticTypeDefinitionWithFieldsMask_I typeWithFields))
{
throw new Exception("Trying to build a field on a type that does not support fields.");
}
if (typeWithFields.Fields.ByName.TryGetValue(fieldName, out SemanticFieldMask_I field))
{
return(field);
}
return(null);
}
public void BuildConstructors(InfrastructureRuntimicModelMask_I model, BoundTypeDefinition_I input)
{
if (!(input is BoundTypeDefinitionWithConstructorsMask_I boundTypeWithConstructors))
{
return;
}
if (input.FullName == "Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Types.GenericClassWithMembersThatTakeInGenericClassParameters`1<T>")
{
}
// Done on purpose to find errors
var constructors = input.UnderlyingType.GetConstructors(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
List <BoundConstructorDefinition> boundConstructors = new List <BoundConstructorDefinition>(constructors.Length);
for (int i = 0; i < constructors.Length; i++)
{
var constructor = constructors[i];
var boundConstructor = BuildConstructor(model, input, constructor);
boundTypeWithConstructors.Constructors.All.Add(boundConstructor);
boundConstructors.Add(boundConstructor);
input.Module.ConstructorsByMetadataToken.Add(constructor.MetadataToken, boundConstructor);
}
// Get the type definition that corresponds to the type reference. This will store all the constructors that are available.
var declaringTypeDefinition = Cecil.Metadata.Members.Types.Getting.GetDefinition(model, input.SourceTypeReference);
// Ensure all the constructors are added to prevent this problem:
#region
#endregion
for (int i = 0; i < boundConstructors.Count; i++)
{
var boundConstructor = boundConstructors[i];
// Search the declaring type definition for the constructor definition that matches the constructor info.
boundConstructor.MethodReference = Cecil.Metadata.Members.Constructors.Getting.FromConstructorInfos.References.GetMethodReference(model, declaringTypeDefinition, boundConstructor.UnderlyingConstructor);
}
}
public CecilTypeReferenceSet EnsureReferences(InfrastructureRuntimicModelMask_I model, List <TypeReference> types)
{
throw new System.Exception("Debug");
//var result = new CecilTypeReferenceSet();
//for (int i = 0; i < types.Count; i++)
//{
// EnsureReference(model, types[i], out UnifiedTypeNode unifiedNode);
// result.Types.Add(unifiedNode);
// if (!IsPresent(result, unifiedNode.AssemblyNode))
// {
// result.Assemblies.Add(unifiedNode.AssemblyNode);
// }
//}
//return result;
}
public BoundGenericParameterTypeDefinition CreateTypeParameter(InfrastructureRuntimicModelMask_I conversion, Type[] typeArguments, TypeReference inputType, GenericParameter typeParamterType)
{
var typeParameter = new BoundGenericParameterTypeDefinition
{
Attributes = Cecil.Metadata.Members.GenericParameters.GetTypeParameterAttributes(typeParamterType),
Name = typeParamterType.Name,
FullName = typeParamterType.FullName,
Position = typeParamterType.Position,
TypeParameterKind = GetTypeParameterKind(typeParamterType.Type),
Definition = typeParamterType,
SourceTypeReference = inputType
};
typeParameter.UnderlyingType = FindMatchingType(typeArguments, typeParamterType);
return(typeParameter);
}
public MethodDefinition GetMethodDefinition(InfrastructureRuntimicModelMask_I model, Mono.Collections.Generic.Collection <MethodDefinition> methodDefinitions, MethodInfo method)
{
if (method.Module.Assembly.IsDynamic)
{
throw new Exception(
"Cannot be used for methods that orginate from dynamic assemblies as the metadata tokens will not match.");
}
for (int i = 0; i < methodDefinitions.Count; i++)
{
var methodDefinition = methodDefinitions[i];
if (method.MetadataToken == methodDefinition.MetadataToken.ToInt32())
{
return(methodDefinition);
}
}
throw new Exception($"Could not find a method matching the method name {method.Name}.");
}
public FieldInfo GetFieldInfo(InfrastructureRuntimicModelMask_I model, SemanticTypeDefinitionMask_I declaringType, string fieldName)
{
// 1) First check the current type for the field.
var result = Get(model, declaringType, fieldName);
// 2.a) If not found, and is generic...
if (result == null && declaringType is BoundGenericTypeDefinitionMask_I bound)
{
// 2.b) Check the blueprint for the field as it might take generic parameters.
result = Get(model, bound.Blueprint, fieldName);
}
if (result == null)
{
return(null);
}
if (!(result is BoundFieldDefinitionMask_I field))
{
throw new Exception("Cannot get a field info from a field hat is not convertible to a BoundFieldMask_I.");
}
return(field.UnderlyingField);
}
public SemanticFieldMask_I Get(InfrastructureRuntimicModelMask_I model, SemanticTypeDefinitionMask_I declaringType, string fieldName)
{
return(Semantic.Metadata.Members.Fields.Get(model, declaringType, fieldName));
}
public TypeReference EnsureReference(InfrastructureRuntimicModelMask_I model, TypeReference inputReference)
{
//return EnsureReference(model, inputReference, out UnifiedTypeNode unifiedNode);
throw new Exception("");
}
//public TypeReference GetTypeReference(InfrastructureRuntimicModelMask_I model, Type input)
//{
// string resolutionName = Binding.Metadata.Members.Types.Naming.GetResolutionName(input);
// TypeReference typeDefinition = Collection.GetStoredTypeReference(model, resolutionName);
// if (typeDefinition != null) return typeDefinition;
// if (!input.IsGenericType)
// {
// throw new Exception($"Type definition for {input.AssemblyQualifiedName} is not loaded.");
// }
// var genericArguments = input.GenericTypeArguments;
// if (genericArguments.Length < 1)
// {
// throw new Exception($"Type definition for {input.AssemblyQualifiedName} is not loaded.");
// }
// var genericTypeDefinition = input.GetGenericTypeDefinition();
// var genericTypeDefinition1 = GetTypeReference(model, genericTypeDefinition);
// var genericArgumentReferences = new TypeReference[genericArguments.Length];
// for (int i = 0; i < genericArguments.Length; i++)
// {
// genericArgumentReferences[i] = GetTypeReference(model, genericArguments[i]);
// }
// var result = genericTypeDefinition1.MakeGenericInstanceType(genericArgumentReferences);
// return result;
//}
public Type ResolveToType(InfrastructureRuntimicModelMask_I model, SemanticTypeDefinitionMask_I semanticType)
{
throw new Exception("resolving a semantic type to a run time is not supported. A semantic type is designed to be used to create runtime type. Right now automatic" +
"compile support is not present.");
}
public TypeReference EnsureReference(InfrastructureRuntimicModelMask_I model, Type type)
{
return(EnsureReference(model, type, out UnifiedTypeNode unifiedNode));
}
public MethodReference MakeGenericInstanceMethod(InfrastructureRuntimicModelMask_I model, TypeReference typeReference,
TypeDefinition typeDefinition, MethodReference methodReference, MethodInfo method)
{
throw new NotImplementedException();
}
public TypeReference EnsureReference(InfrastructureRuntimicModelMask_I model, Type type, out UnifiedTypeNode unifiedNode)
{
throw new System.Exception("Fix");
//var metadataToken = type.MetadataToken;
//// Ensure bound entry
//// Ensure Cecil entry
//// If a type is converted, then a seperate converted entry is created in a corresponding module. Types from different assemlibes cannot be combined
//// without most likely making IL changes to support the additional types.
//string resolutionName = Types.Naming.GetResolutionName(type);
////if (resolutionName == "Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Types.ComplicatedGenericWithOneArgBaseConstructorCall`3, E01D.Pal.Apps.Common, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null")
////{
////}
//TypeReference result = Types.Getting.GetStoredTypeReference(model, resolutionName, out unifiedNode);
//if (result != null) return result;
//if (type.IsGenericType && !type.IsGenericTypeDefinition)
//{
// var genericArguments = type.GenericTypeArguments;
// var genericTypeDefinition = type.GetGenericTypeDefinition();
// var genericTypeDefinition1 = EnsureReference(model, genericTypeDefinition);
// var genericArgumentReferences = new TypeReference[genericArguments.Length];
// for (int i = 0; i < genericArguments.Length; i++)
// {
// genericArgumentReferences[i] = EnsureReference(model, genericArguments[i]);
// }
// result = genericTypeDefinition1.MakeGenericInstanceType(genericArgumentReferences);
// var assemblyNode = Assemblies.Ensuring.Ensure(model, type.Assembly);
// var moduleNode = Unified.Modules.Get(model, type.Module.Name);
// Unified.Types.Extend(model, assemblyNode, moduleNode, result);
//}
//else
//{
// // This should load the assembly, module and types into the model.
// Assemblies.Ensuring.Ensure(model, type.Assembly);
// result = Types.Getting.GetStoredTypeReference(model, resolutionName, out unifiedNode);
// if (result == null)
// {
// throw new Exception($"Type definition for {type.AssemblyQualifiedName} is not loaded.");
// }
//}
//return result;
}
/// <summary>
/// Gets the method definition that coresponds to the runtime method info.
/// </summary>
/// <param name="model"></param>
/// <param name="typeDefinition"></param>
/// <param name="method"></param>
/// <returns></returns>
public MethodDefinition GetMethodDefinition(InfrastructureRuntimicModelMask_I model, TypeDefinition typeDefinition, MethodInfo method)
{
var methodDefinitions = typeDefinition.Methods;
return(GetMethodDefinition(model, methodDefinitions, method));
}
public FieldInfo GetFieldInfo(InfrastructureRuntimicModelMask_I conversion, Type declaringType, FieldReference fieldReference)
{
return(declaringType.GetField(fieldReference.Name));
}
public BoundTypeDefinitionInterfaces GetInterfaces(InfrastructureRuntimicModelMask_I semanticModel, TypeDefinition typeDefinition)
{
BoundTypeDefinitionInterfaces all = new BoundTypeDefinitionInterfaces();
return(all);
}
