/* <summary>
* ''' Return the index within the trivia of what would be considered trailing
* ''' single-line trivia by the Scanner. This behavior must match ScanSingleLineTrivia.
* ''' In short, search walks backwards and stops at the second terminator
* ''' (colon or EOL) from the end, ignoring EOLs preceeded by line continuations.
* ''' </summary>
*/
private static int GetIndexOfEndOfTrivia(this InternalSyntax.SyntaxList <GreenNode> trivia)
{
var n = trivia.Count;
if (n > 0)
{
var i = n - 1;
switch (trivia[i].Kind)
{
case SyntaxKind.EndOfLineTrivia:
if (i > 0)
{
switch (trivia[i - 1].Kind)
{
default:
return(i);
}
}
else
{
return(i);
}
}
}
return(n);
}
internal static TSyntax AddTrailingSyntax <TSyntax>(this TSyntax node, GreenNode unexpected) where TSyntax : GreenNode
{
if (unexpected != null)
{
InternalSyntax.SyntaxList <GreenNode> trivia = CreateSkippedTrivia(
unexpected,
preserveDiagnostics: true,
addDiagnosticToFirstTokenOnly: false,
addDiagnostic: null);
return(AddTrailingTrivia(node, trivia));
}
return(node);
}
internal static TSyntax AddTrailingSyntax <TSyntax>(this TSyntax node, GreenNode unexpected, ERRID errorId) where TSyntax : GreenNode
{
var diagnostic = ErrorFactory.ErrorInfo(errorId);
if (unexpected != null)
{
InternalSyntax.SyntaxList <GreenNode> trivia = CreateSkippedTrivia(
unexpected,
preserveDiagnostics: false,
addDiagnosticToFirstTokenOnly: false,
addDiagnostic: diagnostic);
return(AddTrailingTrivia(node, trivia));
}
else
{
return((TSyntax)node.AddError(diagnostic));
}
}
internal static TSyntax AddLeadingTrivia <TSyntax>(this TSyntax node, InternalSyntax.SyntaxList <GreenNode> trivia) where TSyntax : GreenNode
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (!trivia.Any())
{
return(node);
}
var tk = (node as SyntaxToken.Green);
TSyntax result;
if (tk != null)
{
// Cannot add unexpected tokens as leading trivia on a missing token since
// if the unexpected tokens end with a statement terminator, the missing
// token would follow the statement terminator. That would result in an
// incorrect syntax tree and if this missing token is the end of an expression,
// and the expression represents a transition between VB and XML, the
// terminator will be overlooked (see ParseXmlEmbedded for instance).
if (IsMissingToken(tk))
{
var leadingTrivia = trivia.GetStartOfTrivia();
var trailingTrivia = trivia.GetEndOfTrivia();
tk = SyntaxToken.Green.AddLeadingTrivia(tk, leadingTrivia).AddTrailingTrivia(trailingTrivia);
}
else
{
tk = SyntaxToken.Green.AddLeadingTrivia(tk, trivia);
}
result = ((TSyntax)((object)tk));
}
else
{
result = FirstTokenReplacer.Replace(node, t => SyntaxToken.Green.AddLeadingTrivia(t, trivia));
}
return(result);
}
internal static bool ContainsWhitespaceTrivia(this GreenNode node)
{
if (node == null)
{
return(false);
}
var trivia = new InternalSyntax.SyntaxList <XmlNodeSyntax.Green>(node);
for (var i = 0; i < trivia.Count; i++)
{
var kind = trivia.ItemUntyped(i).Kind;
if (kind == SyntaxKind.WhitespaceTrivia || kind == SyntaxKind.EndOfLineTrivia)
{
return(true);
}
}
return(false);
}
// In order to handle creating SkippedTokens trivia correctly, we need to know if any structured
// trivia is present in a trivia list (because structured trivia can't contain structured trivia).
internal static bool TriviaListContainsStructuredTrivia(this GreenNode triviaList)
{
if (triviaList == null)
{
return(false);
}
var trivia = new InternalSyntax.SyntaxList <XmlNodeSyntax.Green>(triviaList);
for (var i = 0; i < trivia.Count; i++)
{
switch (trivia.ItemUntyped(i).Kind)
{
case SyntaxKind.XmlDocument:
case SyntaxKind.SkippedTokensTrivia:
return(true);
}
}
return(false);
}
internal static TSyntax AddTrailingTrivia <TSyntax>(this TSyntax node, InternalSyntax.SyntaxList <GreenNode> trivia) where TSyntax : GreenNode
{
if (node == null)
{
throw new ArgumentNullException("node");
}
var tk = (node as SyntaxToken.Green);
TSyntax result;
if (tk != null)
{
result = ((TSyntax)((object)SyntaxToken.Green.AddTrailingTrivia(tk, trivia)));
}
else
{
result = LastTokenReplacer.Replace(node, t => SyntaxToken.Green.AddTrailingTrivia(t, trivia));
}
return(result);
}
internal static InternalSyntax.SyntaxList <GreenNode> GetStartOfTrivia(this InternalSyntax.SyntaxList <GreenNode> trivia, int indexOfEnd)
{
if (indexOfEnd == 0)
{
return(null);
}
else if (indexOfEnd == trivia.Count)
{
return(trivia);
}
else
{
var builder = InternalSyntax.SyntaxListBuilder <GreenNode> .Create();
for (var i = 0; i < indexOfEnd; i++)
{
builder.Add(trivia[i]);
}
return(builder.ToList());
}
}
internal WithManyChildren(InternalSyntax.SyntaxList green, SyntaxNode?parent, int position)
: base(green, parent, position)
{
_children = new ArrayElement <SyntaxNode?> [green.SlotCount];
}
internal static InternalSyntax.SyntaxList <GreenNode> GetEndOfTrivia(this InternalSyntax.SyntaxList <GreenNode> trivia)
{
return(trivia.GetEndOfTrivia(trivia.GetIndexOfEndOfTrivia()));
}
internal static TSyntax AddTrailingSyntax <TSyntax>(this TSyntax node, InternalSyntax.SyntaxList <GreenNode> unexpected) where TSyntax : GreenNode
{
return(node.AddTrailingSyntax(unexpected.Node));
}
internal static TSyntax AddLeadingSyntax <TSyntax>(this TSyntax node, InternalSyntax.SyntaxList <GreenNode> unexpected, ERRID errorId) where TSyntax : GreenNode
{
return(AddLeadingSyntax(node, unexpected.Node, errorId));
}
internal SyntaxList(InternalSyntax.SyntaxList green, SyntaxNode parent, int position)
: base(green, parent, position)
{
}
internal WithThreeChildren(InternalSyntax.SyntaxList green, SyntaxNode parent, int position)
: base(green, parent, position)
{
}
internal static XmlTextSyntax.Green XmlText(InternalSyntax.SyntaxList <SyntaxToken.Green> textTokens)
{
return(new XmlTextSyntax.Green(textTokens.Node));
}
internal SeparatedWithManyWeakChildren(InternalSyntax.SyntaxList green, SyntaxNode parent, int position)
: base(green, parent, position)
{
_children = new ArrayElement <WeakReference <SyntaxNode>?> [(((green.SlotCount + 1) >> 1) - 1)];
}
