|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Diagnostics;
using System.Text;
using Microsoft.CodeAnalysis.EmbeddedLanguages.VirtualChars;
using Microsoft.CodeAnalysis.PooledObjects;
using Microsoft.CodeAnalysis.Text;
namespace Microsoft.CodeAnalysis.EmbeddedLanguages.Common
{
/// <summary>
/// Root of the embedded language syntax hierarchy. EmbeddedSyntaxNodes are very similar to
/// Roslyn Red-Nodes in concept, though there are differences for ease of implementation.
///
/// Similarities:
/// 1. Fully representative of the original source. All source VirtualChars are contained
/// in the Regex nodes.
/// 2. Specific types for Nodes, Tokens and Trivia.
/// 3. Uniform ways of deconstructing Nodes (i.e. ChildCount + ChildAt).
///
/// Differences:
/// Note: these differences are not required, and can be changed if felt to be valuable.
/// 1. No parent pointers. These have not been needed yet.
/// 2. No Update methods. These have not been needed yet.
/// 3. No direct ways to get Positions/Spans of node/token/trivia. Instead, that information can
/// be acquired from the VirtualChars contained within those constructs. This does mean that
/// an empty node (for example, an empty RegexSequenceNode) effect has no way to simply ascertain
/// its location. So far that hasn't been a problem.
/// 4. No null nodes. Haven't been needed so far, and it keeps things extremely simple. For
/// example where Roslyn might have chosen an optional null child, the Regex hierarchy just
/// has multiple nodes. For example there are distinct nodes to represent the very similar
/// {a} {a,} {a,b} constructs.
/// </summary>
internal abstract class EmbeddedSyntaxNode<TSyntaxKind, TSyntaxNode>
where TSyntaxKind : struct
where TSyntaxNode : EmbeddedSyntaxNode<TSyntaxKind, TSyntaxNode>
{
public readonly TSyntaxKind Kind;
private TextSpan? _fullSpan;
protected EmbeddedSyntaxNode(TSyntaxKind kind)
{
Debug.Assert((int)(object)kind != 0);
Kind = kind;
}
internal abstract int ChildCount { get; }
internal abstract EmbeddedSyntaxNodeOrToken<TSyntaxKind, TSyntaxNode> ChildAt(int index);
public EmbeddedSyntaxNodeOrToken<TSyntaxKind, TSyntaxNode> this[int index] => ChildAt(index);
public EmbeddedSyntaxNodeOrToken<TSyntaxKind, TSyntaxNode> this[Index index] => this[index.GetOffset(this.ChildCount)];
public TextSpan GetSpan()
{
var start = int.MaxValue;
var end = 0;
this.GetSpan(ref start, ref end);
return TextSpan.FromBounds(start, end);
}
public TextSpan? GetFullSpan()
=> _fullSpan ??= ComputeFullSpan();
private TextSpan? ComputeFullSpan()
{
var start = ComputeStart();
var end = ComputeEnd();
if (start == null || end == null)
return null;
return TextSpan.FromBounds(start.Value, end.Value);
int? ComputeStart()
{
for (int i = 0, n = ChildCount; i < n; i++)
{
var child = ChildAt(i);
var span = child.GetFullSpan();
if (span != null)
return span.Value.Start;
}
return null;
}
int? ComputeEnd()
{
for (var i = ChildCount - 1; i >= 0; i--)
{
var child = ChildAt(i);
var span = child.GetFullSpan();
if (span != null)
return span.Value.End;
}
return null;
}
}
private void GetSpan(ref int start, ref int end)
{
foreach (var child in this)
{
if (child.IsNode)
{
child.Node.GetSpan(ref start, ref end);
}
else
{
var token = child.Token;
if (!token.IsMissing)
{
start = Math.Min(token.VirtualChars[0].Span.Start, start);
end = Math.Max(token.VirtualChars.Last().Span.End, end);
}
}
}
}
public bool Contains(VirtualChar virtualChar)
{
foreach (var child in this)
{
if (child.IsNode)
{
if (child.Node.Contains(virtualChar))
{
return true;
}
}
else
{
if (child.Token.VirtualChars.Contains(virtualChar))
{
return true;
}
}
}
return false;
}
/// <summary>
/// Returns the string representation of this node, not including its leading and trailing trivia.
/// </summary>
/// <returns>The string representation of this node, not including its leading and trailing trivia.</returns>
/// <remarks>The length of the returned string is always the same as Span.Length</remarks>
public override string ToString()
{
using var _ = PooledStringBuilder.GetInstance(out var sb);
WriteTo(sb, leading: false, trailing: false);
return sb.ToString();
}
/// <summary>
/// Returns full string representation of this node including its leading and trailing trivia.
/// </summary>
/// <returns>The full string representation of this node including its leading and trailing trivia.</returns>
/// <remarks>The length of the returned string is always the same as FullSpan.Length</remarks>
public string ToFullString()
{
using var _ = PooledStringBuilder.GetInstance(out var sb);
WriteTo(sb, leading: true, trailing: true);
return sb.ToString();
}
/// <summary>
/// Writes the node to a stringbuilder.
/// </summary>
/// <param name="leading">If false, leading trivia will not be added</param>
/// <param name="trailing">If false, trailing trivia will not be added</param>
public void WriteTo(StringBuilder sb, bool leading, bool trailing)
{
for (var i = 0; i < this.ChildCount; i++)
{
var child = this[i];
var currentLeading = leading || i > 0;
var curentTrailing = trailing || i < (this.ChildCount - 1);
if (child.IsNode)
{
child.Node.WriteTo(sb, currentLeading, curentTrailing);
}
else
{
child.Token.WriteTo(sb, currentLeading, curentTrailing);
}
}
}
public Enumerator GetEnumerator()
=> new(this);
public struct Enumerator
{
private readonly EmbeddedSyntaxNode<TSyntaxKind, TSyntaxNode> _node;
private readonly int _childCount;
private int _currentIndex;
public Enumerator(EmbeddedSyntaxNode<TSyntaxKind, TSyntaxNode> node)
{
_node = node;
_childCount = _node.ChildCount;
_currentIndex = -1;
Current = default;
}
public EmbeddedSyntaxNodeOrToken<TSyntaxKind, TSyntaxNode> Current { get; private set; }
public bool MoveNext()
{
_currentIndex++;
if (_currentIndex >= _childCount)
{
Current = default;
return false;
}
Current = _node.ChildAt(_currentIndex);
return true;
}
}
}
}
|