using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading;
using Microsoft.Cci;
using Microsoft.CodeAnalysis.CSharp.Symbols;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.CodeGen;
using Microsoft.CodeAnalysis.PooledObjects;
using Microsoft.CodeAnalysis.Shared.Collections;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.CSharp;

internal sealed class CodeCoverageInstrumenter : CompoundInstrumenter
{
	private readonly MethodSymbol _method;

	private readonly BoundStatement _methodBody;

	private readonly MethodSymbol _createPayloadForMethodsSpanningSingleFile;

	private readonly MethodSymbol _createPayloadForMethodsSpanningMultipleFiles;

	private readonly ArrayBuilder<SourceSpan> _spansBuilder;

	private ImmutableArray<SourceSpan> _dynamicAnalysisSpans = ImmutableArray<SourceSpan>.Empty;

	private readonly BoundStatement? _methodEntryInstrumentation;

	private readonly ArrayTypeSymbol _payloadType;

	private readonly LocalSymbol _methodPayload;

	private readonly BindingDiagnosticBag _diagnostics;

	private readonly DebugDocumentProvider _debugDocumentProvider;

	private readonly SyntheticBoundNodeFactory _methodBodyFactory;

	public ImmutableArray<SourceSpan> DynamicAnalysisSpans => _dynamicAnalysisSpans;

	public static bool TryCreate(MethodSymbol method, BoundStatement methodBody, SyntheticBoundNodeFactory methodBodyFactory, BindingDiagnosticBag diagnostics, DebugDocumentProvider debugDocumentProvider, Instrumenter previous, [NotNullWhen(true)] out CodeCoverageInstrumenter? instrumenter)
	{
		instrumenter = null;
		if (method.IsImplicitlyDeclared && !method.IsImplicitConstructor)
		{
			return false;
		}
		if (IsExcludedFromCodeCoverage(method))
		{
			return false;
		}
		MethodSymbol createPayloadOverload = GetCreatePayloadOverload(methodBodyFactory.Compilation, (WellKnownMember)354, methodBody.Syntax, diagnostics);
		MethodSymbol createPayloadOverload2 = GetCreatePayloadOverload(methodBodyFactory.Compilation, (WellKnownMember)355, methodBody.Syntax, diagnostics);
		if ((object)createPayloadOverload == null || (object)createPayloadOverload2 == null)
		{
			return false;
		}
		if (method.Equals(createPayloadOverload) || method.Equals(createPayloadOverload2))
		{
			return false;
		}
		instrumenter = new CodeCoverageInstrumenter(method, methodBody, methodBodyFactory, createPayloadOverload, createPayloadOverload2, diagnostics, debugDocumentProvider, previous);
		return true;
	}

	private CodeCoverageInstrumenter(MethodSymbol method, BoundStatement methodBody, SyntheticBoundNodeFactory methodBodyFactory, MethodSymbol createPayloadForMethodsSpanningSingleFile, MethodSymbol createPayloadForMethodsSpanningMultipleFiles, BindingDiagnosticBag diagnostics, DebugDocumentProvider debugDocumentProvider, Instrumenter previous)
		: base(previous)
	{
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		_createPayloadForMethodsSpanningSingleFile = createPayloadForMethodsSpanningSingleFile;
		_createPayloadForMethodsSpanningMultipleFiles = createPayloadForMethodsSpanningMultipleFiles;
		_method = method;
		_methodBody = methodBody;
		_spansBuilder = ArrayBuilder<SourceSpan>.GetInstance();
		TypeSymbol typeSymbol = methodBodyFactory.SpecialType((SpecialType)7);
		_payloadType = ArrayTypeSymbol.CreateCSharpArray(methodBodyFactory.Compilation.Assembly, TypeWithAnnotations.Create(typeSymbol));
		_diagnostics = diagnostics;
		_debugDocumentProvider = debugDocumentProvider;
		_methodBodyFactory = methodBodyFactory;
		MethodSymbol currentFunction = methodBodyFactory.CurrentFunction;
		methodBodyFactory.CurrentFunction = method;
		_methodPayload = methodBodyFactory.SynthesizedLocal(_payloadType, methodBody.Syntax, isPinned: false, isKnownToReferToTempIfReferenceType: false, (RefKind)0, (SynthesizedLocalKind)34);
		SyntaxNode val = MethodDeclarationIfAvailable(methodBody.Syntax);
		if (!method.IsImplicitlyDeclared && !(method is SynthesizedSimpleProgramEntryPointSymbol))
		{
			_methodEntryInstrumentation = AddAnalysisPoint(val, SkipAttributes(val), methodBodyFactory);
		}
		methodBodyFactory.CurrentFunction = currentFunction;
	}

	protected override CompoundInstrumenter WithPreviousImpl(Instrumenter previous)
	{
		throw ExceptionUtilities.Unreachable("/_/src/Compilers/CSharp/Portable/Lowering/Instrumentation/CodeCoverageInstrumenter.cs", 139);
	}

	private static bool IsExcludedFromCodeCoverage(MethodSymbol method)
	{
		NamedTypeSymbol containingType = method.ContainingType;
		while ((object)containingType != null)
		{
			if (containingType.IsDirectlyExcludedFromCodeCoverage)
			{
				return true;
			}
			containingType = containingType.ContainingType;
		}
		if ((object)method != null)
		{
			if (method.IsDirectlyExcludedFromCodeCoverage)
			{
				return true;
			}
			Symbol associatedSymbol = method.AssociatedSymbol;
			if (associatedSymbol is PropertySymbol propertySymbol)
			{
				if (propertySymbol.IsDirectlyExcludedFromCodeCoverage)
				{
					return true;
				}
			}
			else if (associatedSymbol is EventSymbol { IsDirectlyExcludedFromCodeCoverage: not false })
			{
				return true;
			}
		}
		return false;
	}

	private static BoundExpressionStatement GetCreatePayloadStatement(ImmutableArray<SourceSpan> dynamicAnalysisSpans, SyntaxNode methodBodySyntax, LocalSymbol methodPayload, MethodSymbol createPayloadForMethodsSpanningSingleFile, MethodSymbol createPayloadForMethodsSpanningMultipleFiles, BoundExpression mvid, BoundExpression methodToken, BoundExpression payloadSlot, SyntheticBoundNodeFactory methodBodyFactory, DebugDocumentProvider debugDocumentProvider)
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		MethodSymbol method;
		BoundExpression boundExpression;
		if (dynamicAnalysisSpans.IsEmpty)
		{
			method = createPayloadForMethodsSpanningSingleFile;
			DebugSourceDocument sourceDocument = GetSourceDocument(debugDocumentProvider, methodBodySyntax);
			boundExpression = methodBodyFactory.SourceDocumentIndex(sourceDocument);
		}
		else
		{
			PooledHashSet<DebugSourceDocument> instance = PooledHashSet<DebugSourceDocument>.GetInstance();
			ArrayBuilder<BoundExpression> instance2 = ArrayBuilder<BoundExpression>.GetInstance();
			ImmutableArray<SourceSpan>.Enumerator enumerator = dynamicAnalysisSpans.GetEnumerator();
			while (enumerator.MoveNext())
			{
				DebugSourceDocument document = enumerator.Current.Document;
				if (((HashSet<DebugSourceDocument>)(object)instance).Add(document))
				{
					instance2.Add(methodBodyFactory.SourceDocumentIndex(document));
				}
			}
			instance.Free();
			if (instance2.Count == 1)
			{
				method = createPayloadForMethodsSpanningSingleFile;
				boundExpression = ((IEnumerable<BoundExpression>)instance2).Single();
			}
			else
			{
				method = createPayloadForMethodsSpanningMultipleFiles;
				boundExpression = methodBodyFactory.Array(methodBodyFactory.SpecialType((SpecialType)13), instance2.ToImmutable());
			}
			instance2.Free();
		}
		return methodBodyFactory.Assignment(methodBodyFactory.Local(methodPayload), methodBodyFactory.Call(null, method, mvid, methodToken, boundExpression, payloadSlot, methodBodyFactory.Literal(dynamicAnalysisSpans.Length)));
	}

	public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)
	{
		base.InstrumentBlock(original, rewriter, ref additionalLocals, out BoundStatement prologue2, out epilogue, out instrumentation);
		if (original != rewriter.CurrentMethodBody)
		{
			prologue = prologue2;
			return;
		}
		_dynamicAnalysisSpans = _spansBuilder.ToImmutableAndFree();
		ArrayTypeSymbol payloadType = ArrayTypeSymbol.CreateCSharpArray(_methodBodyFactory.Compilation.Assembly, TypeWithAnnotations.Create(_payloadType));
		BoundStatement boundStatement = _methodBodyFactory.Assignment(_methodBodyFactory.Local(_methodPayload), _methodBodyFactory.ArrayAccess(_methodBodyFactory.InstrumentationPayloadRoot(0, payloadType), ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method))));
		BoundExpression mvid = _methodBodyFactory.ModuleVersionId();
		BoundExpression methodToken = _methodBodyFactory.MethodDefIndex(_method);
		BoundExpression payloadSlot = _methodBodyFactory.ArrayAccess(_methodBodyFactory.InstrumentationPayloadRoot(0, payloadType), ImmutableArray.Create(_methodBodyFactory.MethodDefIndex(_method)));
		BoundStatement createPayloadStatement = GetCreatePayloadStatement(_dynamicAnalysisSpans, _methodBody.Syntax, _methodPayload, _createPayloadForMethodsSpanningSingleFile, _createPayloadForMethodsSpanningMultipleFiles, mvid, methodToken, payloadSlot, _methodBodyFactory, _debugDocumentProvider);
		BoundExpression condition = _methodBodyFactory.Binary(BinaryOperatorKind.ObjectEqual, _methodBodyFactory.SpecialType((SpecialType)7), _methodBodyFactory.Local(_methodPayload), _methodBodyFactory.Null(_payloadType));
		BoundStatement boundStatement2 = _methodBodyFactory.If(condition, createPayloadStatement);
		additionalLocals.Add(_methodPayload);
		ArrayBuilder<BoundStatement> instance = ArrayBuilder<BoundStatement>.GetInstance(2 + ((_methodEntryInstrumentation != null) ? 1 : 0) + ((prologue2 != null) ? 1 : 0));
		instance.Add(boundStatement);
		instance.Add(boundStatement2);
		if (_methodEntryInstrumentation != null)
		{
			instance.Add(_methodEntryInstrumentation);
		}
		if (prologue2 != null)
		{
			instance.Add(prologue2);
		}
		prologue = _methodBodyFactory.StatementList(instance.ToImmutableAndFree());
	}

	public override BoundStatement InstrumentNoOpStatement(BoundNoOpStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentNoOpStatement(original, rewritten));
	}

	public override BoundStatement InstrumentBreakStatement(BoundBreakStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentBreakStatement(original, rewritten));
	}

	public override BoundStatement InstrumentContinueStatement(BoundContinueStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentContinueStatement(original, rewritten));
	}

	public override BoundStatement InstrumentExpressionStatement(BoundExpressionStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentExpressionStatement(original, rewritten));
	}

	public override BoundStatement InstrumentFieldOrPropertyInitializer(BoundStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentFieldOrPropertyInitializer(original, rewritten));
	}

	public override BoundStatement InstrumentGotoStatement(BoundGotoStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentGotoStatement(original, rewritten));
	}

	public override BoundStatement InstrumentThrowStatement(BoundThrowStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentThrowStatement(original, rewritten));
	}

	public override BoundStatement InstrumentYieldBreakStatement(BoundYieldBreakStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentYieldBreakStatement(original, rewritten));
	}

	public override BoundStatement InstrumentYieldReturnStatement(BoundYieldReturnStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentYieldReturnStatement(original, rewritten));
	}

	public override BoundStatement InstrumentForEachStatementIterationVarDeclaration(BoundForEachStatement original, BoundStatement iterationVarDecl)
	{
		return AddDynamicAnalysis(original, base.InstrumentForEachStatementIterationVarDeclaration(original, iterationVarDecl));
	}

	public override BoundStatement InstrumentForEachStatementDeconstructionVariablesDeclaration(BoundForEachStatement original, BoundStatement iterationVarDecl)
	{
		return AddDynamicAnalysis(original, base.InstrumentForEachStatementDeconstructionVariablesDeclaration(original, iterationVarDecl));
	}

	public override BoundStatement InstrumentIfStatement(BoundIfStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentIfStatement(original, rewritten));
	}

	public override BoundStatement InstrumentWhileStatementConditionalGotoStartOrBreak(BoundWhileStatement original, BoundStatement ifConditionGotoStart)
	{
		return AddDynamicAnalysis(original, base.InstrumentWhileStatementConditionalGotoStartOrBreak(original, ifConditionGotoStart));
	}

	public override BoundStatement InstrumentUserDefinedLocalInitialization(BoundLocalDeclaration original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentUserDefinedLocalInitialization(original, rewritten));
	}

	public override BoundStatement InstrumentLockTargetCapture(BoundLockStatement original, BoundStatement lockTargetCapture)
	{
		return AddDynamicAnalysis(original, base.InstrumentLockTargetCapture(original, lockTargetCapture));
	}

	public override BoundStatement InstrumentReturnStatement(BoundReturnStatement original, BoundStatement rewritten)
	{
		rewritten = base.InstrumentReturnStatement(original, rewritten);
		if (ReturnsValueWithinExpressionBodiedConstruct(original))
		{
			return CollectDynamicAnalysis(original, rewritten);
		}
		return AddDynamicAnalysis(original, rewritten);
	}

	private static bool ReturnsValueWithinExpressionBodiedConstruct(BoundReturnStatement returnStatement)
	{
		if (returnStatement.WasCompilerGenerated && returnStatement.ExpressionOpt != null && returnStatement.ExpressionOpt.Syntax != null)
		{
			SyntaxKind syntaxKind = returnStatement.ExpressionOpt.Syntax.Parent.Kind();
			if (syntaxKind - 8642 <= SyntaxKind.List || syntaxKind == SyntaxKind.ArrowExpressionClause)
			{
				return true;
			}
		}
		return false;
	}

	public override BoundStatement InstrumentSwitchStatement(BoundSwitchStatement original, BoundStatement rewritten)
	{
		return AddDynamicAnalysis(original, base.InstrumentSwitchStatement(original, rewritten));
	}

	public override BoundStatement InstrumentSwitchWhenClauseConditionalGotoBody(BoundExpression original, BoundStatement ifConditionGotoBody)
	{
		ifConditionGotoBody = base.InstrumentSwitchWhenClauseConditionalGotoBody(original, ifConditionGotoBody);
		WhenClauseSyntax whenClauseSyntax = original.Syntax.FirstAncestorOrSelf<WhenClauseSyntax>((Func<WhenClauseSyntax, bool>)null, true);
		SyntheticBoundNodeFactory syntheticBoundNodeFactory = new SyntheticBoundNodeFactory(_method, (SyntaxNode)(object)whenClauseSyntax, _methodBodyFactory.CompilationState, _diagnostics);
		return syntheticBoundNodeFactory.StatementList(AddAnalysisPoint((SyntaxNode)(object)whenClauseSyntax, syntheticBoundNodeFactory), ifConditionGotoBody);
	}

	public override BoundStatement InstrumentUsingTargetCapture(BoundUsingStatement original, BoundStatement usingTargetCapture)
	{
		return AddDynamicAnalysis(original, base.InstrumentUsingTargetCapture(original, usingTargetCapture));
	}

	private BoundStatement AddDynamicAnalysis(BoundStatement original, BoundStatement rewritten)
	{
		if (!original.WasCompilerGenerated && (!original.IsConstructorInitializer() || original.Syntax.Kind() != SyntaxKind.ConstructorDeclaration))
		{
			return CollectDynamicAnalysis(original, rewritten);
		}
		return rewritten;
	}

	private BoundStatement CollectDynamicAnalysis(BoundStatement original, BoundStatement rewritten)
	{
		SyntheticBoundNodeFactory syntheticBoundNodeFactory = new SyntheticBoundNodeFactory(_method, original.Syntax, _methodBodyFactory.CompilationState, _diagnostics);
		return syntheticBoundNodeFactory.StatementList(AddAnalysisPoint(SyntaxForSpan(original), syntheticBoundNodeFactory), rewritten);
	}

	private static DebugSourceDocument GetSourceDocument(DebugDocumentProvider debugDocumentProvider, SyntaxNode syntax)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		return GetSourceDocument(debugDocumentProvider, syntax, syntax.GetLocation().GetMappedLineSpan());
	}

	private static DebugSourceDocument GetSourceDocument(DebugDocumentProvider debugDocumentProvider, SyntaxNode syntax, FileLinePositionSpan span)
	{
		string text = ((FileLinePositionSpan)(ref span)).Path;
		if (text.Length == 0)
		{
			text = syntax.SyntaxTree.FilePath;
		}
		return debugDocumentProvider.Invoke(text, "");
	}

	private BoundStatement AddAnalysisPoint(SyntaxNode syntaxForSpan, TextSpan alternateSpan, SyntheticBoundNodeFactory statementFactory)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		return AddAnalysisPoint(syntaxForSpan, syntaxForSpan.SyntaxTree.GetMappedLineSpan(alternateSpan, default(CancellationToken)), statementFactory);
	}

	private BoundStatement AddAnalysisPoint(SyntaxNode syntaxForSpan, SyntheticBoundNodeFactory statementFactory)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		return AddAnalysisPoint(syntaxForSpan, syntaxForSpan.GetLocation().GetMappedLineSpan(), statementFactory);
	}

	private BoundStatement AddAnalysisPoint(SyntaxNode syntaxForSpan, FileLinePositionSpan span, SyntheticBoundNodeFactory statementFactory)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: 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_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		int count = _spansBuilder.Count;
		ArrayBuilder<SourceSpan> spansBuilder = _spansBuilder;
		DebugSourceDocument sourceDocument = GetSourceDocument(_debugDocumentProvider, syntaxForSpan, span);
		LinePosition val = ((FileLinePositionSpan)(ref span)).StartLinePosition;
		int line = ((LinePosition)(ref val)).Line;
		val = ((FileLinePositionSpan)(ref span)).StartLinePosition;
		int character = ((LinePosition)(ref val)).Character;
		val = ((FileLinePositionSpan)(ref span)).EndLinePosition;
		int line2 = ((LinePosition)(ref val)).Line;
		val = ((FileLinePositionSpan)(ref span)).EndLinePosition;
		spansBuilder.Add(new SourceSpan(sourceDocument, line, character, line2, ((LinePosition)(ref val)).Character));
		BoundArrayAccess left = statementFactory.ArrayAccess(statementFactory.Local(_methodPayload), statementFactory.Literal(count));
		return statementFactory.Assignment(left, statementFactory.Literal(value: true));
	}

	private static SyntaxNode SyntaxForSpan(BoundStatement statement)
	{
		switch (statement.Kind)
		{
		case BoundKind.IfStatement:
			return ((BoundIfStatement)statement).Condition.Syntax;
		case BoundKind.WhileStatement:
			return ((BoundWhileStatement)statement).Condition.Syntax;
		case BoundKind.ForEachStatement:
			return ((BoundForEachStatement)statement).Expression.Syntax;
		case BoundKind.DoStatement:
			return ((BoundDoStatement)statement).Condition.Syntax;
		case BoundKind.UsingStatement:
		{
			BoundUsingStatement boundUsingStatement = (BoundUsingStatement)statement;
			return ((BoundNode)(((object)boundUsingStatement.ExpressionOpt) ?? ((object)boundUsingStatement.DeclarationsOpt))).Syntax;
		}
		case BoundKind.FixedStatement:
			return ((BoundFixedStatement)statement).Declarations.Syntax;
		case BoundKind.LockStatement:
			return ((BoundLockStatement)statement).Argument.Syntax;
		case BoundKind.SwitchStatement:
			return ((BoundSwitchStatement)statement).Expression.Syntax;
		default:
			return statement.Syntax;
		}
	}

	private static MethodSymbol GetCreatePayloadOverload(CSharpCompilation compilation, WellKnownMember overload, SyntaxNode syntax, BindingDiagnosticBag diagnostics)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		return (MethodSymbol)Binder.GetWellKnownTypeMember(compilation, overload, diagnostics, null, syntax);
	}

	private static SyntaxNode MethodDeclarationIfAvailable(SyntaxNode body)
	{
		SyntaxNode parent = body.Parent;
		if (parent != null)
		{
			switch (parent.Kind())
			{
			case SyntaxKind.MethodDeclaration:
			case SyntaxKind.OperatorDeclaration:
			case SyntaxKind.ConstructorDeclaration:
			case SyntaxKind.PropertyDeclaration:
			case SyntaxKind.GetAccessorDeclaration:
			case SyntaxKind.SetAccessorDeclaration:
			case SyntaxKind.InitAccessorDeclaration:
				return parent;
			}
		}
		return body;
	}

	private static TextSpan SkipAttributes(SyntaxNode syntax)
	{
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0111: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		switch (syntax.Kind())
		{
		case SyntaxKind.MethodDeclaration:
		{
			MethodDeclarationSyntax methodDeclarationSyntax = (MethodDeclarationSyntax)(object)syntax;
			return SkipAttributes(syntax, methodDeclarationSyntax.AttributeLists, methodDeclarationSyntax.Modifiers, default(SyntaxToken), methodDeclarationSyntax.ReturnType);
		}
		case SyntaxKind.PropertyDeclaration:
		{
			PropertyDeclarationSyntax propertyDeclarationSyntax = (PropertyDeclarationSyntax)(object)syntax;
			return SkipAttributes(syntax, propertyDeclarationSyntax.AttributeLists, propertyDeclarationSyntax.Modifiers, default(SyntaxToken), propertyDeclarationSyntax.Type);
		}
		case SyntaxKind.GetAccessorDeclaration:
		case SyntaxKind.SetAccessorDeclaration:
		case SyntaxKind.InitAccessorDeclaration:
		{
			AccessorDeclarationSyntax accessorDeclarationSyntax = (AccessorDeclarationSyntax)(object)syntax;
			return SkipAttributes(syntax, accessorDeclarationSyntax.AttributeLists, accessorDeclarationSyntax.Modifiers, accessorDeclarationSyntax.Keyword, null);
		}
		case SyntaxKind.ConstructorDeclaration:
		{
			ConstructorDeclarationSyntax constructorDeclarationSyntax = (ConstructorDeclarationSyntax)(object)syntax;
			return SkipAttributes(syntax, constructorDeclarationSyntax.AttributeLists, constructorDeclarationSyntax.Modifiers, constructorDeclarationSyntax.Identifier, null);
		}
		case SyntaxKind.OperatorDeclaration:
		{
			OperatorDeclarationSyntax operatorDeclarationSyntax = (OperatorDeclarationSyntax)(object)syntax;
			return SkipAttributes(syntax, operatorDeclarationSyntax.AttributeLists, operatorDeclarationSyntax.Modifiers, operatorDeclarationSyntax.OperatorKeyword, null);
		}
		default:
			return syntax.Span;
		}
	}

	private static TextSpan SkipAttributes(SyntaxNode syntax, SyntaxList<AttributeListSyntax> attributes, SyntaxTokenList modifiers, SyntaxToken keyword, TypeSyntax? type)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		TextSpan span = syntax.Span;
		if (attributes.Count > 0)
		{
			TextSpan val = ((((SyntaxTokenList)(ref modifiers)).Node != null) ? ((SyntaxTokenList)(ref modifiers)).Span : ((((SyntaxToken)(ref keyword)).Node != null) ? ((SyntaxToken)(ref keyword)).Span : ((SyntaxNode)type).Span));
			return new TextSpan(((TextSpan)(ref val)).Start, ((TextSpan)(ref span)).Length - (((TextSpan)(ref val)).Start - ((TextSpan)(ref span)).Start));
		}
		return span;
	}
}