public void CreatePost(ConvertedTypeDefinition converted, SemanticTypeInformation typeInformation)
{
if (converted.IsGeneric())
{
var generic = (ConvertedGenericTypeDefinition_I)converted;
generic.GenericKind = typeInformation.GenericKind;
generic.SourceGenericInstanceType = typeInformation.GenericInstanceType;
if (typeInformation.GenericTypeDefinition == null)
{
if (typeInformation.IsClosedGeneric && !typeInformation.IsAnonymousType)
{
throw new System.Exception("Expected a generic type definition");
}
}
}
converted.AssemblyQualifiedName = Cecil.Metadata.Members.Types.Naming.GetAssemblyQualifiedName(typeInformation.TypeReference);
converted.FullName = typeInformation.FullName;
converted.Name = typeInformation.Name;
converted.PackingSize = typeInformation.PackingSize;
converted.SourceTypeReference = typeInformation.TypeReference;
converted.ResolutionName = Types.Naming.GetResolutionName(converted);
if (typeInformation.IsGlobal)
{
converted.TypeKind |= Enums.E01D.Runtimic.Infrastructure.Metadata.Members.Typal.TypeKind.Global;
}
}
public ConvertedTypeDefinition CreateFactory(SemanticTypeInformation typeInformation)
{
return((ConvertedTypeDefinition)this.Infrastructure.Semantic.Metadata.Members.Types.Creation.Factory.CreateType <
ConvertedGenericStructTypeDefinition,
ConvertedGenericDelegateTypeDefinition,
ConvertedGenericClassTypeDefinition,
ConvertedGenericInterfaceTypeDefinition,
ConvertedGenericNestedStructTypeDefinition,
ConvertedGenericNestedDelegateTypeDefinition,
ConvertedGenericNestedClassTypeDefinition,
ConvertedGenericNestedInterfaceTypeDefinition,
ConvertedNestedEnumTypeDefinition,
ConvertedNestedStructTypeDefinition,
ConvertedNestedDelegateTypeDefinition,
ConvertedNestedClassTypeDefinition,
ConvertedNestedInterfaceTypeDefinition,
ConvertedSimpleClTypeDefinition,
ConvertedEnumTypeDefinition,
ConvertedStructTypeDefinition,
ConvertedDelegateTypeDefinition,
ConvertedArrayTypeDefinition,
ConvertedClassTypeDefinition,
ConvertedInterfaceTypeDefinition,
ConvertedPointerTypeDefinition,
ConvertedRequiredModifierTypeDefinition>(typeInformation));
}
public object CreateType
<
TGenericStructTypeDefinition,
TGenericDelegateTypeDefinition,
TGenericClassTypeDefinition,
TGenericInterfaceTypeDefinition,
TGenericNestedStructTypeDefinition,
TGenericNestedDelegateTypeDefinition,
TGenericNestedClassTypeDefinition,
TGenericNestedInterfaceTypeDefinition,
TNestedEnumTypeDefinition,
TNestedStructTypeDefinition,
TNestedDelegateTypeDefinition,
TNestedClassTypeDefinition,
TNestedInterfaceTypeDefinition,
TSimpleClTypeDefinition,
TEnumTypeDefinition,
TStructTypeDefinition,
TDelegateTypeDefinition,
TArrayTypeDefinition,
TClassTypeDefinition,
TInterfaceTypeDefinition,
TPointerTypeDefinition,
TRequiredModifierTypeDefinition>(SemanticTypeInformation typeInformation)
where TGenericNestedStructTypeDefinition : new()
where TGenericNestedDelegateTypeDefinition : new()
where TGenericNestedClassTypeDefinition : new()
where TGenericNestedInterfaceTypeDefinition : new()
where TGenericStructTypeDefinition : new()
where TGenericDelegateTypeDefinition : new()
where TGenericClassTypeDefinition : new()
where TGenericInterfaceTypeDefinition : new()
where TNestedEnumTypeDefinition : new()
where TNestedStructTypeDefinition : new()
where TNestedDelegateTypeDefinition : new()
where TNestedClassTypeDefinition : new()
where TNestedInterfaceTypeDefinition : new()
where TSimpleClTypeDefinition : new()
where TEnumTypeDefinition : new()
where TStructTypeDefinition : new()
where TDelegateTypeDefinition : new()
where TArrayTypeDefinition : new()
where TClassTypeDefinition : new()
where TInterfaceTypeDefinition : new()
where TPointerTypeDefinition : new()
where TRequiredModifierTypeDefinition : new()
{
object boundTypeDefinition;
if (typeInformation.IsGeneric)
{
if (typeInformation.IsNested)
{
if (typeInformation.IsValueType) // needs to be before
{
if (IsSimpleType(typeInformation.FullName))
{
throw new System.Exception("There are no generic simple types. This is not expected.");
}
if (typeInformation.IsEnum)
{
// Not really a generic, but this logic does occur.
boundTypeDefinition = new TNestedEnumTypeDefinition();
}
else
{
boundTypeDefinition = new TGenericNestedStructTypeDefinition();
}
}
else if (typeInformation.IsDelegate)//(typeDefinition.IsFunctionPointer || typeDefinition.BaseType?.FullName == "System.Delegate" || typeDefinition.BaseType?.FullName == "System.MulticastDelegate")
{
boundTypeDefinition = new TGenericNestedDelegateTypeDefinition();
}
else if (typeInformation.IsArray)
{
throw new System.Exception("Not supported");
}
else if (typeInformation.IsClass)
{
boundTypeDefinition = new TGenericNestedClassTypeDefinition();
}
else if (typeInformation.IsInterface)
{
boundTypeDefinition = new TGenericNestedInterfaceTypeDefinition();
}
else
{
throw new System.NotImplementedException();
}
}
else
{
if (typeInformation.IsValueType) // needs to be before
{
if (IsSimpleType(typeInformation.FullName))
{
throw new System.Exception("Not implemented.");
}
else if (typeInformation.IsEnum)
{
throw new System.Exception("Not expected");
}
else
{
boundTypeDefinition = new TGenericStructTypeDefinition();
}
}
else if (typeInformation.IsDelegate)//(typeDefinition.IsFunctionPointer || typeDefinition.BaseType?.FullName == "System.Delegate" || typeDefinition.BaseType?.FullName == "System.MulticastDelegate")
{
boundTypeDefinition = new TGenericDelegateTypeDefinition();
}
else if (typeInformation.IsArray)
{
throw new System.Exception("Not supported");
}
else if (typeInformation.IsClass)
{
boundTypeDefinition = new TGenericClassTypeDefinition();
}
else if (typeInformation.IsInterface)
{
boundTypeDefinition = new TGenericInterfaceTypeDefinition();
}
else
{
throw new System.NotImplementedException();
}
}
}
else
{
if (typeInformation.IsNested)
{
if (typeInformation.IsValueType) // needs to be before
{
if (IsSimpleType(typeInformation.FullName))
{
throw new System.Exception("Not expected");
}
if (typeInformation.IsEnum)
{
boundTypeDefinition = new TNestedEnumTypeDefinition();
}
else
{
boundTypeDefinition = new TNestedStructTypeDefinition();
}
}
else if (typeInformation.IsDelegate)//(typeDefinition.IsFunctionPointer || typeDefinition.BaseType?.FullName == "System.Delegate" || typeDefinition.BaseType?.FullName == "System.MulticastDelegate")
{
boundTypeDefinition = new TNestedDelegateTypeDefinition();
}
else if (typeInformation.IsArray)
{
throw new System.Exception("Not supported");
}
else if (typeInformation.IsClass)
{
boundTypeDefinition = new TNestedClassTypeDefinition();
}
else if (typeInformation.IsInterface)
{
boundTypeDefinition = new TNestedInterfaceTypeDefinition();
}
else
{
throw new System.NotImplementedException();
}
}
else
{
if (typeInformation.IsValueType) // needs to be before
{
if (IsSimpleType(typeInformation.FullName))
{
boundTypeDefinition = new TSimpleClTypeDefinition();
}
else if (typeInformation.IsEnum)
{
boundTypeDefinition = new TEnumTypeDefinition();
}
else
{
boundTypeDefinition = new TStructTypeDefinition();
}
}
else if (typeInformation.IsDelegate)
{
boundTypeDefinition = new TDelegateTypeDefinition();
}
else if (typeInformation.IsArray)
{
boundTypeDefinition = new TArrayTypeDefinition();
}
else if (typeInformation.IsClass)
{
boundTypeDefinition = new TClassTypeDefinition();
}
else if (typeInformation.IsInterface)
{
boundTypeDefinition = new TInterfaceTypeDefinition();
}
else if (typeInformation.IsPointer)
{
boundTypeDefinition = new TPointerTypeDefinition();
}
else if (typeInformation.IsRequiredModifier)
{
boundTypeDefinition = new TRequiredModifierTypeDefinition();
}
else
{
throw new Exception("Not expected.");
}
}
}
return(boundTypeDefinition);
}
public SemanticTypeInformation CreateTypeInformation(RuntimicSystemModel model, TypeReference typeReference)
{
//if (typeReference.FullName ==
// "Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Types.GenericClassWithMethods`1"
//)
//{
//}
string fullName = Cecil.Types.Naming.GetCliFullName(typeReference);
var typeInformation = new SemanticTypeInformation
{
Name = typeReference.Name,
FullName = fullName,
TypeReference = typeReference
};
if (typeReference.IsDefinition)
{
var typeDefinition = (TypeDefinition)typeReference;
typeInformation.IsDelegate = typeDefinition.BaseType?.FullName == "System.Delegate" || typeDefinition.BaseType?.FullName == "System.MulticastDelegate";
typeInformation.IsArray = typeDefinition.IsArray;
typeInformation.IsClass = typeDefinition.IsClass;
typeInformation.IsInterface = typeDefinition.IsInterface;
typeInformation.IsEnum = typeDefinition.IsEnum;
typeInformation.IsGlobal = typeDefinition.MetadataToken.RID == 1;
typeInformation.IsNested = typeDefinition.IsNested;
typeInformation.IsValueType = typeDefinition.IsValueType;
typeInformation.IsOpenGeneric = typeDefinition.GenericParameters.Count > 0;
if (typeInformation.IsOpenGeneric)
{
typeInformation.GenericKind |= GenericTypeKind.Open;
}
if (typeDefinition.GenericParameters.Count > 0)
{
typeInformation.GenericKind |= GenericTypeKind.HasTypeParameters;
}
typeInformation.IsGeneric = typeInformation.IsOpenGeneric || typeInformation.IsClosedGeneric;
typeInformation.IsAnonymousType = IsAnonymousType(typeInformation.IsGeneric, typeDefinition.Name, typeDefinition.Attributes);
}
else if (typeReference.IsPointer)
{
var pointerDefinition = (PointerType)typeReference;
typeInformation.IsPointer = true;
typeInformation.IsDelegate = false;
typeInformation.IsArray = pointerDefinition.IsArray;
typeInformation.IsClass = false;
typeInformation.IsInterface = false;
typeInformation.IsEnum = false;
typeInformation.IsGlobal = pointerDefinition.MetadataToken.RID == 1;
typeInformation.IsNested = pointerDefinition.IsNested;
typeInformation.IsValueType = pointerDefinition.IsValueType;
typeInformation.IsOpenGeneric = pointerDefinition.GenericParameters.Count > 0;
if (typeInformation.IsOpenGeneric)
{
typeInformation.GenericKind |= GenericTypeKind.Open;
}
if (pointerDefinition.GenericParameters.Count > 0)
{
typeInformation.GenericKind |= GenericTypeKind.HasTypeParameters;
}
typeInformation.IsGeneric = typeInformation.IsOpenGeneric || typeInformation.IsClosedGeneric;
typeInformation.IsAnonymousType = false;
}
else if (typeReference.IsRequiredModifier)
{
var requiredModifierDefinition = (RequiredModifierType)typeReference;
typeInformation.IsRequiredModifier = true;
typeInformation.IsDelegate = false;
typeInformation.IsArray = requiredModifierDefinition.IsArray;
typeInformation.IsClass = false;
typeInformation.IsInterface = false;
typeInformation.IsEnum = false;
typeInformation.IsGlobal = requiredModifierDefinition.MetadataToken.RID == 1;
typeInformation.IsNested = requiredModifierDefinition.IsNested;
typeInformation.IsValueType = requiredModifierDefinition.IsValueType;
typeInformation.IsOpenGeneric = requiredModifierDefinition.GenericParameters.Count > 0;
if (typeInformation.IsOpenGeneric)
{
typeInformation.GenericKind |= GenericTypeKind.Open;
}
if (requiredModifierDefinition.GenericParameters.Count > 0)
{
typeInformation.GenericKind |= GenericTypeKind.HasTypeParameters;
}
typeInformation.IsGeneric = typeInformation.IsOpenGeneric || typeInformation.IsClosedGeneric;
typeInformation.IsAnonymousType = false;
}
else if (typeReference.IsArray)
{
typeInformation.IsDelegate = false;
typeInformation.IsArray = true;
typeInformation.IsClass = false;
typeInformation.IsInterface = false;
typeInformation.IsEnum = false;
typeInformation.IsGlobal = false;
typeInformation.IsNested = false;
typeInformation.IsValueType = false;
typeInformation.IsOpenGeneric = false;
typeInformation.IsAnonymousType = false;
}
else if (typeReference.IsGenericInstance)
{
var genericInstanceType = (GenericInstanceType)typeReference;
typeInformation.IsArray = genericInstanceType.IsArray;
typeInformation.IsGlobal = genericInstanceType.MetadataToken.RID == 1;
typeInformation.IsNested = genericInstanceType.IsNested;
typeInformation.IsValueType = genericInstanceType.IsValueType;
typeInformation.IsOpenGeneric = genericInstanceType.GenericParameters.Count > 0;
typeInformation.IsClosedGeneric = genericInstanceType.GenericArguments.Count > 0 && !(genericInstanceType.GenericParameters.Count > 0);
TypeDefinition elementTypeReference = Types.GenericInstances.GetElementType(model, genericInstanceType);
typeInformation.IsDelegate = elementTypeReference.BaseType?.FullName == "System.Delegate" || elementTypeReference.BaseType?.FullName == "System.MulticastDelegate";
typeInformation.IsArray = genericInstanceType.IsArray;
typeInformation.IsClass = elementTypeReference.IsClass;
typeInformation.IsInterface = elementTypeReference.IsInterface;
typeInformation.IsEnum = elementTypeReference.IsEnum;
if (typeInformation.IsOpenGeneric)
{
typeInformation.GenericKind |= GenericTypeKind.Open;
}
if (typeInformation.IsClosedGeneric)
{
typeInformation.GenericKind |= GenericTypeKind.Closed;
}
if (genericInstanceType.GenericArguments.Count > 0)
{
typeInformation.GenericKind |= GenericTypeKind.HasTypeArguments;
}
if (genericInstanceType.GenericParameters.Count > 0)
{
typeInformation.GenericKind |= GenericTypeKind.HasTypeParameters;
}
typeInformation.IsGeneric = typeInformation.IsOpenGeneric || typeInformation.IsClosedGeneric;
typeInformation.IsAnonymousType = IsAnonymousType(typeInformation.IsGeneric, genericInstanceType.Name, elementTypeReference.Attributes);
// Add the type information before any
//model.Types.TypeInformations.Add(inputType.FullName, typeInformation);
if (genericInstanceType.GenericArguments.Count > 0)
{
var blueprint = genericInstanceType.ElementType;
typeInformation.GenericTypeDefinition = blueprint;
}
else
{
throw new System.Exception("Not expected");
}
}
else
{
throw new System.Exception("Not expected");
}
return(typeInformation);
}
/// <summary>
/// Creates a SemanticTypeInformation instance from a System.Type.
/// </summary>
/// <param name="model"></param>
/// <param name="inputType"></param>
/// <returns></returns>
public SemanticTypeInformation CreateTypeInformation(RuntimicSystemModel model, System.Type inputType)
{
if (inputType?.FullName == null)
{
return(null);
}
var typeInformation = new SemanticTypeInformation
{
Name = inputType.Name,
FullName = inputType.FullName,
IsDelegate = inputType.BaseType?.FullName == "System.Delegate" || inputType.BaseType?.FullName == "System.MulticastDelegate",
IsArray = inputType.IsArray,
IsClass = inputType.IsClass,
IsInterface = inputType.IsInterface,
IsEnum = inputType.IsEnum,
IsOpenGeneric = inputType.ContainsGenericParameters,
IsClosedGeneric = inputType.GenericTypeArguments.Length > 0 && !inputType.ContainsGenericParameters,
IsGlobal = inputType.MetadataToken == 1,
IsNested = inputType.IsNested,
IsValueType = inputType.IsValueType,
};
typeInformation.IsGeneric = typeInformation.IsOpenGeneric || typeInformation.IsClosedGeneric;
typeInformation.IsAnonymousType = IsAnonymousType(inputType);
if (typeInformation.IsOpenGeneric)
{
typeInformation.GenericKind |= GenericTypeKind.Open;
}
if (typeInformation.IsClosedGeneric)
{
typeInformation.GenericKind |= GenericTypeKind.Closed;
}
if (inputType.GenericTypeArguments.Length > 0)
{
typeInformation.GenericKind |= GenericTypeKind.HasTypeArguments;
}
if (inputType.ContainsGenericParameters)
{
typeInformation.GenericKind |= GenericTypeKind.HasTypeParameters;
}
// Add the type information before any
//model.Types.TypeInformations.Add(inputType.FullName, typeInformation);
if (inputType.GenericTypeArguments.Length > 0)
{
var blueprint = inputType.GetGenericTypeDefinition();
typeInformation.GenericTypeDefinition = Cecil.Types.Getting.GetStoredTypeReference(model, blueprint);
}
else
{
typeInformation.TypeReference = Cecil.Types.Getting.GetStoredTypeReference(model, inputType);
}
//// The issue is that type arguments can be generics themselves.
//// The issue also is that arguments could have already been created.
//typeInformation.TypeArguments = GetTypeParameters(model, inputType);
//typeInformation.Interfaces = GetInterfaces(model, inputType);
return(typeInformation);
}