/// <summary>
/// Move any trailing post annotations on the last base type to the first constraint (if any) as prefix annotations.
/// </summary>
protected void AdjustBaseTypePostComments()
{
if (_baseTypes != null)
{
int baseTypes = _baseTypes.Count;
if (baseTypes > 0 && _baseTypes[baseTypes - 1].HasPostAnnotations && HasConstraintClauses)
{
ChildList <Annotation> annotations = _baseTypes[baseTypes - 1].Annotations;
for (int i = 0; i < annotations.Count;)
{
Annotation annotation = annotations[i];
if (annotation.IsPostfix)
{
annotation.IsPostfix = false;
annotations.RemoveAt(i);
if (annotation.IsListed)
{
NotifyListedAnnotationRemoved(annotation);
}
ConstraintClauses[0].AttachAnnotation(annotation);
continue;
}
++i;
}
if (annotations.Count == 0)
{
_baseTypes[baseTypes - 1].Annotations = null;
}
}
}
}
/// <summary>
/// Normalize content.
/// </summary>
public void NormalizeContent()
{
if (_content is ChildList <DocComment> )
{
ChildList <DocComment> children = (ChildList <DocComment>)_content;
// Replace an empty collection with null
if (children.Count == 0)
{
_content = null;
}
else
{
for (int i = children.Count - 1; i > 0; --i)
{
// Combine adjacent DocText objects into a single object
if (children[i] is DocText && children[i - 1] is DocText)
{
children[i - 1].Add(children[i].Text);
children.RemoveAt(i);
}
}
if (children.Count == 1)
{
CodeObject child = children[0];
// Replace a single DocText with a string
if (child is DocText)
{
_content = ((DocText)child).Text;
}
else if (child.NewLines > 0)
{
// Remove any newlines on the first child if they weren't explicitly set
if (!child.IsNewLinesSet && child.NewLines > 0)
{
// Move the newlines to the parent if it hasn't been explicitly set
if (!IsNewLinesSet)
{
SetNewLines(child.NewLines);
}
child.SetNewLines(0);
}
}
}
}
}
}
/// <summary>
/// Remove the first attribute expression with the specified name.
/// </summary>
/// <returns><c>true</c> if found and removed, otherwise <c>false</c>.</returns>
public bool RemoveAttributeExpression(string attributeName)
{
if (_attributeExpressions != null)
{
for (int i = _attributeExpressions.Count - 1; i >= 0; --i)
{
// The expression might be a ConstructorRef or an UnresolvedRef, or it might be a Call that
// has an invoked expression of one of those types.
Expression expression = _attributeExpressions[i];
SymbolicRef symbolicRef = (expression is Call ? ((Call)expression).Expression.SkipPrefixes() as SymbolicRef : expression as SymbolicRef);
// Check if the name matches, with or without an "Attribute" suffix
if (symbolicRef != null && (symbolicRef.Name == attributeName ||
symbolicRef.Name + NameSuffix == attributeName || symbolicRef.Name == attributeName + NameSuffix))
{
_attributeExpressions.RemoveAt(i);
return(true);
}
}
}
return(false);
}
