public DebuggerSyntaxTree(MetaSyntaxNode root, SourceText text, MetaParseOptions options)
: base(
text,
text.Encoding,
text.ChecksumAlgorithm,
path: "",
options: options,
root: root,
directives: DirectiveStack.Empty)
{
}
/// <summary>
/// <para>
/// Internal helper for <see cref="MetaSyntaxNode"/> class to create a new syntax tree rooted at the given root node.
/// This method does not create a clone of the given root, but instead preserves it's reference identity.
/// </para>
/// <para>NOTE: This method is only intended to be used from <see cref="MetaSyntaxNode.SyntaxTree"/> property.</para>
/// <para>NOTE: Do not use this method elsewhere, instead use <see cref="Create(MetaSyntaxNode, CSharpParseOptions, string, Encoding)"/> method for creating a syntax tree.</para>
/// </summary>
internal static MetaSyntaxTree CreateWithoutClone(MetaSyntaxNode root)
{
Debug.Assert(root != null);
return(new ParsedSyntaxTree(
textOpt: null,
encodingOpt: null,
checksumAlgorithm: SourceHashAlgorithm.Sha1,
path: "",
options: MetaParseOptions.Default,
root: root,
directives: DirectiveStack.Empty,
cloneRoot: false));
}
internal ParsedSyntaxTree(SourceText textOpt, Encoding encodingOpt, SourceHashAlgorithm checksumAlgorithm, string path, MetaParseOptions options, MetaSyntaxNode root, DirectiveStack directives, bool cloneRoot = true)
{
Debug.Assert(root != null);
Debug.Assert(options != null);
Debug.Assert(textOpt == null || textOpt.Encoding == encodingOpt && textOpt.ChecksumAlgorithm == checksumAlgorithm);
_lazyText = textOpt;
_encodingOpt = encodingOpt ?? textOpt?.Encoding;
_checksumAlgorithm = checksumAlgorithm;
_options = options;
_path = path ?? string.Empty;
_root = cloneRoot ? this.CloneNodeAsRoot(root) : root;
_hasCompilationUnitRoot = root.Kind == MetaSyntaxKind.Main;
this.SetDirectiveStack(directives);
}
/// <summary>
/// Creates a new syntax tree from a syntax node.
/// </summary>
public static MetaSyntaxTree Create(MetaSyntaxNode root, MetaParseOptions options = null, string path = "", Encoding encoding = null)
{
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
var directives = root.Kind == MetaSyntaxKind.Main ?
((ICompilationUnitRootSyntax)root).GetConditionalDirectivesStack() :
DirectiveStack.Empty;
return(new ParsedSyntaxTree(
textOpt: null,
encodingOpt: encoding,
checksumAlgorithm: SourceHashAlgorithm.Sha1,
path: path,
options: options ?? MetaParseOptions.Default,
root: root,
directives: directives));
}
/// <summary> /// Gets the root node of the syntax tree if it is already available. /// </summary> public abstract bool TryGetRoot(out MetaSyntaxNode root);
// REVIEW: I would prefer to not expose CloneAsRoot and make the functionality
// internal to CaaS layer, to ensure that for a given SyntaxTree there can not
// be multiple trees claiming to be its children.
//
// However, as long as we provide GetRoot extensibility point on SyntaxTree
// the guarantee above cannot be implemented and we have to provide some way for
// creating root nodes.
//
// Therefore I place CloneAsRoot API on SyntaxTree and make it protected to
// at least limit its visibility to SyntaxTree extenders.
/// <summary>
/// Produces a clone of a <see cref="MetaSyntaxNode"/> which will have current syntax tree as its parent.
///
/// Caller must guarantee that if the same instance of <see cref="MetaSyntaxNode"/> makes multiple calls
/// to this function, only one result is observable.
/// </summary>
/// <typeparam name="T">Type of the syntax node.</typeparam>
/// <param name="node">The original syntax node.</param>
/// <returns>A clone of the original syntax node that has current <see cref="CSharpSyntaxTree"/> as its parent.</returns>
protected T CloneNodeAsRoot <T>(T node) where T : MetaSyntaxNode
{
return(MetaSyntaxNode.CloneNodeAsRoot(node, this));
}
public override bool TryGetRoot(out MetaSyntaxNode root)
{
root = _root;
return(true);
}
public DummySyntaxTree()
{
_node = this.CloneNodeAsRoot((MainSyntax)MainGreen.__Missing.CreateRed());
}
/// <summary>
/// Creates a new syntax tree from a syntax node with text that should correspond to the syntax node.
/// </summary>
/// <remarks>This is used by the ExpressionEvaluator.</remarks>
internal static MetaSyntaxTree CreateForDebugger(MetaSyntaxNode root, SourceText text, MetaParseOptions options)
{
Debug.Assert(root != null);
return(new DebuggerSyntaxTree(root, text, options));
}
