928 lines
37 KiB
C#
928 lines
37 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.CodeAnalysis.CSharp.Syntax;
|
|
using Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax;
|
|
using Microsoft.CodeAnalysis.PooledObjects;
|
|
using Microsoft.CodeAnalysis.Syntax;
|
|
using Microsoft.CodeAnalysis.Text;
|
|
using Roslyn.Utilities;
|
|
|
|
namespace Microsoft.CodeAnalysis.CSharp;
|
|
|
|
public abstract class CSharpSyntaxTree : SyntaxTree
|
|
{
|
|
private sealed class DebuggerSyntaxTree : ParsedSyntaxTree
|
|
{
|
|
internal override bool SupportsLocations => true;
|
|
|
|
public DebuggerSyntaxTree(CSharpSyntaxNode root, SourceText text, CSharpParseOptions options)
|
|
: base(text, text.Encoding, text.ChecksumAlgorithm, "", options, root, DirectiveStack.Empty, null, cloneRoot: true)
|
|
{
|
|
}//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
|
|
|
}
|
|
|
|
internal sealed class DummySyntaxTree : CSharpSyntaxTree
|
|
{
|
|
private const SourceHashAlgorithm ChecksumAlgorithm = (SourceHashAlgorithm)1;
|
|
|
|
private readonly Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax _node;
|
|
|
|
public override Encoding Encoding => System.Text.Encoding.UTF8;
|
|
|
|
public override int Length => 0;
|
|
|
|
public override CSharpParseOptions Options => CSharpParseOptions.Default;
|
|
|
|
[Obsolete("Obsolete due to performance problems, use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public override ImmutableDictionary<string, ReportDiagnostic> DiagnosticOptions
|
|
{
|
|
get
|
|
{
|
|
throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/Syntax/CSharpSyntaxTree.Dummy.cs", 61);
|
|
}
|
|
}
|
|
|
|
public override string FilePath => string.Empty;
|
|
|
|
public override bool HasCompilationUnitRoot => true;
|
|
|
|
public DummySyntaxTree()
|
|
{
|
|
_node = CloneNodeAsRoot(SyntaxFactory.ParseCompilationUnit(string.Empty));
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
public override SourceText GetText(CancellationToken cancellationToken)
|
|
{
|
|
return SourceText.From(string.Empty, ((SyntaxTree)this).Encoding, (SourceHashAlgorithm)1);
|
|
}
|
|
|
|
public override bool TryGetText(out SourceText text)
|
|
{
|
|
text = SourceText.From(string.Empty, ((SyntaxTree)this).Encoding, (SourceHashAlgorithm)1);
|
|
return true;
|
|
}
|
|
|
|
public override SyntaxReference GetReference(SyntaxNode node)
|
|
{
|
|
return (SyntaxReference)(object)new SimpleSyntaxReference(node);
|
|
}
|
|
|
|
public override CSharpSyntaxNode GetRoot(CancellationToken cancellationToken)
|
|
{
|
|
return _node;
|
|
}
|
|
|
|
public override bool TryGetRoot(out CSharpSyntaxNode root)
|
|
{
|
|
root = _node;
|
|
return true;
|
|
}
|
|
|
|
public override FileLinePositionSpan GetLineSpan(TextSpan span, CancellationToken cancellationToken = default(CancellationToken))
|
|
{
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
|
return default(FileLinePositionSpan);
|
|
}
|
|
|
|
public override SyntaxTree WithRootAndOptions(SyntaxNode root, ParseOptions options)
|
|
{
|
|
return Create((CSharpSyntaxNode)(object)root, (CSharpParseOptions)(object)options, ((SyntaxTree)this).FilePath, ((SyntaxTree)this).Encoding, (SourceHashAlgorithm)1);
|
|
}
|
|
|
|
public override SyntaxTree WithFilePath(string path)
|
|
{
|
|
return Create(_node, Options, path, ((SyntaxTree)this).Encoding, (SourceHashAlgorithm)1);
|
|
}
|
|
}
|
|
|
|
private sealed class LazySyntaxTree : CSharpSyntaxTree
|
|
{
|
|
private readonly SourceText _text;
|
|
|
|
private readonly CSharpParseOptions _options;
|
|
|
|
private readonly string _path;
|
|
|
|
private readonly ImmutableDictionary<string, ReportDiagnostic> _diagnosticOptions;
|
|
|
|
private CSharpSyntaxNode? _lazyRoot;
|
|
|
|
public override string FilePath => _path;
|
|
|
|
public override Encoding? Encoding => _text.Encoding;
|
|
|
|
public override int Length => _text.Length;
|
|
|
|
public override bool HasCompilationUnitRoot => true;
|
|
|
|
public override CSharpParseOptions Options => _options;
|
|
|
|
[Obsolete("Obsolete due to performance problems, use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public override ImmutableDictionary<string, ReportDiagnostic> DiagnosticOptions => _diagnosticOptions;
|
|
|
|
internal LazySyntaxTree(SourceText text, CSharpParseOptions options, string path, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions)
|
|
{
|
|
_text = text;
|
|
_options = options;
|
|
_path = path ?? string.Empty;
|
|
_diagnosticOptions = diagnosticOptions ?? SyntaxTree.EmptyDiagnosticOptions;
|
|
}
|
|
|
|
public override SourceText GetText(CancellationToken cancellationToken)
|
|
{
|
|
return _text;
|
|
}
|
|
|
|
public override bool TryGetText([NotNullWhen(true)] out SourceText? text)
|
|
{
|
|
text = _text;
|
|
return true;
|
|
}
|
|
|
|
public override CSharpSyntaxNode GetRoot(CancellationToken cancellationToken)
|
|
{
|
|
if (_lazyRoot == null)
|
|
{
|
|
SyntaxTree val = SyntaxFactory.ParseSyntaxTree(_text, (ParseOptions?)(object)_options, _path, cancellationToken);
|
|
CSharpSyntaxNode value = CloneNodeAsRoot((CSharpSyntaxNode)(object)val.GetRoot(cancellationToken));
|
|
Interlocked.CompareExchange(ref _lazyRoot, value, null);
|
|
}
|
|
return _lazyRoot;
|
|
}
|
|
|
|
public override bool TryGetRoot([NotNullWhen(true)] out CSharpSyntaxNode? root)
|
|
{
|
|
root = _lazyRoot;
|
|
return root != null;
|
|
}
|
|
|
|
public override SyntaxReference GetReference(SyntaxNode node)
|
|
{
|
|
return (SyntaxReference)(object)new SimpleSyntaxReference(node);
|
|
}
|
|
|
|
public override SyntaxTree WithRootAndOptions(SyntaxNode root, ParseOptions options)
|
|
{
|
|
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((object)_lazyRoot == root && (object)_options == options)
|
|
{
|
|
return (SyntaxTree)(object)this;
|
|
}
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(null, _text.Encoding, _text.ChecksumAlgorithm, _path, (CSharpParseOptions)(object)options, (CSharpSyntaxNode)(object)root, _lazyDirectives, _diagnosticOptions, cloneRoot: true);
|
|
}
|
|
|
|
public override SyntaxTree WithFilePath(string path)
|
|
{
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
|
if (_path == path)
|
|
{
|
|
return (SyntaxTree)(object)this;
|
|
}
|
|
if (TryGetRoot(out CSharpSyntaxNode root))
|
|
{
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(_text, _text.Encoding, _text.ChecksumAlgorithm, path, _options, root, default(DirectiveStack), _diagnosticOptions, cloneRoot: true);
|
|
}
|
|
return (SyntaxTree)(object)new LazySyntaxTree(_text, _options, path, _diagnosticOptions);
|
|
}
|
|
|
|
[Obsolete("Obsolete due to performance problems, use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public override SyntaxTree WithDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic> options)
|
|
{
|
|
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
|
|
if (options == null)
|
|
{
|
|
options = SyntaxTree.EmptyDiagnosticOptions;
|
|
}
|
|
if (_diagnosticOptions == options)
|
|
{
|
|
return (SyntaxTree)(object)this;
|
|
}
|
|
if (TryGetRoot(out CSharpSyntaxNode root))
|
|
{
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(_text, _text.Encoding, _text.ChecksumAlgorithm, _path, _options, root, default(DirectiveStack), options, cloneRoot: true);
|
|
}
|
|
return (SyntaxTree)(object)new LazySyntaxTree(_text, _options, _path, options);
|
|
}
|
|
}
|
|
|
|
private class ParsedSyntaxTree : CSharpSyntaxTree
|
|
{
|
|
private readonly CSharpParseOptions _options;
|
|
|
|
private readonly string _path;
|
|
|
|
private readonly CSharpSyntaxNode _root;
|
|
|
|
private readonly bool _hasCompilationUnitRoot;
|
|
|
|
private readonly Encoding? _encodingOpt;
|
|
|
|
private readonly SourceHashAlgorithm _checksumAlgorithm;
|
|
|
|
private readonly ImmutableDictionary<string, ReportDiagnostic> _diagnosticOptions;
|
|
|
|
private SourceText? _lazyText;
|
|
|
|
public override string FilePath => _path;
|
|
|
|
public override Encoding? Encoding => _encodingOpt;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
|
TextSpan fullSpan = ((SyntaxNode)_root).FullSpan;
|
|
return ((TextSpan)(ref fullSpan)).Length;
|
|
}
|
|
}
|
|
|
|
public override bool HasCompilationUnitRoot => _hasCompilationUnitRoot;
|
|
|
|
public override CSharpParseOptions Options => _options;
|
|
|
|
[Obsolete("Obsolete due to performance problems, use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public override ImmutableDictionary<string, ReportDiagnostic> DiagnosticOptions => _diagnosticOptions;
|
|
|
|
internal ParsedSyntaxTree(SourceText? textOpt, Encoding? encodingOpt, SourceHashAlgorithm checksumAlgorithm, string? path, CSharpParseOptions options, CSharpSyntaxNode root, DirectiveStack directives, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, bool cloneRoot)
|
|
: base(directives)
|
|
{
|
|
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
|
|
_lazyText = textOpt;
|
|
_encodingOpt = encodingOpt ?? ((textOpt != null) ? textOpt.Encoding : null);
|
|
_checksumAlgorithm = checksumAlgorithm;
|
|
_options = options;
|
|
_path = path ?? string.Empty;
|
|
_root = (cloneRoot ? CloneNodeAsRoot(root) : root);
|
|
_hasCompilationUnitRoot = root.Kind() == SyntaxKind.CompilationUnit;
|
|
_diagnosticOptions = diagnosticOptions ?? SyntaxTree.EmptyDiagnosticOptions;
|
|
}
|
|
|
|
public override SourceText GetText(CancellationToken cancellationToken)
|
|
{
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
|
if (_lazyText == null)
|
|
{
|
|
Interlocked.CompareExchange(ref _lazyText, ((SyntaxNode)GetRoot(cancellationToken)).GetText(_encodingOpt, _checksumAlgorithm), null);
|
|
}
|
|
return _lazyText;
|
|
}
|
|
|
|
public override bool TryGetText([NotNullWhen(true)] out SourceText? text)
|
|
{
|
|
text = _lazyText;
|
|
return text != null;
|
|
}
|
|
|
|
public override CSharpSyntaxNode GetRoot(CancellationToken cancellationToken)
|
|
{
|
|
return _root;
|
|
}
|
|
|
|
public override bool TryGetRoot(out CSharpSyntaxNode root)
|
|
{
|
|
root = _root;
|
|
return true;
|
|
}
|
|
|
|
public override SyntaxReference GetReference(SyntaxNode node)
|
|
{
|
|
return (SyntaxReference)(object)new SimpleSyntaxReference(node);
|
|
}
|
|
|
|
public override SyntaxTree WithRootAndOptions(SyntaxNode root, ParseOptions options)
|
|
{
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((object)_root == root && (object)_options == options)
|
|
{
|
|
return (SyntaxTree)(object)this;
|
|
}
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(null, _encodingOpt, _checksumAlgorithm, _path, (CSharpParseOptions)(object)options, (CSharpSyntaxNode)(object)root, ((object)_root == root) ? _lazyDirectives : default(DirectiveStack), _diagnosticOptions, cloneRoot: true);
|
|
}
|
|
|
|
public override SyntaxTree WithFilePath(string path)
|
|
{
|
|
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
|
|
if (_path == path)
|
|
{
|
|
return (SyntaxTree)(object)this;
|
|
}
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(_lazyText, _encodingOpt, _checksumAlgorithm, path, _options, _root, _lazyDirectives, _diagnosticOptions, cloneRoot: true);
|
|
}
|
|
|
|
[Obsolete("Obsolete due to performance problems, use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public override SyntaxTree WithDiagnosticOptions(ImmutableDictionary<string, ReportDiagnostic> options)
|
|
{
|
|
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
|
|
if (options == null)
|
|
{
|
|
options = SyntaxTree.EmptyDiagnosticOptions;
|
|
}
|
|
if (_diagnosticOptions == options)
|
|
{
|
|
return (SyntaxTree)(object)this;
|
|
}
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(_lazyText, _encodingOpt, _checksumAlgorithm, _path, _options, _root, _lazyDirectives, options, cloneRoot: true);
|
|
}
|
|
}
|
|
|
|
internal static readonly SyntaxTree Dummy = (SyntaxTree)(object)new DummySyntaxTree();
|
|
|
|
private DirectiveStack _lazyDirectives;
|
|
|
|
private ImmutableArray<int> _preprocessorStateChangePositions;
|
|
|
|
private ImmutableArray<DirectiveStack> _preprocessorStates;
|
|
|
|
private CSharpLineDirectiveMap? _lazyLineDirectiveMap;
|
|
|
|
private CSharpPragmaWarningStateMap? _lazyPragmaWarningStateMap;
|
|
|
|
private StrongBox<NullableContextStateMap>? _lazyNullableContextStateMap;
|
|
|
|
private GeneratedKind _lazyIsGeneratedCode;
|
|
|
|
public abstract CSharpParseOptions Options { get; }
|
|
|
|
internal bool HasReferenceDirectives
|
|
{
|
|
get
|
|
{
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000c: Invalid comparison between Unknown and I4
|
|
if ((int)((ParseOptions)Options).Kind == 1)
|
|
{
|
|
return GetCompilationUnitRoot().HasReferenceDirectives;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal bool HasReferenceOrLoadDirectives
|
|
{
|
|
get
|
|
{
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_000c: Invalid comparison between Unknown and I4
|
|
if ((int)((ParseOptions)Options).Kind == 1)
|
|
{
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax compilationUnitRoot = GetCompilationUnitRoot();
|
|
if (!compilationUnitRoot.HasReferenceDirectives)
|
|
{
|
|
return compilationUnitRoot.HasLoadDirectives;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected override ParseOptions OptionsCore => (ParseOptions)(object)Options;
|
|
|
|
public CSharpSyntaxTree()
|
|
: this(default(DirectiveStack))
|
|
{
|
|
}
|
|
|
|
internal CSharpSyntaxTree(DirectiveStack directives)
|
|
{
|
|
_lazyDirectives = directives;
|
|
}
|
|
|
|
protected T CloneNodeAsRoot<T>(T node) where T : CSharpSyntaxNode
|
|
{
|
|
return SyntaxNode.CloneNodeAsRoot<T>(node, (SyntaxTree)(object)this);
|
|
}
|
|
|
|
public abstract CSharpSyntaxNode GetRoot(CancellationToken cancellationToken = default(CancellationToken));
|
|
|
|
public abstract bool TryGetRoot([NotNullWhen(true)] out CSharpSyntaxNode? root);
|
|
|
|
public virtual Task<CSharpSyntaxNode> GetRootAsync(CancellationToken cancellationToken = default(CancellationToken))
|
|
{
|
|
CSharpSyntaxNode root;
|
|
return Task.FromResult(TryGetRoot(out root) ? root : GetRoot(cancellationToken));
|
|
}
|
|
|
|
public Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax GetCompilationUnitRoot(CancellationToken cancellationToken = default(CancellationToken))
|
|
{
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax)GetRoot(cancellationToken);
|
|
}
|
|
|
|
public override bool IsEquivalentTo(SyntaxTree tree, bool topLevel = false)
|
|
{
|
|
return SyntaxFactory.AreEquivalent((SyntaxTree?)(object)this, tree, topLevel);
|
|
}
|
|
|
|
internal DirectiveStack GetDirectives()
|
|
{
|
|
if (_lazyDirectives.IsNull)
|
|
{
|
|
DirectiveStack.InterlockedInitialize(ref _lazyDirectives, GetRoot().CsGreen.ApplyDirectives(DirectiveStack.Empty));
|
|
}
|
|
return _lazyDirectives;
|
|
}
|
|
|
|
internal bool IsAnyPreprocessorSymbolDefined(ImmutableArray<string> conditionalSymbols)
|
|
{
|
|
DirectiveStack directives = GetDirectives();
|
|
ImmutableArray<string>.Enumerator enumerator = conditionalSymbols.GetEnumerator();
|
|
while (enumerator.MoveNext())
|
|
{
|
|
string current = enumerator.Current;
|
|
if (IsPreprocessorSymbolDefined(directives, current))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool IsPreprocessorSymbolDefined(DirectiveStack directives, string symbolName)
|
|
{
|
|
return directives.IsDefined(symbolName) switch
|
|
{
|
|
DefineState.Defined => true,
|
|
DefineState.Undefined => false,
|
|
_ => Options.PreprocessorSymbols.Contains(symbolName),
|
|
};
|
|
}
|
|
|
|
internal bool IsPreprocessorSymbolDefined(string symbolName, int position)
|
|
{
|
|
if (_preprocessorStateChangePositions.IsDefault)
|
|
{
|
|
BuildPreprocessorStateChangeMap();
|
|
}
|
|
int num = _preprocessorStateChangePositions.BinarySearch(position);
|
|
DirectiveStack directives;
|
|
if (num < 0)
|
|
{
|
|
num = ~num - 1;
|
|
directives = ((num < 0) ? DirectiveStack.Empty : _preprocessorStates[num]);
|
|
}
|
|
else
|
|
{
|
|
directives = _preprocessorStates[num];
|
|
}
|
|
return IsPreprocessorSymbolDefined(directives, symbolName);
|
|
}
|
|
|
|
private void BuildPreprocessorStateChangeMap()
|
|
{
|
|
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_011b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_013f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
|
|
DirectiveStack directiveStack = DirectiveStack.Empty;
|
|
ArrayBuilder<int> instance = ArrayBuilder<int>.GetInstance();
|
|
ArrayBuilder<DirectiveStack> instance2 = ArrayBuilder<DirectiveStack>.GetInstance();
|
|
foreach (Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax directive in GetRoot().GetDirectives(delegate(Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax d)
|
|
{
|
|
SyntaxKind syntaxKind = d.Kind();
|
|
return (syntaxKind - 8548 <= (SyntaxKind)3 || syntaxKind - 8554 <= SyntaxKind.List) ? true : false;
|
|
}))
|
|
{
|
|
directiveStack = ((SyntaxNode)(object)directive).ApplyDirectives(directiveStack);
|
|
SyntaxToken val;
|
|
switch (directive.Kind())
|
|
{
|
|
case SyntaxKind.ElifDirectiveTrivia:
|
|
instance2.Add(directiveStack);
|
|
val = ((Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax)directive).ElifKeyword;
|
|
instance.Add(((SyntaxToken)(ref val)).SpanStart);
|
|
break;
|
|
case SyntaxKind.ElseDirectiveTrivia:
|
|
instance2.Add(directiveStack);
|
|
val = ((Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax)directive).ElseKeyword;
|
|
instance.Add(((SyntaxToken)(ref val)).SpanStart);
|
|
break;
|
|
case SyntaxKind.EndIfDirectiveTrivia:
|
|
instance2.Add(directiveStack);
|
|
val = ((Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax)directive).EndIfKeyword;
|
|
instance.Add(((SyntaxToken)(ref val)).SpanStart);
|
|
break;
|
|
case SyntaxKind.DefineDirectiveTrivia:
|
|
instance2.Add(directiveStack);
|
|
val = ((Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax)directive).Name;
|
|
instance.Add(((SyntaxToken)(ref val)).SpanStart);
|
|
break;
|
|
case SyntaxKind.UndefDirectiveTrivia:
|
|
instance2.Add(directiveStack);
|
|
val = ((Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax)directive).Name;
|
|
instance.Add(((SyntaxToken)(ref val)).SpanStart);
|
|
break;
|
|
default:
|
|
throw ExceptionUtilities.UnexpectedValue((object)directive.Kind());
|
|
case SyntaxKind.IfDirectiveTrivia:
|
|
break;
|
|
}
|
|
}
|
|
ImmutableInterlocked.InterlockedInitialize(ref _preprocessorStates, instance2.ToImmutableAndFree());
|
|
ImmutableInterlocked.InterlockedInitialize(ref _preprocessorStateChangePositions, instance.ToImmutableAndFree());
|
|
}
|
|
|
|
public static SyntaxTree Create(CSharpSyntaxNode root, CSharpParseOptions? options = null, string? path = "", Encoding? encoding = null)
|
|
{
|
|
return Create(root, options, path, encoding, (ImmutableDictionary<string, ReportDiagnostic>?)null);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
[Obsolete("The diagnosticOptions and isGeneratedCode parameters are obsolete due to performance problems, if you are using them use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public static SyntaxTree Create(CSharpSyntaxNode root, CSharpParseOptions? options, string? path, Encoding? encoding, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, bool? isGeneratedCode)
|
|
{
|
|
if (root == null)
|
|
{
|
|
throw new ArgumentNullException("root");
|
|
}
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(null, encoding, (SourceHashAlgorithm)1, path, options ?? CSharpParseOptions.Default, root, default(DirectiveStack), diagnosticOptions, cloneRoot: true);
|
|
}
|
|
|
|
internal static SyntaxTree Create(CSharpSyntaxNode root, CSharpParseOptions options, string? path, Encoding? encoding, SourceHashAlgorithm checksumAlgorithm)
|
|
{
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(null, encoding, checksumAlgorithm, path, options, root, default(DirectiveStack), null, cloneRoot: true);
|
|
}
|
|
|
|
internal static SyntaxTree CreateForDebugger(CSharpSyntaxNode root, SourceText text, CSharpParseOptions options)
|
|
{
|
|
return (SyntaxTree)(object)new DebuggerSyntaxTree(root, text, options);
|
|
}
|
|
|
|
internal static SyntaxTree CreateWithoutClone(CSharpSyntaxNode root)
|
|
{
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(null, null, (SourceHashAlgorithm)1, "", CSharpParseOptions.Default, root, default(DirectiveStack), null, cloneRoot: false);
|
|
}
|
|
|
|
internal static SyntaxTree ParseTextLazy(SourceText text, CSharpParseOptions? options = null, string path = "")
|
|
{
|
|
return (SyntaxTree)(object)new LazySyntaxTree(text, options ?? CSharpParseOptions.Default, path, null);
|
|
}
|
|
|
|
public static SyntaxTree ParseText(string text, CSharpParseOptions? options = null, string path = "", Encoding? encoding = null, CancellationToken cancellationToken = default(CancellationToken))
|
|
{
|
|
return ParseText(text, options, path, encoding, null, cancellationToken);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
[Obsolete("The diagnosticOptions and isGeneratedCode parameters are obsolete due to performance problems, if you are using them use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public static SyntaxTree ParseText(string text, CSharpParseOptions? options, string path, Encoding? encoding, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, bool? isGeneratedCode, CancellationToken cancellationToken)
|
|
{
|
|
return ParseText(SourceText.From(text, encoding, (SourceHashAlgorithm)1), options, path, diagnosticOptions, isGeneratedCode, cancellationToken);
|
|
}
|
|
|
|
public static SyntaxTree ParseText(SourceText text, CSharpParseOptions? options = null, string path = "", CancellationToken cancellationToken = default(CancellationToken))
|
|
{
|
|
return ParseText(text, options, path, null, cancellationToken);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
[Obsolete("The diagnosticOptions and isGeneratedCode parameters are obsolete due to performance problems, if you are using them use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public static SyntaxTree ParseText(SourceText text, CSharpParseOptions? options, string path, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, bool? isGeneratedCode, CancellationToken cancellationToken)
|
|
{
|
|
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
|
|
if (text == null)
|
|
{
|
|
throw new ArgumentNullException("text");
|
|
}
|
|
options = options ?? CSharpParseOptions.Default;
|
|
using Lexer lexer = new Lexer(text, options);
|
|
using LanguageParser languageParser = new LanguageParser(lexer, null, null, LexerMode.Syntax, cancellationToken);
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax root = (Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax)(object)((GreenNode)languageParser.ParseCompilationUnit()).CreateRed();
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(text, text.Encoding, text.ChecksumAlgorithm, path, options, root, languageParser.Directives, diagnosticOptions, cloneRoot: true);
|
|
}
|
|
|
|
public override SyntaxTree WithChangedText(SourceText newText)
|
|
{
|
|
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
|
|
SourceText val = default(SourceText);
|
|
if (((SyntaxTree)this).TryGetText(ref val))
|
|
{
|
|
IReadOnlyList<TextChangeRange> changeRanges = newText.GetChangeRanges(val);
|
|
if (changeRanges.Count == 0 && newText == val)
|
|
{
|
|
return (SyntaxTree)(object)this;
|
|
}
|
|
return WithChanges(newText, changeRanges);
|
|
}
|
|
return WithChanges(newText, (IReadOnlyList<TextChangeRange>)(object)new TextChangeRange[1]
|
|
{
|
|
new TextChangeRange(new TextSpan(0, ((SyntaxTree)this).Length), newText.Length)
|
|
});
|
|
}
|
|
|
|
private SyntaxTree WithChanges(SourceText newText, IReadOnlyList<TextChangeRange> changes)
|
|
{
|
|
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
|
|
if (changes == null)
|
|
{
|
|
throw new ArgumentNullException("changes");
|
|
}
|
|
IReadOnlyList<TextChangeRange> readOnlyList = changes;
|
|
CSharpSyntaxTree cSharpSyntaxTree = this;
|
|
if (readOnlyList.Count == 1)
|
|
{
|
|
TextChangeRange val = readOnlyList[0];
|
|
if (((TextChangeRange)(ref val)).Span == new TextSpan(0, ((SyntaxTree)this).Length))
|
|
{
|
|
val = readOnlyList[0];
|
|
if (((TextChangeRange)(ref val)).NewLength == newText.Length)
|
|
{
|
|
readOnlyList = null;
|
|
cSharpSyntaxTree = null;
|
|
}
|
|
}
|
|
}
|
|
using Lexer lexer = new Lexer(newText, Options);
|
|
using LanguageParser languageParser = new LanguageParser(lexer, cSharpSyntaxTree?.GetRoot(), readOnlyList);
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax root = (Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax)(object)((GreenNode)languageParser.ParseCompilationUnit()).CreateRed();
|
|
return (SyntaxTree)(object)new ParsedSyntaxTree(newText, newText.Encoding, newText.ChecksumAlgorithm, ((SyntaxTree)this).FilePath, Options, root, languageParser.Directives, ((SyntaxTree)this).DiagnosticOptions, cloneRoot: true);
|
|
}
|
|
|
|
public override IList<TextSpan> GetChangedSpans(SyntaxTree oldTree)
|
|
{
|
|
if (oldTree == null)
|
|
{
|
|
throw new ArgumentNullException("oldTree");
|
|
}
|
|
return SyntaxDiffer.GetPossiblyDifferentTextSpans(oldTree, (SyntaxTree)(object)this);
|
|
}
|
|
|
|
public override IList<TextChange> GetChanges(SyntaxTree oldTree)
|
|
{
|
|
if (oldTree == null)
|
|
{
|
|
throw new ArgumentNullException("oldTree");
|
|
}
|
|
return SyntaxDiffer.GetTextChanges(oldTree, (SyntaxTree)(object)this);
|
|
}
|
|
|
|
private CSharpLineDirectiveMap GetDirectiveMap()
|
|
{
|
|
if (_lazyLineDirectiveMap == null)
|
|
{
|
|
Interlocked.CompareExchange(ref _lazyLineDirectiveMap, new CSharpLineDirectiveMap((SyntaxTree)(object)this), null);
|
|
}
|
|
return _lazyLineDirectiveMap;
|
|
}
|
|
|
|
public override FileLinePositionSpan GetLineSpan(TextSpan span, CancellationToken cancellationToken = default(CancellationToken))
|
|
{
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
|
|
return new FileLinePositionSpan(((SyntaxTree)this).FilePath, GetLinePosition(((TextSpan)(ref span)).Start, cancellationToken), GetLinePosition(((TextSpan)(ref span)).End, cancellationToken));
|
|
}
|
|
|
|
public override FileLinePositionSpan GetMappedLineSpan(TextSpan span, CancellationToken cancellationToken = default(CancellationToken))
|
|
{
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
|
return ((LineDirectiveMap<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax>)(object)GetDirectiveMap()).TranslateSpan(((SyntaxTree)this).GetText(cancellationToken), ((SyntaxTree)this).FilePath, span);
|
|
}
|
|
|
|
public override LineVisibility GetLineVisibility(int position, CancellationToken cancellationToken = default(CancellationToken))
|
|
{
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
|
return ((LineDirectiveMap<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax>)(object)GetDirectiveMap()).GetLineVisibility(((SyntaxTree)this).GetText(cancellationToken), position);
|
|
}
|
|
|
|
public override IEnumerable<LineMapping> GetLineMappings(CancellationToken cancellationToken = default(CancellationToken))
|
|
{
|
|
CSharpLineDirectiveMap directiveMap = GetDirectiveMap();
|
|
if (((LineDirectiveMap<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax>)(object)directiveMap).Entries.Length != 1)
|
|
{
|
|
return ((LineDirectiveMap<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax>)(object)directiveMap).GetLineMappings(((SyntaxTree)this).GetText(cancellationToken).Lines);
|
|
}
|
|
return Array.Empty<LineMapping>();
|
|
}
|
|
|
|
internal override FileLinePositionSpan GetMappedLineSpanAndVisibility(TextSpan span, out bool isHiddenPosition)
|
|
{
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
|
|
return ((LineDirectiveMap<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax>)(object)GetDirectiveMap()).TranslateSpanAndVisibility(((SyntaxTree)this).GetText(default(CancellationToken)), ((SyntaxTree)this).FilePath, span, ref isHiddenPosition);
|
|
}
|
|
|
|
public override bool HasHiddenRegions()
|
|
{
|
|
return ((LineDirectiveMap<Microsoft.CodeAnalysis.CSharp.Syntax.DirectiveTriviaSyntax>)(object)GetDirectiveMap()).HasAnyHiddenRegions();
|
|
}
|
|
|
|
internal PragmaWarningState GetPragmaDirectiveWarningState(string id, int position)
|
|
{
|
|
if (_lazyPragmaWarningStateMap == null)
|
|
{
|
|
Interlocked.CompareExchange(ref _lazyPragmaWarningStateMap, new CSharpPragmaWarningStateMap((SyntaxTree)(object)this), null);
|
|
}
|
|
return ((AbstractWarningStateMap<PragmaWarningState>)_lazyPragmaWarningStateMap).GetWarningState(id, position);
|
|
}
|
|
|
|
private NullableContextStateMap GetNullableContextStateMap()
|
|
{
|
|
if (_lazyNullableContextStateMap == null)
|
|
{
|
|
Interlocked.CompareExchange(ref _lazyNullableContextStateMap, new StrongBox<NullableContextStateMap>(NullableContextStateMap.Create((SyntaxTree)(object)this)), null);
|
|
}
|
|
return _lazyNullableContextStateMap.Value;
|
|
}
|
|
|
|
internal NullableContextState GetNullableContextState(int position)
|
|
{
|
|
return GetNullableContextStateMap().GetContextState(position);
|
|
}
|
|
|
|
internal bool? IsNullableAnalysisEnabled(TextSpan span)
|
|
{
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
|
return GetNullableContextStateMap().IsNullableAnalysisEnabled(span);
|
|
}
|
|
|
|
internal bool IsGeneratedCode(SyntaxTreeOptionsProvider? provider, CancellationToken cancellationToken)
|
|
{
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_003b: Invalid comparison between Unknown and I4
|
|
GeneratedKind? val = ((provider != null) ? new GeneratedKind?(provider.IsGenerated((SyntaxTree)(object)this, cancellationToken)) : ((GeneratedKind?)null));
|
|
if (val.HasValue)
|
|
{
|
|
GeneratedKind valueOrDefault = val.GetValueOrDefault();
|
|
if ((int)valueOrDefault != 0)
|
|
{
|
|
return (int)valueOrDefault != 1;
|
|
}
|
|
}
|
|
return isGeneratedHeuristic();
|
|
bool isGeneratedHeuristic()
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_004b: Invalid comparison between Unknown and I4
|
|
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)_lazyIsGeneratedCode == 0)
|
|
{
|
|
bool flag = GeneratedCodeUtilities.IsGeneratedCode((SyntaxTree)(object)this, (Func<SyntaxTrivia, bool>)((SyntaxTrivia trivia) => trivia.Kind() == SyntaxKind.SingleLineCommentTrivia || trivia.Kind() == SyntaxKind.MultiLineCommentTrivia), default(CancellationToken));
|
|
_lazyIsGeneratedCode = (GeneratedKind)((!flag) ? 1 : 2);
|
|
}
|
|
return (int)_lazyIsGeneratedCode == 2;
|
|
}
|
|
}
|
|
|
|
private LinePosition GetLinePosition(int position, CancellationToken cancellationToken)
|
|
{
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
|
return ((SyntaxTree)this).GetText(cancellationToken).Lines.GetLinePosition(position);
|
|
}
|
|
|
|
public override Location GetLocation(TextSpan span)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0008: Expected O, but got Unknown
|
|
return (Location)new SourceLocation((SyntaxTree)(object)this, span);
|
|
}
|
|
|
|
public override IEnumerable<Diagnostic> GetDiagnostics(SyntaxNode node)
|
|
{
|
|
if (node == null)
|
|
{
|
|
throw new ArgumentNullException("node");
|
|
}
|
|
return GetDiagnostics(node.Green, node.Position);
|
|
}
|
|
|
|
private IEnumerable<Diagnostic> GetDiagnostics(GreenNode greenNode, int position)
|
|
{
|
|
if (greenNode == null)
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
if (greenNode.ContainsDiagnostics)
|
|
{
|
|
return EnumerateDiagnostics(greenNode, position);
|
|
}
|
|
return SpecializedCollections.EmptyEnumerable<Diagnostic>();
|
|
}
|
|
|
|
private IEnumerable<Diagnostic> EnumerateDiagnostics(GreenNode node, int position)
|
|
{
|
|
SyntaxTreeDiagnosticEnumerator enumerator = new SyntaxTreeDiagnosticEnumerator((SyntaxTree)(object)this, node, position);
|
|
while (enumerator.MoveNext())
|
|
{
|
|
yield return enumerator.Current;
|
|
}
|
|
}
|
|
|
|
public override IEnumerable<Diagnostic> GetDiagnostics(SyntaxToken token)
|
|
{
|
|
if (((SyntaxToken)(ref token)).Node == null)
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
return GetDiagnostics(((SyntaxToken)(ref token)).Node, ((SyntaxToken)(ref token)).Position);
|
|
}
|
|
|
|
public override IEnumerable<Diagnostic> GetDiagnostics(SyntaxTrivia trivia)
|
|
{
|
|
if (((SyntaxTrivia)(ref trivia)).UnderlyingNode == null)
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
return GetDiagnostics(((SyntaxTrivia)(ref trivia)).UnderlyingNode, ((SyntaxTrivia)(ref trivia)).Position);
|
|
}
|
|
|
|
public override IEnumerable<Diagnostic> GetDiagnostics(SyntaxNodeOrToken nodeOrToken)
|
|
{
|
|
if (((SyntaxNodeOrToken)(ref nodeOrToken)).UnderlyingNode == null)
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
return GetDiagnostics(((SyntaxNodeOrToken)(ref nodeOrToken)).UnderlyingNode, ((SyntaxNodeOrToken)(ref nodeOrToken)).Position);
|
|
}
|
|
|
|
public override IEnumerable<Diagnostic> GetDiagnostics(CancellationToken cancellationToken = default(CancellationToken))
|
|
{
|
|
return ((SyntaxTree)this).GetDiagnostics((SyntaxNode)(object)GetRoot(cancellationToken));
|
|
}
|
|
|
|
protected override SyntaxNode GetRootCore(CancellationToken cancellationToken)
|
|
{
|
|
return (SyntaxNode)(object)GetRoot(cancellationToken);
|
|
}
|
|
|
|
protected override async Task<SyntaxNode> GetRootAsyncCore(CancellationToken cancellationToken)
|
|
{
|
|
return (SyntaxNode)(object)(await GetRootAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false));
|
|
}
|
|
|
|
protected override bool TryGetRootCore([NotNullWhen(true)] out SyntaxNode? root)
|
|
{
|
|
if (TryGetRoot(out CSharpSyntaxNode root2))
|
|
{
|
|
root = (SyntaxNode?)(object)root2;
|
|
return true;
|
|
}
|
|
root = null;
|
|
return false;
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
[Obsolete("The diagnosticOptions parameter is obsolete due to performance problems, if you are passing non-null use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public static SyntaxTree ParseText(SourceText text, CSharpParseOptions? options, string path, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, CancellationToken cancellationToken)
|
|
{
|
|
return ParseText(text, options, path, diagnosticOptions, null, cancellationToken);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
[Obsolete("The diagnosticOptions parameter is obsolete due to performance problems, if you are passing non-null use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public static SyntaxTree ParseText(string text, CSharpParseOptions? options, string path, Encoding? encoding, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, CancellationToken cancellationToken)
|
|
{
|
|
return ParseText(SourceText.From(text, encoding, (SourceHashAlgorithm)1), options, path, diagnosticOptions, null, cancellationToken);
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
[Obsolete("The diagnosticOptions parameter is obsolete due to performance problems, if you are passing non-null use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
|
public static SyntaxTree Create(CSharpSyntaxNode root, CSharpParseOptions? options, string? path, Encoding? encoding, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions)
|
|
{
|
|
return Create(root, options, path, encoding, diagnosticOptions, null);
|
|
}
|
|
|
|
internal string Dump()
|
|
{
|
|
return GetRoot().Dump();
|
|
}
|
|
}
|