/// <summary>
/// Checks if a given type is invalid, which can happen for a number of
/// reasons: incomplete definitions, being explicitly ignored, or also
/// by being a type we do not know how to handle.
/// </summary>
private bool HasInvalidType(Type type, Module module, out string msg)
{
if (type == null)
{
msg = "null";
return(true);
}
if (!IsTypeComplete(type))
{
msg = "incomplete";
return(true);
}
if (IsTypeIgnored(type))
{
msg = "ignored";
return(true);
}
if (Options.DoAllModulesHaveLibraries() &&
module != Options.SystemModule && ASTUtils.IsTypeExternal(module, type))
{
msg = "external";
return(true);
}
msg = null;
return(false);
}
/// <summary>
/// Moves specializations which use in their arguments types located outside
/// the library their template is located in, to the module of said external types.
/// </summary>
/// <param name="template">The template to check for external specializations.</param>
private static void MoveExternalSpecializations(Class template)
{
for (int i = template.Specializations.Count - 1; i >= 0; i--)
{
var specialization = template.Specializations[i];
var modules = (from arg in specialization.Arguments
where arg.Type.Type != null &&
ASTUtils.IsTypeExternal(
template.TranslationUnit.Module, arg.Type.Type)
let module = arg.Type.Type.GetModule()
where module != null
select module).ToList().TopologicalSort(m => m.Dependencies);
if (modules.Any())
{
var module = modules.Last();
module.ExternalClassTemplateSpecializations.Add(specialization);
template.Specializations.RemoveAt(i);
}
}
}
private bool HasInvalidType(Type type, Declaration decl, out string msg)
{
if (type == null)
{
msg = "null";
return(true);
}
if (!IsTypeComplete(type))
{
msg = "incomplete";
return(true);
}
if (IsTypeIgnored(type))
{
msg = "ignored";
return(true);
}
var module = decl.TranslationUnit.Module;
if (Options.DoAllModulesHaveLibraries() &&
module != Options.SystemModule && ASTUtils.IsTypeExternal(module, type))
{
msg = "external";
return(true);
}
var arrayType = type as ArrayType;
if (arrayType != null && arrayType.SizeType == ArrayType.ArraySize.Constant &&
arrayType.Size == 0)
{
msg = "zero-sized array";
return(true);
}
msg = null;
return(false);
}
private void CleanSpecializations(Class template)
{
template.Specializations.RemoveAll(s =>
!specializations.Contains(s) && !internalSpecializations.Contains(s));
foreach (var specialization in template.Specializations.Where(
s => !s.IsExplicitlyGenerated &&
(s.Arguments.Any(a =>
{
if (a.Kind != TemplateArgument.ArgumentKind.Declaration &&
a.Kind != TemplateArgument.ArgumentKind.Template &&
a.Kind != TemplateArgument.ArgumentKind.Type)
{
return(true);
}
var type = a.Type.Type.Desugar();
if (ASTUtils.IsTypeExternal(template.TranslationUnit.Module, type) ||
type.IsPrimitiveType(PrimitiveType.Void))
{
return(true);
}
var typeIgnoreChecker = new TypeIgnoreChecker(TypeMaps);
type.Visit(typeIgnoreChecker);
return(typeIgnoreChecker.IsIgnored);
}) ||
s.SpecializationKind == TemplateSpecializationKind.ExplicitSpecialization ||
s is ClassTemplatePartialSpecialization ||
internalSpecializations.Contains(s))))
{
specialization.ExplicitlyIgnore();
}
Func <TemplateArgument, bool> allPointers =
a => a.Type.Type != null && a.Type.Type.IsAddress();
var groups = (from specialization in template.Specializations
group specialization by specialization.Arguments.All(allPointers)
into @group
select @group).ToList();
foreach (var group in groups.Where(g => g.Key))
{
foreach (var specialization in group.Skip(1))
{
template.Specializations.Remove(specialization);
}
}
for (int i = template.Specializations.Count - 1; i >= 0; i--)
{
var specialization = template.Specializations[i];
if (specialization is ClassTemplatePartialSpecialization &&
!specialization.Arguments.All(allPointers))
{
template.Specializations.RemoveAt(i);
}
}
if (!template.IsExplicitlyGenerated &&
template.Specializations.All(s => s.Ignore))
{
template.ExplicitlyIgnore();
}
}
