public BoundTypeDefinitionMask_I EnsureBound(BoundRuntimicModelMask_I semanticModel, System.Type type)
{
throw new Exception("Debug");
//var typeReference = Cecil.Types.Getting.GetTypeReference(semanticModel, type);
//return EnsureBound(semanticModel, typeReference, type);
}
public SemanticTypeDefinitionMask_I Ensure(BoundRuntimicModelMask_I semanticModel, TypeReference input, BoundTypeDefinitionMask_I declaringType, System.Type underlyingType)
{
ArrayType arrayType = (ArrayType)input;
SemanticTypeDefinitionMask_I elementType;
if (underlyingType == null)
{
elementType = Execution.Types.Ensuring.Ensure(semanticModel, arrayType.ElementType, null, null);
}
else
{
elementType = Execution.Types.Ensuring.Ensure(semanticModel, arrayType.ElementType, underlyingType.GetElementType(), null);
}
if (IfAlreadyCreatedReturn(elementType, arrayType.Rank, out SemanticArrayTypeDefinitionMask_I existing))
{
return(existing);
}
var bound = Types.Creation.Create(semanticModel, input, null);
bound.SourceTypeReference = input;
var arrayDef = (BoundArrayTypeDefinition_I)bound;
elementType.Arrays.Add(arrayType.Rank, arrayDef);
arrayDef.ElementType = elementType;
bound.BaseType = Execution.Types.Ensuring.Ensure(semanticModel, typeof(System.Array));
if (!arrayDef.ElementType.IsBound())
{
throw new System.Exception("Expected the element type to be a bound type. Cannot create the undelrying array type without a runtime type.");
}
var arrayElementType = (BoundTypeDefinitionMask_I)arrayDef.ElementType;
var arrayElementUndelryingType = arrayElementType.UnderlyingType;
if (arrayType.Rank == 1)
{
// Makes a vector
bound.UnderlyingType = arrayElementUndelryingType.MakeArrayType();
}
else
{
// Makes an multi-dimensional array
bound.UnderlyingType = arrayElementUndelryingType.MakeArrayType(arrayType.Rank);
}
return(bound);
}
public BoundTypeDefinitionMask_I EnsureBound(BoundRuntimicModelMask_I semanticModel, TypeReference typeReference, System.Type type)
{
var semanticMask = Ensure(semanticModel, typeReference, type, null);
if (!(semanticMask is BoundTypeDefinitionMask_I bound))
{
throw new Exception($"Expected the resolved semantic type of type '{semanticMask.GetType()}' to be a bound type definition.");
}
return(bound);
}
public SemanticTypeDefinitionMask_I Ensure(BoundRuntimicModelMask_I boundModel, TypeReference typeReference, System.Type underlyingType, BoundTypeDefinitionMask_I declaringType)
{
// Check to see if this input is to be converted, or needs to be relegated to bound only.
if (Types.IsConverted(boundModel, typeReference)) // The call does not belong to the conversion code because
{
var conversionModel = (ILConversionRuntimicModel)boundModel;
return(Conversion.Metadata.Members.Types.Ensuring.Ensure(conversionModel.Conversion, typeReference, (ConvertedTypeDefinition_I)declaringType));
}
else
{
return(Bound.Metadata.Members.Types.Ensuring.Ensure(boundModel, typeReference, underlyingType, declaringType));
}
}
public void Add(BoundRuntimicModelMask_I model, SemanticTypeDefinitionMask_I semantic, int arrayTypeRank)
{
throw new System.Exception("Debug");
//var resolutionName = Cecil.Types.Naming.GetResolutionName(semantic.SourceTypeReference);
//if (!model.Unified.Arrays.TryGetValue(resolutionName, out UnifiedArrayInstanceNodeSet set))
//{
// set = new UnifiedArrayInstanceNodeSet();
// model.Unified.Arrays.Add(resolutionName, set);
//}
// set.Instances.Add(new UnifiedArrayInstanceNode()
// {
// ElementResolutionName = resolutionName,
// Rank = arrayTypeRank,
// SemanticType = semantic
// });
}
public UnifiedArrayInstanceNode Get(BoundRuntimicModelMask_I model, TypeReference arrayType, int rank)
{
throw new System.Exception("Debug");
//var resolutionName = Cecil.Types.Naming.GetResolutionName(arrayType);
//if (!model.Unified.Arrays.TryGetValue(resolutionName, out UnifiedArrayInstanceNodeSet set))
//{
// return null;
//}
//for (int i = 0; i < set.Instances.Count; i++)
//{
// var item = set.Instances[i];
// if (item.Rank != rank) continue;
// return item;
//}
//return null;
}
public SemanticTypeDefinitionMask_I Ensure(BoundRuntimicModelMask_I semanticModel, TypeReference input, BoundTypeDefinitionMask_I declaringType, System.Type underlyingType)
{
string resolutionName = Cecil.Types.Naming.GetPointerElementName(input);
var node = Unified.Types.Get(semanticModel, resolutionName);
if (node.PointerType != null)
{
return(node.PointerType);
}
var bound = Types.Creation.Create(semanticModel, input, underlyingType);
// Add the type instance to the model. Do not do any recursive calls till this methods is called.
node.PointerType = bound;
if (bound.IsNestedType())
{
if (declaringType == null)
{
throw new Exception("Declaring type is null. Cannot create a nested type.");
}
var nestedType = (BoundTypeDefinitionWithDeclaringType_I)bound;
nestedType.DeclaringType = declaringType;
}
bound.UnderlyingType = underlyingType;
Members.TypeParameters.Building.EnsureTypeParametersIfAny(semanticModel, bound);
return(bound);
}
/// <summary>
/// Ensures the type is part of the module.
/// </summary>
/// <param name="semanticModel"></param>
/// <param name="semanticModule"></param>
/// <param name="input"></param>
/// <returns></returns>
public SemanticTypeDefinitionMask_I Ensure(BoundRuntimicModelMask_I semanticModel, Type input)
{
var typeReference = Bound.Models.Types.GetTypeReference(semanticModel, input);
return(Ensure(semanticModel, typeReference, input, null));
}