public ExecutionTypeNode_I Ensure(ExecutionEnsureContext context)
{
ArrayType arrayType = (ArrayType)context.TypeReference;
var arrayStemType = Execution.Types.Ensuring.Ensure(new ExecutionEnsureContext()
{
Conversion = context.Conversion,
RuntimicSystem = context.RuntimicSystem,
StructuralInputTypeNode = context.StructuralInputTypeNode.StemType
});
if (CheckForBranch(arrayStemType, arrayType, out ExecutionTypeNode_I ensure))
{
return(ensure);
}
ExecutionArrayTypeDefinition_I bound;
ExecutionTypeNode_I node;
if (arrayStemType.Type.IsConverted())
{
// Converted multi-dimemsinal arrays do have constructors that need to come from a different source
// than bound multi-dimemsinal arrays
bound = (ExecutionArrayTypeDefinition_I)Conversion.Metadata.Members.Types.Creation.Create(context.RuntimicSystem, context.TypeReference);
Conversion.Metadata.Members.Types.Building.UpdateBuildPhase((ConvertedTypeDefinition_I)bound, BuildPhaseKind.TypeCreated);
node = new ConversionTypeNode()
{
IsArrayType = true,
StemType = arrayStemType,
IsDerived = true,
InputStructuralNode = context.StructuralInputTypeNode,
Type = (ConvertedTypeDefinition_I)bound,
Rank = arrayType.Rank
};
}
else
{
bound = (ExecutionArrayTypeDefinition_I)Bound.Metadata.Members.Types.Creation.Create(context.RuntimicSystem, context.TypeReference, null);
bound.UnderlyingType = context.UnderlyingType;
node = new BoundTypeNode()
{
IsArrayType = true,
StemType = arrayStemType,
IsDerived = true,
InputStructuralNode = context.StructuralInputTypeNode,
Type = (BoundTypeDefinition)bound,
Rank = arrayType.Rank
};
}
bound.SourceTypeReference = context.TypeReference;
// bound.BaseType = (BoundTypeDefinitionMask_I)Execution.Types.Ensuring.Ensure(semanticModel, typeof(System.Array));
bound.ElementType = arrayStemType.Type;
if (bound.UnderlyingType == null)
{
var elementType = arrayStemType.Type;
if (arrayType.Rank == 1)
{
// Makes a vector
bound.UnderlyingType = elementType.UnderlyingType.MakeArrayType();
}
else
{
// Makes an multi-dimensional array
bound.UnderlyingType = elementType.UnderlyingType.MakeArrayType(arrayType.Rank);
}
}
SetNode(arrayStemType, node);
return(node);
}
public ExecutionTypeNode_I Ensure(ExecutionEnsureContext context)
{
if (!context.IsConverted.HasValue)
{
throw new Exception("Expected conversion to be figured out.");
}
if (context.StructuralInputTypeNode.CecilTypeReference.IsNested && context.DeclaringType == null)
{
context.DeclaringType = Execution.Types.Ensuring.EnsureBound(context,
context.StructuralInputTypeNode.CecilTypeReference.DeclaringType, cloneContext: true);
}
if (context.IsConverted.Value)
{
var conversion = context.Conversion;
var structuralInputTypeNode = context.StructuralInputTypeNode;
var metadataToken = structuralInputTypeNode.MetadataToken;
var structuralAssembly = Conversion.Metadata.Assemblies.EnsureNode(context.Conversion, structuralInputTypeNode.Module.Assembly);
var convertedModuleNode = Conversion.Metadata.Modules.Ensure(context.Conversion, structuralAssembly, structuralInputTypeNode.Module);
var tableId = (int)(metadataToken & 0xFF000000);
if (!convertedModuleNode.Tables.TryGetValue(tableId, out ConvertedTypeTable table))
{
table = new ConvertedTypeTable();
convertedModuleNode.Tables.Add(tableId, table);
}
if (table.ByRow.TryGetValue((uint)context.RowId, out ConversionTypeNode conversionTypeNode))
{
return(conversionTypeNode);
}
var converted = Conversion.Metadata.Members.Types.Creation.Create(conversion.RuntimicSystem, structuralInputTypeNode.CecilTypeReference);
converted.Module = convertedModuleNode.ConvertedModule;
conversionTypeNode = new ConversionTypeNode()
{
Assembly = structuralAssembly,
ByReferenceType = null,
Id = 0,
InputStructuralNode = structuralInputTypeNode,
IsByReferenceType = false,
IsDerived = false,
IsPointerType = false,
MetadataToken = metadataToken,
Module = convertedModuleNode,
PointerType = null,
Type = converted
};
table.ByRow.Add((uint)context.RowId, conversionTypeNode);
var convertedDeclaringType = context.ConvertedDeclaringType;
Converted_BuildPhase1(conversion, structuralInputTypeNode, converted, convertedDeclaringType);
Conversion.Metadata.Members.Types.Building.IfPossibleBuildPhase2(conversion, converted);
return(conversionTypeNode);
}
else
{
var structuralInputTypeNode = context.StructuralInputTypeNode;
if (structuralInputTypeNode.FullName == "Root.Code.Containers.E01D.Sorting.SortingContainer_I`1")
{
}
var metadataToken = structuralInputTypeNode.MetadataToken;
var boundAssembly = Bound.Metadata.Assemblies.EnsureNode(context.RuntimicSystem, structuralInputTypeNode.Module.Assembly);
var boundModuleNode = Bound.Metadata.Modules.Ensuring.EnsureNode(context.RuntimicSystem, boundAssembly, structuralInputTypeNode.Module);
var tableId = (int)(metadataToken & 0xFF000000);
if (!boundModuleNode.Tables.TryGetValue(tableId, out BoundTypeTable table))
{
table = new BoundTypeTable();
boundModuleNode.Tables.Add(tableId, table);
}
if (table.ByRow.TryGetValue((uint)context.RowId, out BoundTypeNode boundTypeNode))
{
return(boundTypeNode);
}
//---------------------------------
// Conversion is going to occur.
//---------------------------------
if (context.UnderlyingType == null)
{
context.UnderlyingType = Cecil.GetUnderlyingType(structuralInputTypeNode.CecilTypeReference);
if (context.UnderlyingType == null)
{
throw new Exception("Null type");
}
}
var bound = Bound.Metadata.Members.Types.Creation.Create(context.RuntimicSystem, context.StructuralInputTypeNode.CecilTypeReference, context.UnderlyingType);
boundTypeNode = new BoundTypeNode()
{
Assembly = boundAssembly,
ByReferenceType = null,
Id = 0,
InputStructuralNode = structuralInputTypeNode,
IsByReferenceType = false,
IsDerived = false,
IsPointerType = false,
MetadataToken = metadataToken,
Module = boundModuleNode,
PointerType = null,
Type = bound
};
bound.Module = boundModuleNode.BoundModule;
//// Add the type instance to the model. Do not do any recursive calls till this methods is called.
table.ByRow.Add((uint)context.RowId, boundTypeNode);
//Types.Addition.Add(semanticModel, boundModule, bound);
Bound.Metadata.Members.Types.Building.NonGenericInstances.Phase1Initial.Build(context.RuntimicSystem, bound, context.UnderlyingType, context.DeclaringType);
return(boundTypeNode);
}
}
