10833 lines
753 KiB
C#
10833 lines
753 KiB
C#
|
using System;
|
||
|
|
using System.Collections.Generic;
|
||
|
|
using System.Collections.Immutable;
|
||
|
|
using System.ComponentModel;
|
||
|
|
using System.Linq;
|
||
|
|
using System.Text;
|
||
|
|
using System.Threading;
|
||
|
|
using System.Xml.Linq;
|
||
|
|
using Microsoft.CodeAnalysis.CSharp.Syntax;
|
||
|
|
using Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax;
|
||
|
|
using Microsoft.CodeAnalysis.Syntax;
|
||
|
|
using Microsoft.CodeAnalysis.Syntax.InternalSyntax;
|
||
|
|
using Microsoft.CodeAnalysis.Text;
|
||
|
|
using Roslyn.Utilities;
|
||
|
|
|
||
|
|
namespace Microsoft.CodeAnalysis.CSharp;
|
||
|
|
|
||
|
|
public static class SyntaxFactory
|
||
|
|
{
|
||
|
|
public static SyntaxTrivia CarriageReturnLineFeed { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CarriageReturnLineFeed;
|
||
|
|
|
||
|
|
public static SyntaxTrivia LineFeed { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LineFeed;
|
||
|
|
|
||
|
|
public static SyntaxTrivia CarriageReturn { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CarriageReturn;
|
||
|
|
|
||
|
|
public static SyntaxTrivia Space { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Space;
|
||
|
|
|
||
|
|
public static SyntaxTrivia Tab { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Tab;
|
||
|
|
|
||
|
|
public static SyntaxTrivia ElasticCarriageReturnLineFeed { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElasticCarriageReturnLineFeed;
|
||
|
|
|
||
|
|
public static SyntaxTrivia ElasticLineFeed { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElasticLineFeed;
|
||
|
|
|
||
|
|
public static SyntaxTrivia ElasticCarriageReturn { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElasticCarriageReturn;
|
||
|
|
|
||
|
|
public static SyntaxTrivia ElasticSpace { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElasticSpace;
|
||
|
|
|
||
|
|
public static SyntaxTrivia ElasticTab { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElasticTab;
|
||
|
|
|
||
|
|
public static SyntaxTrivia ElasticMarker { get; } = Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElasticZeroSpace;
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax AnonymousMethodExpression()
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SyntaxFactory.AnonymousMethodExpression(default(SyntaxToken), Token(SyntaxKind.DelegateKeyword), (Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax)null, Block(), (Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax AnonymousMethodExpression(SyntaxToken asyncKeyword, SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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)
|
||
|
|
return AnonymousMethodExpression(TokenList(asyncKeyword), delegateKeyword, parameterList, block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax Block(SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements, SyntaxToken closeBraceToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: 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)
|
||
|
|
return Block(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), openBraceToken, statements, closeBraceToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax BreakStatement(SyntaxToken breakKeyword, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return BreakStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), breakKeyword, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax CheckedStatement(SyntaxKind kind, SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CheckedStatement(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), keyword, block);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax ConstructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax? initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConstructorDeclaration(attributeLists, modifiers, identifier, parameterList, initializer, body, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax ConstructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax? initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConstructorDeclaration(attributeLists, modifiers, identifier, parameterList, initializer, body, null, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax ConstructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConstructorDeclaration(attributeLists, modifiers, identifier, parameterList, initializer, null, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax ConstructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax initializer, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConstructorDeclaration(attributeLists, modifiers, identifier, parameterList, initializer, null, expressionBody, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax ContinueStatement(SyntaxToken continueKeyword, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ContinueStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), continueKeyword, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax DestructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DestructorDeclaration(attributeLists, modifiers, Token(SyntaxKind.TildeToken), identifier, parameterList, body, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax DestructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken tildeToken, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DestructorDeclaration(attributeLists, modifiers, tildeToken, identifier, parameterList, body, null, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax DestructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DestructorDeclaration(attributeLists, modifiers, Token(SyntaxKind.TildeToken), identifier, parameterList, null, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax DestructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken tildeToken, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DestructorDeclaration(attributeLists, modifiers, tildeToken, identifier, parameterList, null, expressionBody, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax DoStatement(SyntaxToken doKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, SyntaxToken whileKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, SyntaxToken closeParenToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: 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)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DoStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax EmptyStatement(SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EmptyStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ExpressionStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), expression, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax FixedStatement(SyntaxToken fixedKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FixedStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), fixedKeyword, openParenToken, declaration, closeParenToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax ForEachStatement(SyntaxToken forEachKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken identifier, SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForEachStatement(default(SyntaxToken), forEachKeyword, openParenToken, type, identifier, inKeyword, expression, closeParenToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax ForEachStatement(SyntaxToken awaitKeyword, SyntaxToken forEachKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken identifier, SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: 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)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForEachStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), awaitKeyword, forEachKeyword, openParenToken, type, identifier, inKeyword, expression, closeParenToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax ForEachVariableStatement(SyntaxToken forEachKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForEachVariableStatement(default(SyntaxToken), forEachKeyword, openParenToken, variable, inKeyword, expression, closeParenToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax ForEachVariableStatement(SyntaxToken awaitKeyword, SyntaxToken forEachKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: 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)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForEachVariableStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), awaitKeyword, forEachKeyword, openParenToken, variable, inKeyword, expression, closeParenToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), declaration, initializers, condition, incrementors, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax ForStatement(SyntaxToken forKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers, SyntaxToken firstSemicolonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition, SyntaxToken secondSemicolonToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), forKeyword, openParenToken, declaration, initializers, firstSemicolonToken, condition, secondSemicolonToken, incrementors, closeParenToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax GotoStatement(SyntaxKind kind, SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return GotoStatement(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), caseOrDefaultKeyword, expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax GotoStatement(SyntaxKind kind, SyntaxToken gotoKeyword, SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: 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)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return GotoStatement(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), gotoKeyword, caseOrDefaultKeyword, expression, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? @else)
|
||
|
|
{
|
||
|
|
//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 IfStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), condition, statement, @else);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax IfStatement(SyntaxToken ifKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? @else)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IfStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), ifKeyword, openParenToken, condition, closeParenToken, statement, @else);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax IndexerDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IndexerDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, parameterList, accessorList, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax InterpolatedStringExpression(SyntaxToken stringStartToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
return InterpolatedStringExpression(stringStartToken, Token(SyntaxKind.InterpolatedStringEndToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax InterpolatedStringExpression(SyntaxToken stringStartToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax> contents)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return InterpolatedStringExpression(stringStartToken, contents, Token(SyntaxKind.InterpolatedStringEndToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax LabeledStatement(SyntaxToken identifier, SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LabeledStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), identifier, colonToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax LiteralExpression(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LiteralExpression(kind, Token(GetLiteralExpressionTokenKind(kind)));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetLiteralExpressionTokenKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.ArgListExpression => SyntaxKind.ArgListKeyword,
|
||
|
|
SyntaxKind.NumericLiteralExpression => SyntaxKind.NumericLiteralToken,
|
||
|
|
SyntaxKind.StringLiteralExpression => SyntaxKind.StringLiteralToken,
|
||
|
|
SyntaxKind.Utf8StringLiteralExpression => SyntaxKind.Utf8StringLiteralToken,
|
||
|
|
SyntaxKind.CharacterLiteralExpression => SyntaxKind.CharacterLiteralToken,
|
||
|
|
SyntaxKind.TrueLiteralExpression => SyntaxKind.TrueKeyword,
|
||
|
|
SyntaxKind.FalseLiteralExpression => SyntaxKind.FalseKeyword,
|
||
|
|
SyntaxKind.NullLiteralExpression => SyntaxKind.NullKeyword,
|
||
|
|
SyntaxKind.DefaultLiteralExpression => SyntaxKind.DefaultKeyword,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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)
|
||
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LocalDeclarationStatement(default(SyntaxToken), default(SyntaxToken), modifiers, declaration, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxToken awaitKeyword, SyntaxToken usingKeyword, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: 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)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LocalDeclarationStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), awaitKeyword, usingKeyword, modifiers, declaration, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LocalDeclarationStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), modifiers, declaration);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: 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)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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 LocalFunctionStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), modifiers, returnType, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: 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)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LocalFunctionStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), modifiers, returnType, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax LockStatement(SyntaxToken lockKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LockStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), lockKeyword, openParenToken, expression, closeParenToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax MethodDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return MethodDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses, body, null, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return NameColon(name, Token(SyntaxKind.ColonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax NameColon(string name)
|
||
|
|
{
|
||
|
|
return NameColon(IdentifierName(name));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ParenthesizedLambdaExpression(TokenList(asyncKeyword), parameterList, arrowToken, block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//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 ParenthesizedLambdaExpression(default(SyntaxTokenList), parameterList, block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ParenthesizedLambdaExpression(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), modifiers, null, parameterList, arrowToken, block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ParenthesizedLambdaExpression(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), modifiers, parameterList, block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ParenthesizedLambdaExpression(attributeLists, modifiers, null, parameterList, block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_0019: 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_0028: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AccessorDeclaration(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(GetAccessorDeclarationKeywordKind(kind)), body, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax RecordDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0005: 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_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return RecordDeclaration(SyntaxKind.RecordDeclaration, attributeLists, modifiers, keyword, default(SyntaxToken), identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax RecordDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0019: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: 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_002d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0055: 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_004c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0063: 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_0067: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxToken semicolonToken = (SyntaxToken)((members.Count == 0) ? Token(SyntaxKind.SemicolonToken) : default(SyntaxToken));
|
||
|
|
SyntaxToken openBraceToken = (SyntaxToken)((members.Count == 0) ? default(SyntaxToken) : Token(SyntaxKind.OpenBraceToken));
|
||
|
|
SyntaxToken closeBraceToken = (SyntaxToken)((members.Count == 0) ? default(SyntaxToken) : Token(SyntaxKind.CloseBraceToken));
|
||
|
|
return RecordDeclaration(SyntaxKind.RecordDeclaration, attributeLists, modifiers, keyword, default(SyntaxToken), identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax RecordDeclaration(SyntaxToken keyword, string identifier)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
return RecordDeclaration(keyword, Identifier(identifier));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax RecordDeclaration(SyntaxToken keyword, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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_0027: 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_0030: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: 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_003f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return RecordDeclaration(SyntaxKind.RecordDeclaration, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), keyword, default(SyntaxToken), identifier, null, null, null, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), default(SyntaxToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), default(SyntaxToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax RefType(SyntaxToken refKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return RefType(refKeyword, default(SyntaxToken), type);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax ReturnStatement(SyntaxToken returnKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: 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)
|
||
|
|
return ReturnStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), returnKeyword, expression, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax SimpleLambdaExpression(SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SimpleLambdaExpression(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), TokenList(asyncKeyword), parameter, arrowToken, block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SimpleLambdaExpression(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), parameter, block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax SimpleLambdaExpression(SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: 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)
|
||
|
|
return SimpleLambdaExpression(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), modifiers, parameter, arrowToken, block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax SimpleLambdaExpression(SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SimpleLambdaExpression(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), modifiers, parameter, block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax StackAllocArrayCreationExpression(SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return StackAllocArrayCreationExpression(stackAllocKeyword, type, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern)
|
||
|
|
{
|
||
|
|
return Subpattern((Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax?)nameColon, pattern);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax SwitchStatement(SyntaxToken switchKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax> sections, SyntaxToken closeBraceToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SwitchStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, sections, closeBraceToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTrivia EndOfLine(string text)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EndOfLine(text);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTrivia ElasticEndOfLine(string text)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EndOfLine(text, elastic: true);
|
||
|
|
}
|
||
|
|
|
||
|
|
[Obsolete("Use SyntaxFactory.EndOfLine or SyntaxFactory.ElasticEndOfLine")]
|
||
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
||
|
|
public static SyntaxTrivia EndOfLine(string text, bool elastic)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EndOfLine(text, elastic);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTrivia Whitespace(string text)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Whitespace(text);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTrivia ElasticWhitespace(string text)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Whitespace(text);
|
||
|
|
}
|
||
|
|
|
||
|
|
[Obsolete("Use SyntaxFactory.Whitespace or SyntaxFactory.ElasticWhitespace")]
|
||
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
||
|
|
public static SyntaxTrivia Whitespace(string text, bool elastic)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Whitespace(text, elastic);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTrivia Comment(string text)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Comment(text);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTrivia DisabledText(string text)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DisabledText(text);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTrivia PreprocessingMessage(string text)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PreprocessingMessage(text);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTrivia SyntaxTrivia(SyntaxKind kind, string text)
|
||
|
|
{
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (text == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("text");
|
||
|
|
}
|
||
|
|
if (kind - 8539 <= (SyntaxKind)4 || kind == SyntaxKind.DisabledTextTrivia)
|
||
|
|
{
|
||
|
|
SyntaxToken val = default(SyntaxToken);
|
||
|
|
return new SyntaxTrivia(ref val, (GreenNode)(object)new SyntaxTrivia(kind, text), 0, 0);
|
||
|
|
}
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Token(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Token(underlyingNode, kind, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Token(SyntaxTriviaList leading, SyntaxKind kind, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Token(((SyntaxTriviaList)(ref leading)).Node, kind, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Token(SyntaxTriviaList leading, SyntaxKind kind, string text, string valueText, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
switch (kind)
|
||
|
|
{
|
||
|
|
case SyntaxKind.IdentifierToken:
|
||
|
|
throw new ArgumentException(CSharpResources.UseVerbatimIdentifier, "kind");
|
||
|
|
case SyntaxKind.CharacterLiteralToken:
|
||
|
|
throw new ArgumentException(CSharpResources.UseLiteralForTokens, "kind");
|
||
|
|
case SyntaxKind.NumericLiteralToken:
|
||
|
|
throw new ArgumentException(CSharpResources.UseLiteralForNumeric, "kind");
|
||
|
|
default:
|
||
|
|
if (!SyntaxFacts.IsAnyToken(kind))
|
||
|
|
{
|
||
|
|
throw new ArgumentException(string.Format(CSharpResources.ThisMethodCanOnlyBeUsedToCreateTokens, kind), "kind");
|
||
|
|
}
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Token(((SyntaxTriviaList)(ref leading)).Node, kind, text, valueText, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken MissingToken(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.MissingToken(underlyingNode, kind, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken MissingToken(SyntaxTriviaList leading, SyntaxKind kind, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.MissingToken(((SyntaxTriviaList)(ref leading)).Node, kind, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Identifier(string text)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Identifier(underlyingNode, text, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Identifier(SyntaxTriviaList leading, string text, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Identifier(((SyntaxTriviaList)(ref leading)).Node, text, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken VerbatimIdentifier(SyntaxTriviaList leading, string text, string valueText, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (text.StartsWith("@", StringComparison.Ordinal))
|
||
|
|
{
|
||
|
|
throw new ArgumentException("text should not start with an @ character.");
|
||
|
|
}
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Identifier(SyntaxKind.IdentifierName, ((SyntaxTriviaList)(ref leading)).Node, "@" + text, valueText, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Identifier(SyntaxTriviaList leading, SyntaxKind contextualKind, string text, string valueText, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Identifier(contextualKind, ((SyntaxTriviaList)(ref leading)).Node, text, valueText, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(int value)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Literal(ObjectDisplay.FormatLiteral(value, (ObjectDisplayOptions)0), value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(string text, int value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(underlyingNode, text, value, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(SyntaxTriviaList leading, string text, int value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(uint value)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Literal(ObjectDisplay.FormatLiteral(value, (ObjectDisplayOptions)2), value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(string text, uint value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(underlyingNode, text, value, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(SyntaxTriviaList leading, string text, uint value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(long value)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Literal(ObjectDisplay.FormatLiteral(value, (ObjectDisplayOptions)2), value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(string text, long value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(underlyingNode, text, value, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(SyntaxTriviaList leading, string text, long value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(ulong value)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Literal(ObjectDisplay.FormatLiteral(value, (ObjectDisplayOptions)2), value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(string text, ulong value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(underlyingNode, text, value, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(SyntaxTriviaList leading, string text, ulong value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(float value)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Literal(ObjectDisplay.FormatLiteral(value, (ObjectDisplayOptions)2), value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(string text, float value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(underlyingNode, text, value, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(SyntaxTriviaList leading, string text, float value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(double value)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Literal(ObjectDisplay.FormatLiteral(value, (ObjectDisplayOptions)0), value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(string text, double value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(underlyingNode, text, value, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(SyntaxTriviaList leading, string text, double value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(decimal value)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Literal(ObjectDisplay.FormatLiteral(value, (ObjectDisplayOptions)2), value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(string text, decimal value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(underlyingNode, text, value, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(SyntaxTriviaList leading, string text, decimal value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(string value)
|
||
|
|
{
|
||
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Literal(SymbolDisplay.FormatLiteral(value, quote: true), value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(string text, string value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(underlyingNode, text, value, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(SyntaxTriviaList leading, string text, string value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(char value)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Literal(ObjectDisplay.FormatLiteral(value, (ObjectDisplayOptions)24), value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(string text, char value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(underlyingNode, text, value, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken Literal(SyntaxTriviaList leading, string text, char value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Literal(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken BadToken(SyntaxTriviaList leading, string text, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.BadToken(((SyntaxTriviaList)(ref leading)).Node, text, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken XmlTextLiteral(SyntaxTriviaList leading, string text, string value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlTextLiteral(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken XmlEntity(SyntaxTriviaList leading, string text, string value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlEntity(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax DocumentationComment(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0006: 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)
|
||
|
|
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SyntaxNodeExtensions.WithTrailingTrivia<Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax>(SyntaxNodeExtensions.WithLeadingTrivia<Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax>(DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia, List(content)), (SyntaxTrivia[])(object)new SyntaxTrivia[1] { DocumentationCommentExterior("/// ") }), (SyntaxTrivia[])(object)new SyntaxTrivia[1] { EndOfLine("") });
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlSummaryElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlSummaryElement(List(content));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlSummaryElement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlMultiLineElement("summary", content);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlSeeElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref)
|
||
|
|
{
|
||
|
|
return XmlEmptyElement("see").AddAttributes(XmlCrefAttribute(cref));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlSeeAlsoElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref)
|
||
|
|
{
|
||
|
|
return XmlEmptyElement("seealso").AddAttributes(XmlCrefAttribute(cref));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlSeeAlsoElement(Uri linkAddress, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> linkText)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax xmlElementSyntax = XmlElement("seealso", linkText);
|
||
|
|
return xmlElementSyntax.WithStartTag(xmlElementSyntax.StartTag.AddAttributes(XmlTextAttribute("cref", linkAddress.ToString())));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlThreadSafetyElement()
|
||
|
|
{
|
||
|
|
return XmlThreadSafetyElement(isStatic: true, isInstance: false);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlThreadSafetyElement(bool isStatic, bool isInstance)
|
||
|
|
{
|
||
|
|
return XmlEmptyElement("threadsafety").AddAttributes(XmlTextAttribute("static", isStatic.ToString().ToLowerInvariant()), XmlTextAttribute("instance", isInstance.ToString().ToLowerInvariant()));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax XmlNameAttribute(string parameterName)
|
||
|
|
{
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SyntaxNodeExtensions.WithLeadingTrivia<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax>(XmlNameAttribute(XmlName("name"), Token(SyntaxKind.DoubleQuoteToken), parameterName, Token(SyntaxKind.DoubleQuoteToken)), (SyntaxTrivia[])(object)new SyntaxTrivia[1] { Whitespace(" ") });
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlPreliminaryElement()
|
||
|
|
{
|
||
|
|
return XmlEmptyElement("preliminary");
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref)
|
||
|
|
{
|
||
|
|
return XmlCrefAttribute(cref, SyntaxKind.DoubleQuoteToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, SyntaxKind quoteKind)
|
||
|
|
{
|
||
|
|
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
cref = SyntaxNodeExtensions.ReplaceTokens<Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax>(cref, ((SyntaxNode)cref).DescendantTokens((Func<SyntaxNode, bool>)null, false), (Func<SyntaxToken, SyntaxToken, SyntaxToken>)XmlReplaceBracketTokens);
|
||
|
|
return SyntaxNodeExtensions.WithLeadingTrivia<Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax>(XmlCrefAttribute(XmlName("cref"), Token(quoteKind), cref, Token(quoteKind)), (SyntaxTrivia[])(object)new SyntaxTrivia[1] { Whitespace(" ") });
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlRemarksElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlRemarksElement(List(content));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlRemarksElement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlMultiLineElement("remarks", content);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlReturnsElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlReturnsElement(List(content));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlReturnsElement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlMultiLineElement("returns", content);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlValueElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlValueElement(List(content));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlValueElement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlMultiLineElement("value", content);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlExceptionElement(cref, List(content));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlExceptionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax xmlElementSyntax = XmlElement("exception", content);
|
||
|
|
return xmlElementSyntax.WithStartTag(xmlElementSyntax.StartTag.AddAttributes(XmlCrefAttribute(cref)));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlPermissionElement(cref, List(content));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlPermissionElement(Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax xmlElementSyntax = XmlElement("permission", content);
|
||
|
|
return xmlElementSyntax.WithStartTag(xmlElementSyntax.StartTag.AddAttributes(XmlCrefAttribute(cref)));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlExampleElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlExampleElement(List(content));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlExampleElement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax xmlElementSyntax = XmlElement("example", content);
|
||
|
|
return xmlElementSyntax.WithStartTag(xmlElementSyntax.StartTag);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlParaElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlParaElement(List(content));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlParaElement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlElement("para", content);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlParamElement(string parameterName, params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlParamElement(parameterName, List(content));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlParamElement(string parameterName, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax xmlElementSyntax = XmlElement("param", content);
|
||
|
|
return xmlElementSyntax.WithStartTag(xmlElementSyntax.StartTag.AddAttributes(XmlNameAttribute(parameterName)));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlParamRefElement(string parameterName)
|
||
|
|
{
|
||
|
|
return XmlEmptyElement("paramref").AddAttributes(XmlNameAttribute(parameterName));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlNullKeywordElement()
|
||
|
|
{
|
||
|
|
return XmlKeywordElement("null");
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlKeywordElement(string keyword)
|
||
|
|
{
|
||
|
|
return XmlEmptyElement("see").AddAttributes(XmlTextAttribute("langword", keyword));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlPlaceholderElement(params Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax[] content)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlPlaceholderElement(List(content));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlPlaceholderElement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlElement("placeholder", content);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlEmptyElement(string localName)
|
||
|
|
{
|
||
|
|
return XmlEmptyElement(XmlName(localName));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlElement(string localName, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlElement(XmlName(localName), content);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlElement(XmlElementStartTag(name), content, XmlElementEndTag(name));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax XmlTextAttribute(string name, string value)
|
||
|
|
{
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlTextAttribute(name, XmlTextLiteral(value));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax XmlTextAttribute(string name, params SyntaxToken[] textTokens)
|
||
|
|
{
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlTextAttribute(XmlName(name), SyntaxKind.DoubleQuoteToken, TokenList(textTokens));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax XmlTextAttribute(string name, SyntaxKind quoteKind, SyntaxTokenList textTokens)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlTextAttribute(XmlName(name), quoteKind, textTokens);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxKind quoteKind, SyntaxTokenList textTokens)
|
||
|
|
{
|
||
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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)
|
||
|
|
return SyntaxNodeExtensions.WithLeadingTrivia<Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax>(XmlTextAttribute(name, Token(quoteKind), textTokens, Token(quoteKind)), (SyntaxTrivia[])(object)new SyntaxTrivia[1] { Whitespace(" ") });
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlMultiLineElement(string localName, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlMultiLineElement(XmlName(localName), content);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlMultiLineElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlElement(XmlElementStartTag(name), content, XmlElementEndTag(name));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax XmlNewLine(string text)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlText(XmlTextNewLine(text));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken XmlTextNewLine(string text)
|
||
|
|
{
|
||
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlTextNewLine(text, continueXmlDocumentationComment: true);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken XmlTextNewLine(SyntaxTriviaList leading, string text, string value, SyntaxTriviaList trailing)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlTextNewLine(((SyntaxTriviaList)(ref leading)).Node, text, value, ((SyntaxTriviaList)(ref trailing)).Node));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken XmlTextNewLine(string text, bool continueXmlDocumentationComment)
|
||
|
|
{
|
||
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0034: 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_0041: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
SyntaxToken result = default(SyntaxToken);
|
||
|
|
((SyntaxToken)(ref result))._002Ector((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlTextNewLine(underlyingNode, text, text, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
if (continueXmlDocumentationComment)
|
||
|
|
{
|
||
|
|
SyntaxTriviaList trailingTrivia = ((SyntaxToken)(ref result)).TrailingTrivia;
|
||
|
|
result = ((SyntaxToken)(ref result)).WithTrailingTrivia(((SyntaxTriviaList)(ref trailingTrivia)).Add(DocumentationCommentExterior("/// ")));
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax XmlText(string value)
|
||
|
|
{
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlText(XmlTextLiteral(value));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax XmlText(params SyntaxToken[] textTokens)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlText(TokenList(textTokens));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken XmlTextLiteral(string value)
|
||
|
|
{
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
string text = new XText(value).ToString();
|
||
|
|
return XmlTextLiteral(TriviaList(), text, value, TriviaList());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken XmlTextLiteral(string text, string value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTrivia elasticMarker = ElasticMarker;
|
||
|
|
GreenNode underlyingNode = ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode;
|
||
|
|
elasticMarker = ElasticMarker;
|
||
|
|
return new SyntaxToken((GreenNode)(object)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlTextLiteral(underlyingNode, text, value, ((SyntaxTrivia)(ref elasticMarker)).UnderlyingNode));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxToken XmlReplaceBracketTokens(SyntaxToken originalToken, SyntaxToken rewrittenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003b: 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_0069: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (rewrittenToken.IsKind(SyntaxKind.LessThanToken) && string.Equals("<", ((SyntaxToken)(ref rewrittenToken)).Text, StringComparison.Ordinal))
|
||
|
|
{
|
||
|
|
return Token(((SyntaxToken)(ref rewrittenToken)).LeadingTrivia, SyntaxKind.LessThanToken, "{", ((SyntaxToken)(ref rewrittenToken)).ValueText, ((SyntaxToken)(ref rewrittenToken)).TrailingTrivia);
|
||
|
|
}
|
||
|
|
if (rewrittenToken.IsKind(SyntaxKind.GreaterThanToken) && string.Equals(">", ((SyntaxToken)(ref rewrittenToken)).Text, StringComparison.Ordinal))
|
||
|
|
{
|
||
|
|
return Token(((SyntaxToken)(ref rewrittenToken)).LeadingTrivia, SyntaxKind.GreaterThanToken, "}", ((SyntaxToken)(ref rewrittenToken)).ValueText, ((SyntaxToken)(ref rewrittenToken)).TrailingTrivia);
|
||
|
|
}
|
||
|
|
return rewrittenToken;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTrivia DocumentationCommentExterior(string text)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DocumentationCommentExteriorTrivia(text);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxList<TNode> List<TNode>() where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
//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(SyntaxList<TNode>);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxList<TNode> SingletonList<TNode>(TNode node) where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxList<TNode>(node);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxList<TNode> List<TNode>(IEnumerable<TNode> nodes) where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxList<TNode>(nodes);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTokenList TokenList()
|
||
|
|
{
|
||
|
|
//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(SyntaxTokenList);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTokenList TokenList(SyntaxToken token)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxTokenList(token);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTokenList TokenList(params SyntaxToken[] tokens)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxTokenList(tokens);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTokenList TokenList(IEnumerable<SyntaxToken> tokens)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxTokenList(tokens);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTrivia Trivia(Microsoft.CodeAnalysis.CSharp.Syntax.StructuredTriviaSyntax node)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxToken val = default(SyntaxToken);
|
||
|
|
return new SyntaxTrivia(ref val, ((SyntaxNode)node).Green, 0, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTriviaList TriviaList()
|
||
|
|
{
|
||
|
|
//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(SyntaxTriviaList);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTriviaList TriviaList(SyntaxTrivia trivia)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxTriviaList(trivia);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTriviaList TriviaList(params SyntaxTrivia[] trivias)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxTriviaList(trivias);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTriviaList TriviaList(IEnumerable<SyntaxTrivia> trivias)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxTriviaList(trivias);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SeparatedSyntaxList<TNode> SeparatedList<TNode>() where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
//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(SeparatedSyntaxList<TNode>);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SeparatedSyntaxList<TNode> SingletonSeparatedList<TNode>(TNode node) where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SeparatedSyntaxList<TNode>(new SyntaxNodeOrTokenList((SyntaxNode)(object)node, 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(IEnumerable<TNode>? nodes) where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0021: 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_003a: 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_0041: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0059: 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_0072: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0082: 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_0096: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (nodes == null)
|
||
|
|
{
|
||
|
|
return default(SeparatedSyntaxList<TNode>);
|
||
|
|
}
|
||
|
|
ICollection<TNode> collection = nodes as ICollection<TNode>;
|
||
|
|
if (collection != null && collection.Count == 0)
|
||
|
|
{
|
||
|
|
return default(SeparatedSyntaxList<TNode>);
|
||
|
|
}
|
||
|
|
using IEnumerator<TNode> enumerator = nodes.GetEnumerator();
|
||
|
|
if (!enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
return default(SeparatedSyntaxList<TNode>);
|
||
|
|
}
|
||
|
|
TNode current = enumerator.Current;
|
||
|
|
if (!enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
return SingletonSeparatedList(current);
|
||
|
|
}
|
||
|
|
SeparatedSyntaxListBuilder<TNode> val = default(SeparatedSyntaxListBuilder<TNode>);
|
||
|
|
val._002Ector(collection?.Count ?? 3);
|
||
|
|
val.Add(current);
|
||
|
|
SyntaxToken val2 = Token(SyntaxKind.CommaToken);
|
||
|
|
do
|
||
|
|
{
|
||
|
|
val.AddSeparator(ref val2);
|
||
|
|
val.Add(enumerator.Current);
|
||
|
|
}
|
||
|
|
while (enumerator.MoveNext());
|
||
|
|
return val.ToList();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(IEnumerable<TNode>? nodes, IEnumerable<SyntaxToken>? separators) where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
//IL_000d: 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)
|
||
|
|
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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)
|
||
|
|
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (nodes != null)
|
||
|
|
{
|
||
|
|
IEnumerator<TNode> enumerator = nodes.GetEnumerator();
|
||
|
|
SeparatedSyntaxListBuilder<TNode> val = SeparatedSyntaxListBuilder<TNode>.Create();
|
||
|
|
if (separators != null)
|
||
|
|
{
|
||
|
|
foreach (SyntaxToken separator in separators)
|
||
|
|
{
|
||
|
|
SyntaxToken current = separator;
|
||
|
|
if (!enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
throw new ArgumentException("nodes must not be empty.", "nodes");
|
||
|
|
}
|
||
|
|
val.Add(enumerator.Current);
|
||
|
|
val.AddSeparator(ref current);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
val.Add(enumerator.Current);
|
||
|
|
if (enumerator.MoveNext())
|
||
|
|
{
|
||
|
|
throw new ArgumentException("separators must have 1 fewer element than nodes", "separators");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return val.ToList();
|
||
|
|
}
|
||
|
|
if (separators != null)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("When nodes is null, separators must also be null.", "separators");
|
||
|
|
}
|
||
|
|
return default(SeparatedSyntaxList<TNode>);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(IEnumerable<SyntaxNodeOrToken> nodesAndTokens) where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
return SeparatedList<TNode>(NodeOrTokenList(nodesAndTokens));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SeparatedSyntaxList<TNode> SeparatedList<TNode>(SyntaxNodeOrTokenList nodesAndTokens) where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: 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_0027: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (!HasSeparatedNodeTokenPattern(nodesAndTokens))
|
||
|
|
{
|
||
|
|
throw new ArgumentException(CodeAnalysisResources.NodeOrTokenOutOfSequence);
|
||
|
|
}
|
||
|
|
if (!NodesAreCorrectType<TNode>(nodesAndTokens))
|
||
|
|
{
|
||
|
|
throw new ArgumentException(CodeAnalysisResources.UnexpectedTypeOfNodeInList);
|
||
|
|
}
|
||
|
|
return new SeparatedSyntaxList<TNode>(nodesAndTokens);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool NodesAreCorrectType<TNode>(SyntaxNodeOrTokenList list)
|
||
|
|
{
|
||
|
|
//IL_000f: 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)
|
||
|
|
int i = 0;
|
||
|
|
for (int count = ((SyntaxNodeOrTokenList)(ref list)).Count; i < count; i++)
|
||
|
|
{
|
||
|
|
SyntaxNodeOrToken val = ((SyntaxNodeOrTokenList)(ref list))[i];
|
||
|
|
if (((SyntaxNodeOrToken)(ref val)).IsNode && !(((SyntaxNodeOrToken)(ref val)).AsNode() is TNode))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool HasSeparatedNodeTokenPattern(SyntaxNodeOrTokenList list)
|
||
|
|
{
|
||
|
|
//IL_000f: 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)
|
||
|
|
int i = 0;
|
||
|
|
for (int count = ((SyntaxNodeOrTokenList)(ref list)).Count; i < count; i++)
|
||
|
|
{
|
||
|
|
SyntaxNodeOrToken val = ((SyntaxNodeOrTokenList)(ref list))[i];
|
||
|
|
if (((SyntaxNodeOrToken)(ref val)).IsToken == ((i & 1) == 0))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxNodeOrTokenList NodeOrTokenList()
|
||
|
|
{
|
||
|
|
//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(SyntaxNodeOrTokenList);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxNodeOrTokenList NodeOrTokenList(IEnumerable<SyntaxNodeOrToken> nodesAndTokens)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxNodeOrTokenList(nodesAndTokens);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxNodeOrTokenList NodeOrTokenList(params SyntaxNodeOrToken[] nodesAndTokens)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return new SyntaxNodeOrTokenList(nodesAndTokens);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax IdentifierName(string name)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IdentifierName(Identifier(name));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTree SyntaxTree(SyntaxNode root, ParseOptions? options = null, string path = "", Encoding? encoding = null)
|
||
|
|
{
|
||
|
|
return CSharpSyntaxTree.Create((CSharpSyntaxNode)(object)root, ((CSharpParseOptions)(object)options) ?? CSharpParseOptions.Default, path, encoding, (SourceHashAlgorithm)1);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTree ParseSyntaxTree(string text, ParseOptions? options = null, string path = "", Encoding? encoding = null, CancellationToken cancellationToken = default(CancellationToken))
|
||
|
|
{
|
||
|
|
return CSharpSyntaxTree.ParseText(SourceText.From(text, encoding, (SourceHashAlgorithm)1), (CSharpParseOptions)(object)options, path, null, null, cancellationToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTree ParseSyntaxTree(SourceText text, ParseOptions? options = null, string path = "", CancellationToken cancellationToken = default(CancellationToken))
|
||
|
|
{
|
||
|
|
return CSharpSyntaxTree.ParseText(text, (CSharpParseOptions)(object)options, path, cancellationToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTriviaList ParseLeadingTrivia(string text, int offset = 0)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ParseLeadingTrivia(text, CSharpParseOptions.Default, offset);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static SyntaxTriviaList ParseLeadingTrivia(string text, CSharpParseOptions options, int offset = 0)
|
||
|
|
{
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
using Lexer lexer = new Lexer(MakeSourceText(text, offset), options);
|
||
|
|
return lexer.LexSyntaxLeadingTrivia();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxTriviaList ParseTrailingTrivia(string text, int offset = 0)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: 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)
|
||
|
|
using Lexer lexer = new Lexer(MakeSourceText(text, offset), CSharpParseOptions.Default);
|
||
|
|
return lexer.LexSyntaxTrailingTrivia();
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax? ParseCref(string text)
|
||
|
|
{
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: 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_0049: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxTriviaList val = ParseLeadingTrivia($"/// <see cref=\"{text}\"/>", CSharpParseOptions.Default.WithDocumentationMode((DocumentationMode)2));
|
||
|
|
SyntaxTrivia val2 = ((SyntaxTriviaList)(ref val)).First();
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax xmlAttributeSyntax = ((Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax)((Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax)(object)((SyntaxTrivia)(ref val2)).GetStructure()).Content[1]).Attributes[0];
|
||
|
|
if (xmlAttributeSyntax.Kind() != SyntaxKind.XmlCrefAttribute)
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return ((Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax)xmlAttributeSyntax).Cref;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static SyntaxToken ParseToken(string text, int offset = 0)
|
||
|
|
{
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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)
|
||
|
|
using Lexer lexer = new Lexer(MakeSourceText(text, offset), CSharpParseOptions.Default);
|
||
|
|
return new SyntaxToken((GreenNode)(object)lexer.Lex(LexerMode.Syntax));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static IEnumerable<SyntaxToken> ParseTokens(string text, int offset = 0, int initialTokenPosition = 0, CSharpParseOptions? options = null)
|
||
|
|
{
|
||
|
|
using Lexer lexer = new Lexer(MakeSourceText(text, offset), options ?? CSharpParseOptions.Default);
|
||
|
|
int position = initialTokenPosition;
|
||
|
|
SyntaxToken token;
|
||
|
|
do
|
||
|
|
{
|
||
|
|
token = lexer.Lex(LexerMode.Syntax);
|
||
|
|
yield return new SyntaxToken((SyntaxNode)null, (GreenNode)(object)token, position, 0);
|
||
|
|
position += ((GreenNode)token).FullWidth;
|
||
|
|
}
|
||
|
|
while (token.Kind != SyntaxKind.EndOfFileToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax ParseName(string text, int offset = 0, bool consumeFullText = true)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameSyntax nameSyntax = languageParser.ParseName();
|
||
|
|
if (consumeFullText)
|
||
|
|
{
|
||
|
|
nameSyntax = languageParser.ConsumeUnexpectedTokens(nameSyntax);
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax)(object)((GreenNode)nameSyntax).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax ParseTypeName(string text, int offset, bool consumeFullText)
|
||
|
|
{
|
||
|
|
return ParseTypeName(text, offset, null, consumeFullText);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax ParseTypeName(string text, int offset = 0, ParseOptions? options = null, bool consumeFullText = true)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset, (CSharpParseOptions)(object)options);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax typeSyntax = languageParser.ParseTypeName();
|
||
|
|
if (consumeFullText)
|
||
|
|
{
|
||
|
|
typeSyntax = languageParser.ConsumeUnexpectedTokens(typeSyntax);
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax)(object)((GreenNode)typeSyntax).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax ParseExpression(string text, int offset = 0, ParseOptions? options = null, bool consumeFullText = true)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset, (CSharpParseOptions)(object)options);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax expressionSyntax = languageParser.ParseExpression();
|
||
|
|
if (consumeFullText)
|
||
|
|
{
|
||
|
|
expressionSyntax = languageParser.ConsumeUnexpectedTokens(expressionSyntax);
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)(object)((GreenNode)expressionSyntax).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax ParseStatement(string text, int offset = 0, ParseOptions? options = null, bool consumeFullText = true)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset, (CSharpParseOptions)(object)options);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax statementSyntax = languageParser.ParseStatement();
|
||
|
|
if (consumeFullText)
|
||
|
|
{
|
||
|
|
statementSyntax = languageParser.ConsumeUnexpectedTokens(statementSyntax);
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax)(object)((GreenNode)statementSyntax).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax? ParseMemberDeclaration(string text, int offset = 0, ParseOptions? options = null, bool consumeFullText = true)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset, (CSharpParseOptions)(object)options);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.MemberDeclarationSyntax memberDeclarationSyntax = languageParser.ParseMemberDeclaration();
|
||
|
|
if (memberDeclarationSyntax == null)
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax)(object)((GreenNode)(consumeFullText ? languageParser.ConsumeUnexpectedTokens(memberDeclarationSyntax) : memberDeclarationSyntax)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax ParseCompilationUnit(string text, int offset = 0, CSharpParseOptions? options = null)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset, options);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax)(object)((GreenNode)languageParser.ParseCompilationUnit()).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax ParseParameterList(string text, int offset = 0, ParseOptions? options = null, bool consumeFullText = true)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset, (CSharpParseOptions)(object)options);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax parameterListSyntax = languageParser.ParseParenthesizedParameterList();
|
||
|
|
if (consumeFullText)
|
||
|
|
{
|
||
|
|
parameterListSyntax = languageParser.ConsumeUnexpectedTokens(parameterListSyntax);
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax)(object)((GreenNode)parameterListSyntax).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax ParseBracketedParameterList(string text, int offset = 0, ParseOptions? options = null, bool consumeFullText = true)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset, (CSharpParseOptions)(object)options);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BracketedParameterListSyntax bracketedParameterListSyntax = languageParser.ParseBracketedParameterList();
|
||
|
|
if (consumeFullText)
|
||
|
|
{
|
||
|
|
bracketedParameterListSyntax = languageParser.ConsumeUnexpectedTokens(bracketedParameterListSyntax);
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax)(object)((GreenNode)bracketedParameterListSyntax).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax ParseArgumentList(string text, int offset = 0, ParseOptions? options = null, bool consumeFullText = true)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset, (CSharpParseOptions)(object)options);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArgumentListSyntax argumentListSyntax = languageParser.ParseParenthesizedArgumentList();
|
||
|
|
if (consumeFullText)
|
||
|
|
{
|
||
|
|
argumentListSyntax = languageParser.ConsumeUnexpectedTokens(argumentListSyntax);
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax)(object)((GreenNode)argumentListSyntax).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax ParseBracketedArgumentList(string text, int offset = 0, ParseOptions? options = null, bool consumeFullText = true)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset, (CSharpParseOptions)(object)options);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BracketedArgumentListSyntax bracketedArgumentListSyntax = languageParser.ParseBracketedArgumentList();
|
||
|
|
if (consumeFullText)
|
||
|
|
{
|
||
|
|
bracketedArgumentListSyntax = languageParser.ConsumeUnexpectedTokens(bracketedArgumentListSyntax);
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax)(object)((GreenNode)bracketedArgumentListSyntax).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax? ParseAttributeArgumentList(string text, int offset = 0, ParseOptions? options = null, bool consumeFullText = true)
|
||
|
|
{
|
||
|
|
using Lexer lexer = MakeLexer(text, offset, (CSharpParseOptions)(object)options);
|
||
|
|
using LanguageParser languageParser = MakeParser(lexer);
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeArgumentListSyntax attributeArgumentListSyntax = languageParser.ParseAttributeArgumentList() ?? new Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeArgumentListSyntax(SyntaxKind.AttributeArgumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.MissingToken(SyntaxKind.OpenParenToken), null, Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.MissingToken(SyntaxKind.CloseParenToken), null, null);
|
||
|
|
if (consumeFullText)
|
||
|
|
{
|
||
|
|
attributeArgumentListSyntax = languageParser.ConsumeUnexpectedTokens(attributeArgumentListSyntax);
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax)(object)((GreenNode)attributeArgumentListSyntax).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SourceText MakeSourceText(string text, int offset)
|
||
|
|
{
|
||
|
|
return SourceText.From(text, Encoding.UTF8, (SourceHashAlgorithm)1).GetSubText(offset);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Lexer MakeLexer(string text, int offset, CSharpParseOptions? options = null)
|
||
|
|
{
|
||
|
|
return new Lexer(MakeSourceText(text, offset), options ?? CSharpParseOptions.Default);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static LanguageParser MakeParser(Lexer lexer)
|
||
|
|
{
|
||
|
|
return new LanguageParser(lexer, null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool AreEquivalent(SyntaxTree? oldTree, SyntaxTree? newTree, bool topLevel)
|
||
|
|
{
|
||
|
|
if (oldTree == null && newTree == null)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (oldTree == null || newTree == null)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return SyntaxEquivalence.AreEquivalent(oldTree, newTree, null, topLevel);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool AreEquivalent(SyntaxNode? oldNode, SyntaxNode? newNode, bool topLevel)
|
||
|
|
{
|
||
|
|
return SyntaxEquivalence.AreEquivalent(oldNode, newNode, null, topLevel);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool AreEquivalent(SyntaxNode? oldNode, SyntaxNode? newNode, Func<SyntaxKind, bool>? ignoreChildNode = null)
|
||
|
|
{
|
||
|
|
return SyntaxEquivalence.AreEquivalent(oldNode, newNode, ignoreChildNode, topLevel: false);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool AreEquivalent(SyntaxToken oldToken, SyntaxToken newToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SyntaxEquivalence.AreEquivalent(oldToken, newToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool AreEquivalent(SyntaxTokenList oldList, SyntaxTokenList newList)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SyntaxEquivalence.AreEquivalent(oldList, newList);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool AreEquivalent<TNode>(SyntaxList<TNode> oldList, SyntaxList<TNode> newList, bool topLevel) where TNode : CSharpSyntaxNode
|
||
|
|
{
|
||
|
|
return SyntaxEquivalence.AreEquivalent(oldList.Node, newList.Node, null, topLevel);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool AreEquivalent<TNode>(SyntaxList<TNode> oldList, SyntaxList<TNode> newList, Func<SyntaxKind, bool>? ignoreChildNode = null) where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
return SyntaxEquivalence.AreEquivalent(oldList.Node, newList.Node, ignoreChildNode, topLevel: false);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool AreEquivalent<TNode>(SeparatedSyntaxList<TNode> oldList, SeparatedSyntaxList<TNode> newList, bool topLevel) where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
return SyntaxEquivalence.AreEquivalent(oldList.Node, newList.Node, null, topLevel);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool AreEquivalent<TNode>(SeparatedSyntaxList<TNode> oldList, SeparatedSyntaxList<TNode> newList, Func<SyntaxKind, bool>? ignoreChildNode = null) where TNode : SyntaxNode
|
||
|
|
{
|
||
|
|
return SyntaxEquivalence.AreEquivalent(oldList.Node, newList.Node, ignoreChildNode, topLevel: false);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? GetStandaloneType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? node)
|
||
|
|
{
|
||
|
|
if (node != null && node.Parent is Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expressionSyntax && (node.Kind() == SyntaxKind.IdentifierName || node.Kind() == SyntaxKind.GenericName))
|
||
|
|
{
|
||
|
|
switch (expressionSyntax.Kind())
|
||
|
|
{
|
||
|
|
case SyntaxKind.QualifiedName:
|
||
|
|
{
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax qualifiedNameSyntax = (Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax)expressionSyntax;
|
||
|
|
if (qualifiedNameSyntax.Right == node)
|
||
|
|
{
|
||
|
|
return qualifiedNameSyntax;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case SyntaxKind.AliasQualifiedName:
|
||
|
|
{
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax aliasQualifiedNameSyntax = (Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax)expressionSyntax;
|
||
|
|
if (aliasQualifiedNameSyntax.Name == node)
|
||
|
|
{
|
||
|
|
return aliasQualifiedNameSyntax;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax GetStandaloneExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
return (GetStandaloneNode(expression) as Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) ?? expression;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static CSharpSyntaxNode? GetStandaloneNode(CSharpSyntaxNode? node)
|
||
|
|
{
|
||
|
|
if (node == null || (!(node is Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax) && !(node is Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax)))
|
||
|
|
{
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
switch (node.Kind())
|
||
|
|
{
|
||
|
|
default:
|
||
|
|
return node;
|
||
|
|
case SyntaxKind.NameMemberCref:
|
||
|
|
case SyntaxKind.IndexerMemberCref:
|
||
|
|
case SyntaxKind.OperatorMemberCref:
|
||
|
|
case SyntaxKind.ConversionOperatorMemberCref:
|
||
|
|
case SyntaxKind.IdentifierName:
|
||
|
|
case SyntaxKind.GenericName:
|
||
|
|
case SyntaxKind.ArrayType:
|
||
|
|
case SyntaxKind.NullableType:
|
||
|
|
{
|
||
|
|
CSharpSyntaxNode parent = node.Parent;
|
||
|
|
if (parent == null)
|
||
|
|
{
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
switch (parent.Kind())
|
||
|
|
{
|
||
|
|
case SyntaxKind.QualifiedName:
|
||
|
|
if (((Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax)parent).Right == node)
|
||
|
|
{
|
||
|
|
return parent;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SyntaxKind.AliasQualifiedName:
|
||
|
|
if (((Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax)parent).Name == node)
|
||
|
|
{
|
||
|
|
return parent;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SyntaxKind.SimpleMemberAccessExpression:
|
||
|
|
case SyntaxKind.PointerMemberAccessExpression:
|
||
|
|
if (((Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax)parent).Name == node)
|
||
|
|
{
|
||
|
|
return parent;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SyntaxKind.MemberBindingExpression:
|
||
|
|
if (((Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax)parent).Name == node)
|
||
|
|
{
|
||
|
|
return parent;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SyntaxKind.NameMemberCref:
|
||
|
|
if (((Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax)parent).Name == node)
|
||
|
|
{
|
||
|
|
CSharpSyntaxNode parent2 = parent.Parent;
|
||
|
|
if (parent2 == null || parent2.Kind() != SyntaxKind.QualifiedCref)
|
||
|
|
{
|
||
|
|
return parent;
|
||
|
|
}
|
||
|
|
return parent2;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SyntaxKind.QualifiedCref:
|
||
|
|
if (((Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax)parent).Member == node)
|
||
|
|
{
|
||
|
|
return parent;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SyntaxKind.ArrayCreationExpression:
|
||
|
|
if (((Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax)parent).Type == node)
|
||
|
|
{
|
||
|
|
return parent;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SyntaxKind.ObjectCreationExpression:
|
||
|
|
if (node.Kind() == SyntaxKind.NullableType && ((Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax)parent).Type == node)
|
||
|
|
{
|
||
|
|
return parent;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SyntaxKind.StackAllocArrayCreationExpression:
|
||
|
|
if (((Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax)parent).Type == node)
|
||
|
|
{
|
||
|
|
return parent;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case SyntaxKind.NameColon:
|
||
|
|
if (((SyntaxNode?)(object)parent.Parent).IsKind(SyntaxKind.Subpattern))
|
||
|
|
{
|
||
|
|
return parent.Parent;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax? FindConditionalAccessNodeForBinding(CSharpSyntaxNode node)
|
||
|
|
{
|
||
|
|
//IL_0020: 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)
|
||
|
|
CSharpSyntaxNode cSharpSyntaxNode = node;
|
||
|
|
while (cSharpSyntaxNode != null)
|
||
|
|
{
|
||
|
|
cSharpSyntaxNode = cSharpSyntaxNode.Parent;
|
||
|
|
if (cSharpSyntaxNode.Kind() == SyntaxKind.ConditionalAccessExpression)
|
||
|
|
{
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax conditionalAccessExpressionSyntax = (Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax)cSharpSyntaxNode;
|
||
|
|
SyntaxToken operatorToken = conditionalAccessExpressionSyntax.OperatorToken;
|
||
|
|
if (((SyntaxToken)(ref operatorToken)).EndPosition == ((SyntaxNode)node).Position)
|
||
|
|
{
|
||
|
|
return conditionalAccessExpressionSyntax;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? GetNonGenericExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (expression != null)
|
||
|
|
{
|
||
|
|
switch (expression.Kind())
|
||
|
|
{
|
||
|
|
case SyntaxKind.SimpleMemberAccessExpression:
|
||
|
|
case SyntaxKind.PointerMemberAccessExpression:
|
||
|
|
{
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax memberAccessExpressionSyntax = (Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax)expression;
|
||
|
|
if (memberAccessExpressionSyntax.Name.Kind() == SyntaxKind.GenericName)
|
||
|
|
{
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax genericNameSyntax2 = (Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax)memberAccessExpressionSyntax.Name;
|
||
|
|
return BinaryExpression(expression.Kind(), memberAccessExpressionSyntax.Expression, memberAccessExpressionSyntax.OperatorToken, IdentifierName(genericNameSyntax2.Identifier));
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case SyntaxKind.QualifiedName:
|
||
|
|
{
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax qualifiedNameSyntax = (Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax)expression;
|
||
|
|
if (qualifiedNameSyntax.Right.Kind() == SyntaxKind.GenericName)
|
||
|
|
{
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax genericNameSyntax3 = (Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax)qualifiedNameSyntax.Right;
|
||
|
|
return QualifiedName(qualifiedNameSyntax.Left, qualifiedNameSyntax.DotToken, IdentifierName(genericNameSyntax3.Identifier));
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case SyntaxKind.AliasQualifiedName:
|
||
|
|
{
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax aliasQualifiedNameSyntax = (Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax)expression;
|
||
|
|
if (aliasQualifiedNameSyntax.Name.Kind() == SyntaxKind.GenericName)
|
||
|
|
{
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax genericNameSyntax = (Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax)aliasQualifiedNameSyntax.Name;
|
||
|
|
return AliasQualifiedName(aliasQualifiedNameSyntax.Alias, aliasQualifiedNameSyntax.ColonColonToken, IdentifierName(genericNameSyntax.Identifier));
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return expression;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static bool IsCompleteSubmission(SyntaxTree tree)
|
||
|
|
{
|
||
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Invalid comparison between Unknown and I4
|
||
|
|
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0057: 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_0120: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0169: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_016e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (tree == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("tree");
|
||
|
|
}
|
||
|
|
if ((int)tree.Options.Kind != 1)
|
||
|
|
{
|
||
|
|
throw new ArgumentException(CSharpResources.SyntaxTreeIsNotASubmission);
|
||
|
|
}
|
||
|
|
if (!tree.HasCompilationUnitRoot)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax compilationUnitSyntax = (Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax)(object)tree.GetRoot(default(CancellationToken));
|
||
|
|
if (!((SyntaxNode)compilationUnitSyntax).HasErrors)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
SyntaxToken endOfFileToken = compilationUnitSyntax.EndOfFileToken;
|
||
|
|
foreach (Diagnostic diagnostic in ((SyntaxToken)(ref endOfFileToken)).GetDiagnostics())
|
||
|
|
{
|
||
|
|
ErrorCode code = (ErrorCode)diagnostic.Code;
|
||
|
|
if (code == ErrorCode.ERR_EndifDirectiveExpected || code == ErrorCode.ERR_OpenEndedComment || code == ErrorCode.ERR_EndRegionDirectiveExpected)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
SyntaxNode val = ((SyntaxNode)compilationUnitSyntax).ChildNodes().LastOrDefault();
|
||
|
|
if (val == null)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (val.HasTrailingTrivia && val.ContainsDiagnostics && HasUnterminatedMultiLineComment(val.GetTrailingTrivia()))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (val.IsKind(SyntaxKind.IncompleteMember))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (!val.IsKind(SyntaxKind.GlobalStatement))
|
||
|
|
{
|
||
|
|
SyntaxToken lastToken = val.GetLastToken(true, true, true, true);
|
||
|
|
return !((SyntaxToken)(ref lastToken)).IsMissing;
|
||
|
|
}
|
||
|
|
Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax globalStatementSyntax = (Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax)(object)val;
|
||
|
|
SyntaxToken token = val.GetLastToken(true, true, true, true);
|
||
|
|
if (((SyntaxToken)(ref token)).IsMissing)
|
||
|
|
{
|
||
|
|
if ((int)tree.Options.Kind == 0 || !((SyntaxNode?)(object)globalStatementSyntax.Statement).IsKind(SyntaxKind.ExpressionStatement) || !token.IsKind(SyntaxKind.SemicolonToken))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
token = ((SyntaxToken)(ref token)).GetPreviousToken(SyntaxToken.Any, SyntaxTrivia.Any);
|
||
|
|
if (((SyntaxToken)(ref token)).IsMissing)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
foreach (Diagnostic diagnostic2 in ((SyntaxToken)(ref token)).GetDiagnostics())
|
||
|
|
{
|
||
|
|
switch ((ErrorCode)diagnostic2.Code)
|
||
|
|
{
|
||
|
|
case ErrorCode.ERR_NewlineInConst:
|
||
|
|
case ErrorCode.ERR_EOFExpected:
|
||
|
|
case ErrorCode.ERR_UnterminatedStringLit:
|
||
|
|
case ErrorCode.ERR_GlobalDefinitionOrStatementExpected:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static bool HasUnterminatedMultiLineComment(SyntaxTriviaList triviaList)
|
||
|
|
{
|
||
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
Enumerator enumerator = ((SyntaxTriviaList)(ref triviaList)).GetEnumerator();
|
||
|
|
while (((Enumerator)(ref enumerator)).MoveNext())
|
||
|
|
{
|
||
|
|
SyntaxTrivia current = ((Enumerator)(ref enumerator)).Current;
|
||
|
|
if (((SyntaxTrivia)(ref current)).ContainsDiagnostics && current.Kind() == SyntaxKind.MultiLineCommentTrivia)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CaseSwitchLabel(Token(SyntaxKind.CaseKeyword), value, Token(SyntaxKind.ColonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax DefaultSwitchLabel()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DefaultSwitchLabel(Token(SyntaxKind.DefaultKeyword), Token(SyntaxKind.ColonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax Block(params Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax[] statements)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Block(List(statements));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax Block(IEnumerable<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Block(List(statements));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax PropertyDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return PropertyDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, identifier, accessorList, null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0003: 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)
|
||
|
|
return ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, operatorKeyword, type, parameterList, body, null, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, null, operatorKeyword, type, parameterList, body, expressionBody, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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)
|
||
|
|
return ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, null, type, parameterList, body, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0004: 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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, explicitInterfaceSpecifier, operatorKeyword, default(SyntaxToken), type, parameterList, body, expressionBody, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken operatorKeyword, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0004: 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)
|
||
|
|
return OperatorDeclaration(attributeLists, modifiers, returnType, operatorKeyword, operatorToken, parameterList, body, null, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken operatorKeyword, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return OperatorDeclaration(attributeLists, modifiers, returnType, null, operatorKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return OperatorDeclaration(attributeLists, modifiers, returnType, null, operatorToken, parameterList, body, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0004: 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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return OperatorDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, operatorKeyword, default(SyntaxToken), operatorToken, parameterList, body, expressionBody, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UsingDirective(Token(SyntaxKind.UsingKeyword), default(SyntaxToken), alias, name, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax UsingDirective(SyntaxToken usingKeyword, SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UsingDirective(default(SyntaxToken), usingKeyword, staticKeyword, default(SyntaxToken), alias, name, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax ClassOrStructConstraint(SyntaxKind kind, SyntaxToken classOrStructKeyword)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ClassOrStructConstraint(kind, classOrStructKeyword, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
return AccessorDeclaration(kind, attributeLists, modifiers, body, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax body, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AccessorDeclaration(kind, attributeLists, modifiers, keyword, body, null, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
return AccessorDeclaration(kind, attributeLists, modifiers, null, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AccessorDeclaration(kind, attributeLists, modifiers, keyword, null, expressionBody, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax EnumMemberDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? equalsValue)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EnumMemberDeclaration(attributeLists, default(SyntaxTokenList), identifier, equalsValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return NamespaceDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), name, externs, usings, members);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax NamespaceDeclaration(SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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)
|
||
|
|
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return NamespaceDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), namespaceKeyword, name, openBraceToken, externs, usings, members, closeBraceToken, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax EventDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax accessorList)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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 EventDeclaration(attributeLists, modifiers, eventKeyword, type, explicitInterfaceSpecifier, identifier, accessorList, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax EventDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken identifier, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EventDeclaration(attributeLists, modifiers, eventKeyword, type, explicitInterfaceSpecifier, identifier, null, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax> sections)
|
||
|
|
{
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0024: 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_0029: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002f: 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_003f: 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: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
bool num = !(expression is Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax);
|
||
|
|
SyntaxToken openParenToken = (SyntaxToken)(num ? Token(SyntaxKind.OpenParenToken) : default(SyntaxToken));
|
||
|
|
SyntaxToken closeParenToken = (SyntaxToken)(num ? Token(SyntaxKind.CloseParenToken) : default(SyntaxToken));
|
||
|
|
return SwitchStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.SwitchKeyword), openParenToken, expression, closeParenToken, Token(SyntaxKind.OpenBraceToken), sections, Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax SwitchStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SwitchStatement(expression, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax>));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, CSharpSyntaxNode body)
|
||
|
|
{
|
||
|
|
if (!(body is Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block))
|
||
|
|
{
|
||
|
|
return SimpleLambdaExpression(parameter, null, (Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)body);
|
||
|
|
}
|
||
|
|
return SimpleLambdaExpression(parameter, block, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax SimpleLambdaExpression(SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, SyntaxToken arrowToken, CSharpSyntaxNode body)
|
||
|
|
{
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (!(body is Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block))
|
||
|
|
{
|
||
|
|
return SimpleLambdaExpression(asyncKeyword, parameter, arrowToken, null, (Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)body);
|
||
|
|
}
|
||
|
|
return SimpleLambdaExpression(asyncKeyword, parameter, arrowToken, block, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(CSharpSyntaxNode body)
|
||
|
|
{
|
||
|
|
//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 ParenthesizedLambdaExpression(ParameterList(), body);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, CSharpSyntaxNode body)
|
||
|
|
{
|
||
|
|
if (!(body is Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block))
|
||
|
|
{
|
||
|
|
return ParenthesizedLambdaExpression(parameterList, null, (Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)body);
|
||
|
|
}
|
||
|
|
return ParenthesizedLambdaExpression(parameterList, block, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxToken asyncKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxToken arrowToken, CSharpSyntaxNode body)
|
||
|
|
{
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (!(body is Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block))
|
||
|
|
{
|
||
|
|
return ParenthesizedLambdaExpression(asyncKeyword, parameterList, arrowToken, null, (Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax)body);
|
||
|
|
}
|
||
|
|
return ParenthesizedLambdaExpression(asyncKeyword, parameterList, arrowToken, block, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax AnonymousMethodExpression(CSharpSyntaxNode body)
|
||
|
|
{
|
||
|
|
return AnonymousMethodExpression(null, body);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax AnonymousMethodExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, CSharpSyntaxNode body)
|
||
|
|
{
|
||
|
|
//IL_0017: 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_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (!(body is Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block))
|
||
|
|
{
|
||
|
|
throw new ArgumentException("body");
|
||
|
|
}
|
||
|
|
return SyntaxFactory.AnonymousMethodExpression(default(SyntaxTokenList), Token(SyntaxKind.DelegateKeyword), parameterList, block, (Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax?)null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax AnonymousMethodExpression(SyntaxToken asyncKeyword, SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, CSharpSyntaxNode body)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (!(body is Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block))
|
||
|
|
{
|
||
|
|
throw new ArgumentException("body");
|
||
|
|
}
|
||
|
|
return AnonymousMethodExpression(asyncKeyword, delegateKeyword, parameterList, block, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
[Obsolete("The diagnosticOptions parameter is obsolete due to performance problems, if you are passing non-null use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
||
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
||
|
|
public static SyntaxTree ParseSyntaxTree(string text, ParseOptions? options, string path, Encoding? encoding, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, CancellationToken cancellationToken)
|
||
|
|
{
|
||
|
|
return ParseSyntaxTree(SourceText.From(text, encoding, (SourceHashAlgorithm)1), options, path, diagnosticOptions, null, cancellationToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
[Obsolete("The diagnosticOptions parameter is obsolete due to performance problems, if you are passing non-null use CompilationOptions.SyntaxTreeOptionsProvider instead", false)]
|
||
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
||
|
|
public static SyntaxTree ParseSyntaxTree(SourceText text, ParseOptions? options, string path, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, CancellationToken cancellationToken)
|
||
|
|
{
|
||
|
|
return CSharpSyntaxTree.ParseText(text, (CSharpParseOptions)(object)options, path, diagnosticOptions, 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 ParseSyntaxTree(string text, ParseOptions? options, string path, Encoding? encoding, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, bool? isGeneratedCode, CancellationToken cancellationToken)
|
||
|
|
{
|
||
|
|
return ParseSyntaxTree(SourceText.From(text, encoding, (SourceHashAlgorithm)1), options, path, diagnosticOptions, isGeneratedCode, 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 ParseSyntaxTree(SourceText text, ParseOptions? options, string path, ImmutableDictionary<string, ReportDiagnostic>? diagnosticOptions, bool? isGeneratedCode, CancellationToken cancellationToken)
|
||
|
|
{
|
||
|
|
return CSharpSyntaxTree.ParseText(text, (CSharpParseOptions)(object)options, path, diagnosticOptions, isGeneratedCode, cancellationToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax OperatorMemberCref(SyntaxToken operatorKeyword, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0005: 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)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return OperatorMemberCref(operatorKeyword, default(SyntaxToken), operatorToken, parameters);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax ConversionOperatorMemberCref(SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConversionOperatorMemberCref(implicitOrExplicitKeyword, operatorKeyword, default(SyntaxToken), type, parameters);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax ClassDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: 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)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ClassDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax ClassDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ClassDeclaration(attributeLists, modifiers, identifier, typeParameterList, null, baseList, constraintClauses, members);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax ClassDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: 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)
|
||
|
|
//IL_002c: 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)
|
||
|
|
return ClassDeclaration(attributeLists, modifiers, Token(SyntaxKind.ClassKeyword), identifier, typeParameterList, parameterList, baseList, constraintClauses, Token(SyntaxKind.OpenBraceToken), members, Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax ClassDeclaration(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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_0028: 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_0035: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0048: 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)
|
||
|
|
return ClassDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.ClassKeyword), identifier, null, null, null, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), Token(SyntaxKind.OpenBraceToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax ClassDeclaration(string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0027: 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_0033: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003a: 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_0046: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004d: 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)
|
||
|
|
return ClassDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.ClassKeyword), Identifier(identifier), null, null, null, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), Token(SyntaxKind.OpenBraceToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax StructDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: 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)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return StructDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax StructDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return StructDeclaration(attributeLists, modifiers, identifier, typeParameterList, null, baseList, constraintClauses, members);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax StructDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: 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)
|
||
|
|
//IL_002c: 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)
|
||
|
|
return StructDeclaration(attributeLists, modifiers, Token(SyntaxKind.StructKeyword), identifier, typeParameterList, parameterList, baseList, constraintClauses, Token(SyntaxKind.OpenBraceToken), members, Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax StructDeclaration(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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_0028: 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_0035: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0048: 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)
|
||
|
|
return StructDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.StructKeyword), identifier, null, null, null, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), Token(SyntaxKind.OpenBraceToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax StructDeclaration(string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0027: 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_0033: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003a: 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_0046: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004d: 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)
|
||
|
|
return StructDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.StructKeyword), Identifier(identifier), null, null, null, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), Token(SyntaxKind.OpenBraceToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax InterfaceDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: 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)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return InterfaceDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax InterfaceDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002a: 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)
|
||
|
|
return InterfaceDeclaration(attributeLists, modifiers, Token(SyntaxKind.InterfaceKeyword), identifier, typeParameterList, baseList, constraintClauses, Token(SyntaxKind.OpenBraceToken), members, Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax InterfaceDeclaration(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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_0027: 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_0034: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003a: 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_0047: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return InterfaceDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.InterfaceKeyword), identifier, null, null, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), Token(SyntaxKind.OpenBraceToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax InterfaceDeclaration(string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0026: 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_0032: 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_003f: 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_004c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return InterfaceDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.InterfaceKeyword), Identifier(identifier), null, null, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), Token(SyntaxKind.OpenBraceToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax EnumDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: 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_002c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EnumDeclaration(attributeLists, modifiers, Token(SyntaxKind.EnumKeyword), identifier, baseList, Token(SyntaxKind.OpenBraceToken), members, Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax EnumDeclaration(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002a: 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_0036: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EnumDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.EnumKeyword), identifier, null, Token(SyntaxKind.OpenBraceToken), default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax>), Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax EnumDeclaration(string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0028: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002f: 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_003b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EnumDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.EnumKeyword), Identifier(identifier), null, Token(SyntaxKind.OpenBraceToken), default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax>), Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax ThrowStatement(SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: 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)
|
||
|
|
return ThrowStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), throwKeyword, expression, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax TryStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax? @finally)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TryStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), block, catches, @finally);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax TryStatement(SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax? @finally)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: 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)
|
||
|
|
return TryStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), tryKeyword, block, catches, @finally);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static SyntaxKind GetTypeDeclarationKeywordKind(DeclarationKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
DeclarationKind.Class => SyntaxKind.ClassKeyword,
|
||
|
|
DeclarationKind.Struct => SyntaxKind.StructKeyword,
|
||
|
|
DeclarationKind.Interface => SyntaxKind.InterfaceKeyword,
|
||
|
|
_ => throw ExceptionUtilities.UnexpectedValue((object)kind),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetTypeDeclarationKeywordKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
switch (kind)
|
||
|
|
{
|
||
|
|
case SyntaxKind.ClassDeclaration:
|
||
|
|
return SyntaxKind.ClassKeyword;
|
||
|
|
case SyntaxKind.StructDeclaration:
|
||
|
|
return SyntaxKind.StructKeyword;
|
||
|
|
case SyntaxKind.InterfaceDeclaration:
|
||
|
|
return SyntaxKind.InterfaceKeyword;
|
||
|
|
case SyntaxKind.RecordDeclaration:
|
||
|
|
case SyntaxKind.RecordStructDeclaration:
|
||
|
|
return SyntaxKind.RecordKeyword;
|
||
|
|
default:
|
||
|
|
throw ExceptionUtilities.UnexpectedValue((object)kind);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax TypeDeclaration(SyntaxKind kind, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: 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_0042: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TypeDeclaration(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(GetTypeDeclarationKeywordKind(kind)), identifier, null, null, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), Token(SyntaxKind.OpenBraceToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax TypeDeclaration(SyntaxKind kind, string identifier)
|
||
|
|
{
|
||
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TypeDeclaration(kind, Identifier(identifier));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeDeclarationSyntax TypeDeclaration(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributes, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_002d: 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_002f: 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_0036: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003a: 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_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0051: 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_0055: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0060: 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_0062: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0082: 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_0089: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.ClassDeclaration => ClassDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken),
|
||
|
|
SyntaxKind.StructDeclaration => StructDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken),
|
||
|
|
SyntaxKind.InterfaceDeclaration => InterfaceDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken),
|
||
|
|
SyntaxKind.RecordDeclaration => RecordDeclaration(SyntaxKind.RecordDeclaration, attributes, modifiers, keyword, default(SyntaxToken), identifier, typeParameterList, null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken),
|
||
|
|
SyntaxKind.RecordStructDeclaration => RecordDeclaration(SyntaxKind.RecordStructDeclaration, attributes, modifiers, keyword, Token(SyntaxKind.StructKeyword), identifier, typeParameterList, null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken),
|
||
|
|
_ => throw ExceptionUtilities.UnexpectedValue((object)kind),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax UnsafeStatement(SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UnsafeStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), unsafeKeyword, block);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax UsingDirective(SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UsingDirective(default(SyntaxToken), Token(SyntaxKind.UsingKeyword), staticKeyword, default(SyntaxToken), alias, name, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax UsingDirective(SyntaxToken globalKeyword, SyntaxToken usingKeyword, SyntaxToken staticKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0005: 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)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UsingDirective(globalKeyword, usingKeyword, staticKeyword, default(SyntaxToken), alias, name, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name)
|
||
|
|
{
|
||
|
|
return UsingDirective((Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax)name);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax UsingStatement(SyntaxToken usingKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UsingStatement(default(SyntaxToken), usingKeyword, openParenToken, declaration, expression, closeParenToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax UsingStatement(SyntaxToken awaitKeyword, SyntaxToken usingKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: 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)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UsingStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), awaitKeyword, usingKeyword, openParenToken, declaration, expression, closeParenToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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 UsingStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), declaration, expression, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax WhileStatement(SyntaxToken whileKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return WhileStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), whileKeyword, openParenToken, condition, closeParenToken, statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax YieldStatement(SyntaxKind kind, SyntaxToken yieldKeyword, SyntaxToken returnOrBreakKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: 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)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return YieldStatement(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), yieldKeyword, returnOrBreakKeyword, expression, semicolonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax IdentifierName(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = identifier.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.GlobalKeyword && syntaxKind != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.IdentifierName((SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax left, SyntaxToken dotToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax right)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (left == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("left");
|
||
|
|
}
|
||
|
|
if (dotToken.Kind() != SyntaxKind.DotToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("dotToken");
|
||
|
|
}
|
||
|
|
if (right == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("right");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.QualifiedName((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameSyntax)(object)((SyntaxNode)left).Green, (SyntaxToken)(object)((SyntaxToken)(ref dotToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SimpleNameSyntax)(object)((SyntaxNode)right).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedNameSyntax QualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax left, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax right)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return QualifiedName(left, Token(SyntaxKind.DotToken), right);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax GenericName(SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax typeArgumentList)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (typeArgumentList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("typeArgumentList");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.GenericName((SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeArgumentListSyntax)(object)((SyntaxNode)typeArgumentList).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax GenericName(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return GenericName(identifier, TypeArgumentList());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GenericNameSyntax GenericName(string identifier)
|
||
|
|
{
|
||
|
|
//IL_0001: 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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return GenericName(Identifier(identifier), TypeArgumentList());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax TypeArgumentList(SyntaxToken lessThanToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax> arguments, SyntaxToken greaterThanToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (lessThanToken.Kind() != SyntaxKind.LessThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("lessThanToken");
|
||
|
|
}
|
||
|
|
if (greaterThanToken.Kind() != SyntaxKind.GreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("greaterThanToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TypeArgumentList((SyntaxToken)(object)((SyntaxToken)(ref lessThanToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax>(arguments.Node), (SyntaxToken)(object)((SyntaxToken)(ref greaterThanToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeArgumentListSyntax TypeArgumentList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax> arguments = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TypeArgumentList(Token(SyntaxKind.LessThanToken), arguments, Token(SyntaxKind.GreaterThanToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax alias, SyntaxToken colonColonToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (alias == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("alias");
|
||
|
|
}
|
||
|
|
if (colonColonToken.Kind() != SyntaxKind.ColonColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonColonToken");
|
||
|
|
}
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AliasQualifiedName((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.IdentifierNameSyntax)(object)((SyntaxNode)alias).Green, (SyntaxToken)(object)((SyntaxToken)(ref colonColonToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SimpleNameSyntax)(object)((SyntaxNode)name).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax AliasQualifiedName(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax alias, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AliasQualifiedName(alias, Token(SyntaxKind.ColonColonToken), name);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AliasQualifiedNameSyntax AliasQualifiedName(string alias, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AliasQualifiedName(IdentifierName(alias), Token(SyntaxKind.ColonColonToken), name);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax PredefinedType(SyntaxToken keyword)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = keyword.Kind();
|
||
|
|
if (syntaxKind - 8304 > (SyntaxKind)15)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.PredefinedTypeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PredefinedType((SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax> rankSpecifiers)
|
||
|
|
{
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (elementType == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("elementType");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ArrayType((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)elementType).Green, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrayRankSpecifierSyntax>(rankSpecifiers.Node))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax ArrayType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ArrayType(elementType, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax>));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax ArrayRankSpecifier(SyntaxToken openBracketToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> sizes, SyntaxToken closeBracketToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBracketToken");
|
||
|
|
}
|
||
|
|
if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBracketToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ArrayRankSpecifier((SyntaxToken)(object)((SyntaxToken)(ref openBracketToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax>(sizes.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBracketToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArrayRankSpecifierSyntax ArrayRankSpecifier(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> sizes = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ArrayRankSpecifier(Token(SyntaxKind.OpenBracketToken), sizes, Token(SyntaxKind.CloseBracketToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType, SyntaxToken asteriskToken)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (elementType == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("elementType");
|
||
|
|
}
|
||
|
|
if (asteriskToken.Kind() != SyntaxKind.AsteriskToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("asteriskToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PointerType((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)elementType).Green, (SyntaxToken)(object)((SyntaxToken)(ref asteriskToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PointerTypeSyntax PointerType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return PointerType(elementType, Token(SyntaxKind.AsteriskToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax? callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax parameterList)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (delegateKeyword.Kind() != SyntaxKind.DelegateKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("delegateKeyword");
|
||
|
|
}
|
||
|
|
if (asteriskToken.Kind() != SyntaxKind.AsteriskToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("asteriskToken");
|
||
|
|
}
|
||
|
|
if (parameterList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameterList");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FunctionPointerType((SyntaxToken)(object)((SyntaxToken)(ref delegateKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref asteriskToken)).Node, (callingConvention == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)(object)((SyntaxNode)callingConvention).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.FunctionPointerParameterListSyntax)(object)((SyntaxNode)parameterList).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax FunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax? callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax parameterList)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FunctionPointerType(Token(SyntaxKind.DelegateKeyword), Token(SyntaxKind.AsteriskToken), callingConvention, parameterList);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax FunctionPointerType()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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 FunctionPointerType(Token(SyntaxKind.DelegateKeyword), Token(SyntaxKind.AsteriskToken), null, FunctionPointerParameterList());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax FunctionPointerParameterList(SyntaxToken lessThanToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax> parameters, SyntaxToken greaterThanToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (lessThanToken.Kind() != SyntaxKind.LessThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("lessThanToken");
|
||
|
|
}
|
||
|
|
if (greaterThanToken.Kind() != SyntaxKind.GreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("greaterThanToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FunctionPointerParameterList((SyntaxToken)(object)((SyntaxToken)(ref lessThanToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.FunctionPointerParameterSyntax>(parameters.Node), (SyntaxToken)(object)((SyntaxToken)(ref greaterThanToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax FunctionPointerParameterList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax> parameters = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FunctionPointerParameterList(Token(SyntaxKind.LessThanToken), parameters, Token(SyntaxKind.GreaterThanToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedOrUnmanagedKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = managedOrUnmanagedKeyword.Kind();
|
||
|
|
if (syntaxKind - 8445 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("managedOrUnmanagedKeyword");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FunctionPointerCallingConvention((SyntaxToken)(object)((SyntaxToken)(ref managedOrUnmanagedKeyword)).Node, (unmanagedCallingConventionList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionListSyntax)(object)((SyntaxNode)unmanagedCallingConventionList).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedOrUnmanagedKeyword)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FunctionPointerCallingConvention(managedOrUnmanagedKeyword, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax FunctionPointerUnmanagedCallingConventionList(SyntaxToken openBracketToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax> callingConventions, SyntaxToken closeBracketToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBracketToken");
|
||
|
|
}
|
||
|
|
if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBracketToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList((SyntaxToken)(object)((SyntaxToken)(ref openBracketToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntax>(callingConventions.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBracketToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax FunctionPointerUnmanagedCallingConventionList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax> callingConventions = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FunctionPointerUnmanagedCallingConventionList(Token(SyntaxKind.OpenBracketToken), callingConventions, Token(SyntaxKind.CloseBracketToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken name)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (name.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("name");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FunctionPointerUnmanagedCallingConvention((SyntaxToken)(object)((SyntaxToken)(ref name)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType, SyntaxToken questionToken)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (elementType == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("elementType");
|
||
|
|
}
|
||
|
|
if (questionToken.Kind() != SyntaxKind.QuestionToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("questionToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.NullableType((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)elementType).Green, (SyntaxToken)(object)((SyntaxToken)(ref questionToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NullableTypeSyntax NullableType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax elementType)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return NullableType(elementType, Token(SyntaxKind.QuestionToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax TupleType(SyntaxToken openParenToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax> elements, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TupleType((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TupleElementSyntax>(elements.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax TupleType(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax> elements = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TupleType(Token(SyntaxKind.OpenParenToken), elements, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = identifier.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TupleElement((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax TupleElement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TupleElement(type, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax OmittedTypeArgument(SyntaxToken omittedTypeArgumentToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (omittedTypeArgumentToken.Kind() != SyntaxKind.OmittedTypeArgumentToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("omittedTypeArgumentToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.OmittedTypeArgument((SyntaxToken)(object)((SyntaxToken)(ref omittedTypeArgumentToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OmittedTypeArgumentSyntax OmittedTypeArgument()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return OmittedTypeArgument(Token(SyntaxKind.OmittedTypeArgumentToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax RefType(SyntaxToken refKeyword, SyntaxToken readOnlyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (refKeyword.Kind() != SyntaxKind.RefKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("refKeyword");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = readOnlyKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.ReadOnlyKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("readOnlyKeyword");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.RefType((SyntaxToken)(object)((SyntaxToken)(ref refKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref readOnlyKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax RefType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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 RefType(Token(SyntaxKind.RefKeyword), default(SyntaxToken), type);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax ScopedType(SyntaxToken scopedKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (scopedKeyword.Kind() != SyntaxKind.ScopedKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("scopedKeyword");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ScopedType((SyntaxToken)(object)((SyntaxToken)(ref scopedKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ScopedTypeSyntax ScopedType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ScopedType(Token(SyntaxKind.ScopedKeyword), type);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax ParenthesizedExpression(SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ParenthesizedExpression((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedExpressionSyntax ParenthesizedExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ParenthesizedExpression(Token(SyntaxKind.OpenParenToken), expression, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax TupleExpression(SyntaxToken openParenToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TupleExpression((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArgumentSyntax>(arguments.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax TupleExpression(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TupleExpression(Token(SyntaxKind.OpenParenToken), arguments, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax PrefixUnaryExpression(SyntaxKind kind, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand)
|
||
|
|
{
|
||
|
|
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8730 > (SyntaxKind)7 && kind != SyntaxKind.IndexExpression)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
switch (operatorToken.Kind())
|
||
|
|
{
|
||
|
|
default:
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
case SyntaxKind.TildeToken:
|
||
|
|
case SyntaxKind.ExclamationToken:
|
||
|
|
case SyntaxKind.CaretToken:
|
||
|
|
case SyntaxKind.AmpersandToken:
|
||
|
|
case SyntaxKind.AsteriskToken:
|
||
|
|
case SyntaxKind.MinusToken:
|
||
|
|
case SyntaxKind.PlusToken:
|
||
|
|
case SyntaxKind.MinusMinusToken:
|
||
|
|
case SyntaxKind.PlusPlusToken:
|
||
|
|
if (operand == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("operand");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PrefixUnaryExpression(kind, (SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)operand).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PrefixUnaryExpressionSyntax PrefixUnaryExpression(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return PrefixUnaryExpression(kind, Token(GetPrefixUnaryExpressionOperatorTokenKind(kind)), operand);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetPrefixUnaryExpressionOperatorTokenKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.UnaryPlusExpression => SyntaxKind.PlusToken,
|
||
|
|
SyntaxKind.UnaryMinusExpression => SyntaxKind.MinusToken,
|
||
|
|
SyntaxKind.BitwiseNotExpression => SyntaxKind.TildeToken,
|
||
|
|
SyntaxKind.LogicalNotExpression => SyntaxKind.ExclamationToken,
|
||
|
|
SyntaxKind.PreIncrementExpression => SyntaxKind.PlusPlusToken,
|
||
|
|
SyntaxKind.PreDecrementExpression => SyntaxKind.MinusMinusToken,
|
||
|
|
SyntaxKind.AddressOfExpression => SyntaxKind.AmpersandToken,
|
||
|
|
SyntaxKind.PointerIndirectionExpression => SyntaxKind.AsteriskToken,
|
||
|
|
SyntaxKind.IndexExpression => SyntaxKind.CaretToken,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax AwaitExpression(SyntaxToken awaitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (awaitKeyword.Kind() != SyntaxKind.AwaitKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("awaitKeyword");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AwaitExpression((SyntaxToken)(object)((SyntaxToken)(ref awaitKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AwaitExpressionSyntax AwaitExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AwaitExpression(Token(SyntaxKind.AwaitKeyword), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax PostfixUnaryExpression(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand, SyntaxToken operatorToken)
|
||
|
|
{
|
||
|
|
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8738 > SyntaxKind.List && kind != SyntaxKind.SuppressNullableWarningExpression)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (operand == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("operand");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = operatorToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.ExclamationToken && syntaxKind - 8262 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PostfixUnaryExpression(kind, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)operand).Green, (SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PostfixUnaryExpressionSyntax PostfixUnaryExpression(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax operand)
|
||
|
|
{
|
||
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return PostfixUnaryExpression(kind, operand, Token(GetPostfixUnaryExpressionOperatorTokenKind(kind)));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetPostfixUnaryExpressionOperatorTokenKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.PostIncrementExpression => SyntaxKind.PlusPlusToken,
|
||
|
|
SyntaxKind.PostDecrementExpression => SyntaxKind.MinusMinusToken,
|
||
|
|
SyntaxKind.SuppressNullableWarningExpression => SyntaxKind.ExclamationToken,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax MemberAccessExpression(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8689 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = operatorToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.DotToken && syntaxKind != SyntaxKind.MinusGreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
}
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.MemberAccessExpression(kind, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SimpleNameSyntax)(object)((SyntaxNode)name).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MemberAccessExpressionSyntax MemberAccessExpression(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return MemberAccessExpression(kind, expression, Token(GetMemberAccessExpressionOperatorTokenKind(kind)), name);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetMemberAccessExpressionOperatorTokenKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.SimpleMemberAccessExpression => SyntaxKind.DotToken,
|
||
|
|
SyntaxKind.PointerMemberAccessExpression => SyntaxKind.MinusGreaterThanToken,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenNotNull)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (operatorToken.Kind() != SyntaxKind.QuestionToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
}
|
||
|
|
if (whenNotNull == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("whenNotNull");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ConditionalAccessExpression((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)whenNotNull).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalAccessExpressionSyntax ConditionalAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenNotNull)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConditionalAccessExpression(expression, Token(SyntaxKind.QuestionToken), whenNotNull);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax MemberBindingExpression(SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (operatorToken.Kind() != SyntaxKind.DotToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
}
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.MemberBindingExpression((SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SimpleNameSyntax)(object)((SyntaxNode)name).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MemberBindingExpressionSyntax MemberBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.SimpleNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return MemberBindingExpression(Token(SyntaxKind.DotToken), name);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax ElementBindingExpression(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList)
|
||
|
|
{
|
||
|
|
if (argumentList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("argumentList");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElementBindingExpression((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BracketedArgumentListSyntax)(object)((SyntaxNode)argumentList).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ElementBindingExpressionSyntax ElementBindingExpression()
|
||
|
|
{
|
||
|
|
//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 ElementBindingExpression(BracketedArgumentList());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? leftOperand, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? rightOperand)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (operatorToken.Kind() != SyntaxKind.DotDotToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.RangeExpression((leftOperand == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)leftOperand).Green), (SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (rightOperand == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)rightOperand).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax RangeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? leftOperand, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? rightOperand)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return RangeExpression(leftOperand, Token(SyntaxKind.DotDotToken), rightOperand);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax RangeExpression()
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return RangeExpression(null, Token(SyntaxKind.DotDotToken), null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax ImplicitElementAccess(Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList)
|
||
|
|
{
|
||
|
|
if (argumentList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("argumentList");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ImplicitElementAccess((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BracketedArgumentListSyntax)(object)((SyntaxNode)argumentList).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitElementAccessSyntax ImplicitElementAccess()
|
||
|
|
{
|
||
|
|
//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 ImplicitElementAccess(BracketedArgumentList());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax BinaryExpression(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right)
|
||
|
|
{
|
||
|
|
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8668 > (SyntaxKind)20 && kind != SyntaxKind.UnsignedRightShiftExpression)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (left == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("left");
|
||
|
|
}
|
||
|
|
switch (operatorToken.Kind())
|
||
|
|
{
|
||
|
|
default:
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
case SyntaxKind.PercentToken:
|
||
|
|
case SyntaxKind.CaretToken:
|
||
|
|
case SyntaxKind.AmpersandToken:
|
||
|
|
case SyntaxKind.AsteriskToken:
|
||
|
|
case SyntaxKind.MinusToken:
|
||
|
|
case SyntaxKind.PlusToken:
|
||
|
|
case SyntaxKind.BarToken:
|
||
|
|
case SyntaxKind.LessThanToken:
|
||
|
|
case SyntaxKind.GreaterThanToken:
|
||
|
|
case SyntaxKind.SlashToken:
|
||
|
|
case SyntaxKind.BarBarToken:
|
||
|
|
case SyntaxKind.AmpersandAmpersandToken:
|
||
|
|
case SyntaxKind.QuestionQuestionToken:
|
||
|
|
case SyntaxKind.ExclamationEqualsToken:
|
||
|
|
case SyntaxKind.EqualsEqualsToken:
|
||
|
|
case SyntaxKind.LessThanEqualsToken:
|
||
|
|
case SyntaxKind.LessThanLessThanToken:
|
||
|
|
case SyntaxKind.GreaterThanEqualsToken:
|
||
|
|
case SyntaxKind.GreaterThanGreaterThanToken:
|
||
|
|
case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
|
||
|
|
case SyntaxKind.IsKeyword:
|
||
|
|
case SyntaxKind.AsKeyword:
|
||
|
|
if (right == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("right");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.BinaryExpression(kind, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)left).Green, (SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)right).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BinaryExpressionSyntax BinaryExpression(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right)
|
||
|
|
{
|
||
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return BinaryExpression(kind, left, Token(GetBinaryExpressionOperatorTokenKind(kind)), right);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetBinaryExpressionOperatorTokenKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.AddExpression => SyntaxKind.PlusToken,
|
||
|
|
SyntaxKind.SubtractExpression => SyntaxKind.MinusToken,
|
||
|
|
SyntaxKind.MultiplyExpression => SyntaxKind.AsteriskToken,
|
||
|
|
SyntaxKind.DivideExpression => SyntaxKind.SlashToken,
|
||
|
|
SyntaxKind.ModuloExpression => SyntaxKind.PercentToken,
|
||
|
|
SyntaxKind.LeftShiftExpression => SyntaxKind.LessThanLessThanToken,
|
||
|
|
SyntaxKind.RightShiftExpression => SyntaxKind.GreaterThanGreaterThanToken,
|
||
|
|
SyntaxKind.UnsignedRightShiftExpression => SyntaxKind.GreaterThanGreaterThanGreaterThanToken,
|
||
|
|
SyntaxKind.LogicalOrExpression => SyntaxKind.BarBarToken,
|
||
|
|
SyntaxKind.LogicalAndExpression => SyntaxKind.AmpersandAmpersandToken,
|
||
|
|
SyntaxKind.BitwiseOrExpression => SyntaxKind.BarToken,
|
||
|
|
SyntaxKind.BitwiseAndExpression => SyntaxKind.AmpersandToken,
|
||
|
|
SyntaxKind.ExclusiveOrExpression => SyntaxKind.CaretToken,
|
||
|
|
SyntaxKind.EqualsExpression => SyntaxKind.EqualsEqualsToken,
|
||
|
|
SyntaxKind.NotEqualsExpression => SyntaxKind.ExclamationEqualsToken,
|
||
|
|
SyntaxKind.LessThanExpression => SyntaxKind.LessThanToken,
|
||
|
|
SyntaxKind.LessThanOrEqualExpression => SyntaxKind.LessThanEqualsToken,
|
||
|
|
SyntaxKind.GreaterThanExpression => SyntaxKind.GreaterThanToken,
|
||
|
|
SyntaxKind.GreaterThanOrEqualExpression => SyntaxKind.GreaterThanEqualsToken,
|
||
|
|
SyntaxKind.IsExpression => SyntaxKind.IsKeyword,
|
||
|
|
SyntaxKind.AsExpression => SyntaxKind.AsKeyword,
|
||
|
|
SyntaxKind.CoalesceExpression => SyntaxKind.QuestionQuestionToken,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax AssignmentExpression(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right)
|
||
|
|
{
|
||
|
|
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8714 > (SyntaxKind)12)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (left == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("left");
|
||
|
|
}
|
||
|
|
switch (operatorToken.Kind())
|
||
|
|
{
|
||
|
|
default:
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
case SyntaxKind.EqualsToken:
|
||
|
|
case SyntaxKind.LessThanLessThanEqualsToken:
|
||
|
|
case SyntaxKind.GreaterThanGreaterThanEqualsToken:
|
||
|
|
case SyntaxKind.SlashEqualsToken:
|
||
|
|
case SyntaxKind.AsteriskEqualsToken:
|
||
|
|
case SyntaxKind.BarEqualsToken:
|
||
|
|
case SyntaxKind.AmpersandEqualsToken:
|
||
|
|
case SyntaxKind.PlusEqualsToken:
|
||
|
|
case SyntaxKind.MinusEqualsToken:
|
||
|
|
case SyntaxKind.CaretEqualsToken:
|
||
|
|
case SyntaxKind.PercentEqualsToken:
|
||
|
|
case SyntaxKind.QuestionQuestionEqualsToken:
|
||
|
|
case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
|
||
|
|
if (right == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("right");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AssignmentExpression(kind, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)left).Green, (SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)right).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AssignmentExpressionSyntax AssignmentExpression(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax left, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax right)
|
||
|
|
{
|
||
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AssignmentExpression(kind, left, Token(GetAssignmentExpressionOperatorTokenKind(kind)), right);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetAssignmentExpressionOperatorTokenKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.SimpleAssignmentExpression => SyntaxKind.EqualsToken,
|
||
|
|
SyntaxKind.AddAssignmentExpression => SyntaxKind.PlusEqualsToken,
|
||
|
|
SyntaxKind.SubtractAssignmentExpression => SyntaxKind.MinusEqualsToken,
|
||
|
|
SyntaxKind.MultiplyAssignmentExpression => SyntaxKind.AsteriskEqualsToken,
|
||
|
|
SyntaxKind.DivideAssignmentExpression => SyntaxKind.SlashEqualsToken,
|
||
|
|
SyntaxKind.ModuloAssignmentExpression => SyntaxKind.PercentEqualsToken,
|
||
|
|
SyntaxKind.AndAssignmentExpression => SyntaxKind.AmpersandEqualsToken,
|
||
|
|
SyntaxKind.ExclusiveOrAssignmentExpression => SyntaxKind.CaretEqualsToken,
|
||
|
|
SyntaxKind.OrAssignmentExpression => SyntaxKind.BarEqualsToken,
|
||
|
|
SyntaxKind.LeftShiftAssignmentExpression => SyntaxKind.LessThanLessThanEqualsToken,
|
||
|
|
SyntaxKind.RightShiftAssignmentExpression => SyntaxKind.GreaterThanGreaterThanEqualsToken,
|
||
|
|
SyntaxKind.UnsignedRightShiftAssignmentExpression => SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
|
||
|
|
SyntaxKind.CoalesceAssignmentExpression => SyntaxKind.QuestionQuestionEqualsToken,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, SyntaxToken questionToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenTrue, SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenFalse)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (condition == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("condition");
|
||
|
|
}
|
||
|
|
if (questionToken.Kind() != SyntaxKind.QuestionToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("questionToken");
|
||
|
|
}
|
||
|
|
if (whenTrue == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("whenTrue");
|
||
|
|
}
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
if (whenFalse == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("whenFalse");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ConditionalExpression((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)condition).Green, (SyntaxToken)(object)((SyntaxToken)(ref questionToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)whenTrue).Green, (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)whenFalse).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConditionalExpressionSyntax ConditionalExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenTrue, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax whenFalse)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConditionalExpression(condition, Token(SyntaxKind.QuestionToken), whenTrue, Token(SyntaxKind.ColonToken), whenFalse);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax ThisExpression(SyntaxToken token)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (token.Kind() != SyntaxKind.ThisKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("token");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ThisExpression((SyntaxToken)(object)((SyntaxToken)(ref token)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ThisExpressionSyntax ThisExpression()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ThisExpression(Token(SyntaxKind.ThisKeyword));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax BaseExpression(SyntaxToken token)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (token.Kind() != SyntaxKind.BaseKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("token");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.BaseExpression((SyntaxToken)(object)((SyntaxToken)(ref token)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionSyntax BaseExpression()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return BaseExpression(Token(SyntaxKind.BaseKeyword));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax LiteralExpression(SyntaxKind kind, SyntaxToken token)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8748 > (SyntaxKind)8)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
switch (token.Kind())
|
||
|
|
{
|
||
|
|
default:
|
||
|
|
throw new ArgumentException("token");
|
||
|
|
case SyntaxKind.NullKeyword:
|
||
|
|
case SyntaxKind.TrueKeyword:
|
||
|
|
case SyntaxKind.FalseKeyword:
|
||
|
|
case SyntaxKind.DefaultKeyword:
|
||
|
|
case SyntaxKind.ArgListKeyword:
|
||
|
|
case SyntaxKind.NumericLiteralToken:
|
||
|
|
case SyntaxKind.CharacterLiteralToken:
|
||
|
|
case SyntaxKind.StringLiteralToken:
|
||
|
|
case SyntaxKind.SingleLineRawStringLiteralToken:
|
||
|
|
case SyntaxKind.MultiLineRawStringLiteralToken:
|
||
|
|
case SyntaxKind.Utf8StringLiteralToken:
|
||
|
|
case SyntaxKind.Utf8SingleLineRawStringLiteralToken:
|
||
|
|
case SyntaxKind.Utf8MultiLineRawStringLiteralToken:
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.LiteralExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LiteralExpression(kind, (SyntaxToken)(object)((SyntaxToken)(ref token)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax MakeRefExpression(SyntaxToken keyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (keyword.Kind() != SyntaxKind.MakeRefKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.MakeRefExpression((SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MakeRefExpressionSyntax MakeRefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return MakeRefExpression(Token(SyntaxKind.MakeRefKeyword), Token(SyntaxKind.OpenParenToken), expression, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax RefTypeExpression(SyntaxToken keyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (keyword.Kind() != SyntaxKind.RefTypeKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.RefTypeExpression((SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeExpressionSyntax RefTypeExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return RefTypeExpression(Token(SyntaxKind.RefTypeKeyword), Token(SyntaxKind.OpenParenToken), expression, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax RefValueExpression(SyntaxToken keyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken comma, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (keyword.Kind() != SyntaxKind.RefValueKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (comma.Kind() != SyntaxKind.CommaToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("comma");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.RefValueExpression((SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref comma)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RefValueExpressionSyntax RefValueExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: 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)
|
||
|
|
return RefValueExpression(Token(SyntaxKind.RefValueKeyword), Token(SyntaxKind.OpenParenToken), expression, Token(SyntaxKind.CommaToken), type, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax CheckedExpression(SyntaxKind kind, SyntaxToken keyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8762 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = keyword.Kind();
|
||
|
|
if (syntaxKind - 8379 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CheckedExpression(kind, (SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CheckedExpressionSyntax CheckedExpression(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CheckedExpression(kind, Token(GetCheckedExpressionKeywordKind(kind)), Token(SyntaxKind.OpenParenToken), expression, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetCheckedExpressionKeywordKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.CheckedExpression => SyntaxKind.CheckedKeyword,
|
||
|
|
SyntaxKind.UncheckedExpression => SyntaxKind.UncheckedKeyword,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax DefaultExpression(SyntaxToken keyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (keyword.Kind() != SyntaxKind.DefaultKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DefaultExpression((SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DefaultExpressionSyntax DefaultExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DefaultExpression(Token(SyntaxKind.DefaultKeyword), Token(SyntaxKind.OpenParenToken), type, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax TypeOfExpression(SyntaxToken keyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (keyword.Kind() != SyntaxKind.TypeOfKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TypeOfExpression((SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeOfExpressionSyntax TypeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TypeOfExpression(Token(SyntaxKind.TypeOfKeyword), Token(SyntaxKind.OpenParenToken), type, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax SizeOfExpression(SyntaxToken keyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (keyword.Kind() != SyntaxKind.SizeOfKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SizeOfExpression((SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SizeOfExpressionSyntax SizeOfExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SizeOfExpression(Token(SyntaxKind.SizeOfKeyword), Token(SyntaxKind.OpenParenToken), type, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList)
|
||
|
|
{
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (argumentList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("argumentList");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.InvocationExpression((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArgumentListSyntax)(object)((SyntaxNode)argumentList).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax InvocationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return InvocationExpression(expression, ArgumentList());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax argumentList)
|
||
|
|
{
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (argumentList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("argumentList");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElementAccessExpression((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BracketedArgumentListSyntax)(object)((SyntaxNode)argumentList).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ElementAccessExpressionSyntax ElementAccessExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ElementAccessExpression(expression, BracketedArgumentList());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax ArgumentList(SyntaxToken openParenToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ArgumentList((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArgumentSyntax>(arguments.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax ArgumentList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ArgumentList(Token(SyntaxKind.OpenParenToken), arguments, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax BracketedArgumentList(SyntaxToken openBracketToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments, SyntaxToken closeBracketToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBracketToken");
|
||
|
|
}
|
||
|
|
if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBracketToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.BracketedArgumentList((SyntaxToken)(object)((SyntaxToken)(ref openBracketToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArgumentSyntax>(arguments.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBracketToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax BracketedArgumentList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax> arguments = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return BracketedArgumentList(Token(SyntaxKind.OpenBracketToken), arguments, Token(SyntaxKind.CloseBracketToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax Argument(Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon, SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = refKindKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind - 8360 > (SyntaxKind)2)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("refKindKeyword");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Argument((nameColon == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameColonSyntax)(object)((SyntaxNode)nameColon).Green), (SyntaxToken)(object)((SyntaxToken)(ref refKindKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax Argument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Argument(null, default(SyntaxToken), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax ExpressionColon(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionColonSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ExpressionColon((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax NameColon(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.NameColon((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.IdentifierNameSyntax)(object)((SyntaxNode)name).Green, (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax DeclarationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation)
|
||
|
|
{
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (designation == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("designation");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DeclarationExpression((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDesignationSyntax)(object)((SyntaxNode)designation).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax CastExpression(SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CastExpression((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CastExpressionSyntax CastExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CastExpression(Token(SyntaxKind.OpenParenToken), type, Token(SyntaxKind.CloseParenToken), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax AnonymousMethodExpression(SyntaxTokenList modifiers, SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
if (delegateKeyword.Kind() != SyntaxKind.DelegateKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("delegateKeyword");
|
||
|
|
}
|
||
|
|
if (block == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("block");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousMethodExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AnonymousMethodExpression(GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref delegateKeyword)).Node, (parameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)block).Green, (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expressionBody).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax SimpleLambdaExpression(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_000e: 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)
|
||
|
|
if (parameter == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameter");
|
||
|
|
}
|
||
|
|
if (arrowToken.Kind() != SyntaxKind.EqualsGreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("arrowToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SimpleLambdaExpression(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterSyntax)(object)((SyntaxNode)parameter).Green, (SyntaxToken)(object)((SyntaxToken)(ref arrowToken)).Node, (block == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)block).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expressionBody).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax SimpleLambdaExpression(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: 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 SimpleLambdaExpression(attributeLists, modifiers, parameter, Token(SyntaxKind.EqualsGreaterThanToken), block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SimpleLambdaExpressionSyntax SimpleLambdaExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax parameter)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SimpleLambdaExpression(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), parameter, Token(SyntaxKind.EqualsGreaterThanToken), null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax RefExpression(SyntaxToken refKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (refKeyword.Kind() != SyntaxKind.RefKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("refKeyword");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.RefExpression((SyntaxToken)(object)((SyntaxToken)(ref refKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax RefExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return RefExpression(Token(SyntaxKind.RefKeyword), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_000e: 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_003a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (parameterList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameterList");
|
||
|
|
}
|
||
|
|
if (arrowToken.Kind() != SyntaxKind.EqualsGreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("arrowToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ParenthesizedLambdaExpression(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (returnType == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)returnType).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green, (SyntaxToken)(object)((SyntaxToken)(ref arrowToken)).Node, (block == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)block).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expressionBody).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ParenthesizedLambdaExpression(attributeLists, modifiers, returnType, parameterList, Token(SyntaxKind.EqualsGreaterThanToken), block, expressionBody);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression()
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: 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)
|
||
|
|
return ParenthesizedLambdaExpression(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), null, ParameterList(), Token(SyntaxKind.EqualsGreaterThanToken), null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax InitializerExpression(SyntaxKind kind, SyntaxToken openBraceToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> expressions, SyntaxToken closeBraceToken)
|
||
|
|
{
|
||
|
|
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8644 > (SyntaxKind)2 && kind != SyntaxKind.ComplexElementInitializerExpression && kind != SyntaxKind.WithInitializerExpression)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (openBraceToken.Kind() != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
if (closeBraceToken.Kind() != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.InitializerExpression(kind, (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax>(expressions.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax InitializerExpression(SyntaxKind kind, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> expressions = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>))
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return InitializerExpression(kind, Token(SyntaxKind.OpenBraceToken), expressions, Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax ImplicitObjectCreationExpression(SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (newKeyword.Kind() != SyntaxKind.NewKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("newKeyword");
|
||
|
|
}
|
||
|
|
if (argumentList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("argumentList");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ImplicitObjectCreationExpression((SyntaxToken)(object)((SyntaxToken)(ref newKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArgumentListSyntax)(object)((SyntaxNode)argumentList).Green, (initializer == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.InitializerExpressionSyntax)(object)((SyntaxNode)initializer).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ImplicitObjectCreationExpression(Token(SyntaxKind.NewKeyword), argumentList, initializer);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax ImplicitObjectCreationExpression()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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 ImplicitObjectCreationExpression(Token(SyntaxKind.NewKeyword), ArgumentList(), null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax ObjectCreationExpression(SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax? argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (newKeyword.Kind() != SyntaxKind.NewKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("newKeyword");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ObjectCreationExpression((SyntaxToken)(object)((SyntaxToken)(ref newKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (argumentList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArgumentListSyntax)(object)((SyntaxNode)argumentList).Green), (initializer == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.InitializerExpressionSyntax)(object)((SyntaxNode)initializer).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax? argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ObjectCreationExpression(Token(SyntaxKind.NewKeyword), type, argumentList, initializer);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax ObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ObjectCreationExpression(Token(SyntaxKind.NewKeyword), type, null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken withKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (withKeyword.Kind() != SyntaxKind.WithKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("withKeyword");
|
||
|
|
}
|
||
|
|
if (initializer == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("initializer");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.WithExpression((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref withKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.InitializerExpressionSyntax)(object)((SyntaxNode)initializer).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return WithExpression(expression, Token(SyntaxKind.WithKeyword), initializer);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? nameEquals, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AnonymousObjectMemberDeclarator((nameEquals == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameEqualsSyntax)(object)((SyntaxNode)nameEquals).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax AnonymousObjectMemberDeclarator(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
return AnonymousObjectMemberDeclarator(null, expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax AnonymousObjectCreationExpression(SyntaxToken newKeyword, SyntaxToken openBraceToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax> initializers, SyntaxToken closeBraceToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0067: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (newKeyword.Kind() != SyntaxKind.NewKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("newKeyword");
|
||
|
|
}
|
||
|
|
if (openBraceToken.Kind() != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
if (closeBraceToken.Kind() != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AnonymousObjectCreationExpression((SyntaxToken)(object)((SyntaxToken)(ref newKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AnonymousObjectMemberDeclaratorSyntax>(initializers.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectCreationExpressionSyntax AnonymousObjectCreationExpression(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax> initializers = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AnonymousObjectMemberDeclaratorSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AnonymousObjectCreationExpression(Token(SyntaxKind.NewKeyword), Token(SyntaxKind.OpenBraceToken), initializers, Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax ArrayCreationExpression(SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (newKeyword.Kind() != SyntaxKind.NewKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("newKeyword");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ArrayCreationExpression((SyntaxToken)(object)((SyntaxToken)(ref newKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrayTypeSyntax)(object)((SyntaxNode)type).Green, (initializer == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.InitializerExpressionSyntax)(object)((SyntaxNode)initializer).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ArrayCreationExpression(Token(SyntaxKind.NewKeyword), type, initializer);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArrayCreationExpressionSyntax ArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArrayTypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ArrayCreationExpression(Token(SyntaxKind.NewKeyword), type, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax ImplicitArrayCreationExpression(SyntaxToken newKeyword, SyntaxToken openBracketToken, SyntaxTokenList commas, SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0076: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (newKeyword.Kind() != SyntaxKind.NewKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("newKeyword");
|
||
|
|
}
|
||
|
|
if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBracketToken");
|
||
|
|
}
|
||
|
|
if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBracketToken");
|
||
|
|
}
|
||
|
|
if (initializer == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("initializer");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ImplicitArrayCreationExpression((SyntaxToken)(object)((SyntaxToken)(ref newKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openBracketToken)).Node, GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref commas)).Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBracketToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.InitializerExpressionSyntax)(object)((SyntaxNode)initializer).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax ImplicitArrayCreationExpression(SyntaxTokenList commas, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ImplicitArrayCreationExpression(Token(SyntaxKind.NewKeyword), Token(SyntaxKind.OpenBracketToken), commas, Token(SyntaxKind.CloseBracketToken), initializer);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitArrayCreationExpressionSyntax ImplicitArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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 ImplicitArrayCreationExpression(Token(SyntaxKind.NewKeyword), Token(SyntaxKind.OpenBracketToken), default(SyntaxTokenList), Token(SyntaxKind.CloseBracketToken), initializer);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax StackAllocArrayCreationExpression(SyntaxToken stackAllocKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (stackAllocKeyword.Kind() != SyntaxKind.StackAllocKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("stackAllocKeyword");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.StackAllocArrayCreationExpression((SyntaxToken)(object)((SyntaxToken)(ref stackAllocKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (initializer == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.InitializerExpressionSyntax)(object)((SyntaxNode)initializer).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax? initializer)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return StackAllocArrayCreationExpression(Token(SyntaxKind.StackAllocKeyword), type, initializer);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StackAllocArrayCreationExpressionSyntax StackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return StackAllocArrayCreationExpression(Token(SyntaxKind.StackAllocKeyword), type, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax ImplicitStackAllocArrayCreationExpression(SyntaxToken stackAllocKeyword, SyntaxToken openBracketToken, SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (stackAllocKeyword.Kind() != SyntaxKind.StackAllocKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("stackAllocKeyword");
|
||
|
|
}
|
||
|
|
if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBracketToken");
|
||
|
|
}
|
||
|
|
if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBracketToken");
|
||
|
|
}
|
||
|
|
if (initializer == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("initializer");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ImplicitStackAllocArrayCreationExpression((SyntaxToken)(object)((SyntaxToken)(ref stackAllocKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openBracketToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref closeBracketToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.InitializerExpressionSyntax)(object)((SyntaxNode)initializer).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax ImplicitStackAllocArrayCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ImplicitStackAllocArrayCreationExpression(Token(SyntaxKind.StackAllocKeyword), Token(SyntaxKind.OpenBracketToken), Token(SyntaxKind.CloseBracketToken), initializer);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax CollectionExpression(SyntaxToken openBracketToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax> elements, SyntaxToken closeBracketToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBracketToken");
|
||
|
|
}
|
||
|
|
if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBracketToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CollectionExpression((SyntaxToken)(object)((SyntaxToken)(ref openBracketToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CollectionElementSyntax>(elements.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBracketToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CollectionExpressionSyntax CollectionExpression(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax> elements = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CollectionExpression(Token(SyntaxKind.OpenBracketToken), elements, Token(SyntaxKind.CloseBracketToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax ExpressionElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionElementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ExpressionElement((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax SpreadElement(SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (operatorToken.Kind() != SyntaxKind.DotDotToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SpreadElement((SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SpreadElementSyntax SpreadElement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SpreadElement(Token(SyntaxKind.DotDotToken), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax QueryExpression(Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax fromClause, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body)
|
||
|
|
{
|
||
|
|
if (fromClause == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("fromClause");
|
||
|
|
}
|
||
|
|
if (body == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("body");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.QueryExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.QueryExpression((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.FromClauseSyntax)(object)((SyntaxNode)fromClause).Green, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.QueryBodySyntax)(object)((SyntaxNode)body).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax QueryBody(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax> clauses, Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax selectOrGroup, Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax? continuation)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (selectOrGroup == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("selectOrGroup");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.QueryBody(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.QueryClauseSyntax>(clauses.Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SelectOrGroupClauseSyntax)(object)((SyntaxNode)selectOrGroup).Green, (continuation == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.QueryContinuationSyntax)(object)((SyntaxNode)continuation).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax QueryBody(Microsoft.CodeAnalysis.CSharp.Syntax.SelectOrGroupClauseSyntax selectOrGroup)
|
||
|
|
{
|
||
|
|
//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 QueryBody(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.QueryClauseSyntax>), selectOrGroup, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax FromClause(SyntaxToken fromKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, SyntaxToken identifier, SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (fromKeyword.Kind() != SyntaxKind.FromKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("fromKeyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (inKeyword.Kind() != SyntaxKind.InKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("inKeyword");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FromClause((SyntaxToken)(object)((SyntaxToken)(ref fromKeyword)).Node, (type == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green), (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (SyntaxToken)(object)((SyntaxToken)(ref inKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax FromClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FromClause(Token(SyntaxKind.FromKeyword), type, identifier, Token(SyntaxKind.InKeyword), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax FromClause(SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FromClause(Token(SyntaxKind.FromKeyword), null, identifier, Token(SyntaxKind.InKeyword), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FromClauseSyntax FromClause(string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FromClause(Token(SyntaxKind.FromKeyword), null, Identifier(identifier), Token(SyntaxKind.InKeyword), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax LetClause(SyntaxToken letKeyword, SyntaxToken identifier, SyntaxToken equalsToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (letKeyword.Kind() != SyntaxKind.LetKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("letKeyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (equalsToken.Kind() != SyntaxKind.EqualsToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("equalsToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LetClause((SyntaxToken)(object)((SyntaxToken)(ref letKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (SyntaxToken)(object)((SyntaxToken)(ref equalsToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax LetClause(SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LetClause(Token(SyntaxKind.LetKeyword), identifier, Token(SyntaxKind.EqualsToken), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LetClauseSyntax LetClause(string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LetClause(Token(SyntaxKind.LetKeyword), Identifier(identifier), Token(SyntaxKind.EqualsToken), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax JoinClause(SyntaxToken joinKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, SyntaxToken identifier, SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax inExpression, SyntaxToken onKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftExpression, SyntaxToken equalsKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightExpression, Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax? into)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0057: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (joinKeyword.Kind() != SyntaxKind.JoinKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("joinKeyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (inKeyword.Kind() != SyntaxKind.InKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("inKeyword");
|
||
|
|
}
|
||
|
|
if (inExpression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("inExpression");
|
||
|
|
}
|
||
|
|
if (onKeyword.Kind() != SyntaxKind.OnKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("onKeyword");
|
||
|
|
}
|
||
|
|
if (leftExpression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("leftExpression");
|
||
|
|
}
|
||
|
|
if (equalsKeyword.Kind() != SyntaxKind.EqualsKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("equalsKeyword");
|
||
|
|
}
|
||
|
|
if (rightExpression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("rightExpression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.JoinClause((SyntaxToken)(object)((SyntaxToken)(ref joinKeyword)).Node, (type == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green), (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (SyntaxToken)(object)((SyntaxToken)(ref inKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)inExpression).Green, (SyntaxToken)(object)((SyntaxToken)(ref onKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)leftExpression).Green, (SyntaxToken)(object)((SyntaxToken)(ref equalsKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)rightExpression).Green, (into == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.JoinIntoClauseSyntax)(object)((SyntaxNode)into).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax JoinClause(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax inExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightExpression, Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax? into)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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)
|
||
|
|
return JoinClause(Token(SyntaxKind.JoinKeyword), type, identifier, Token(SyntaxKind.InKeyword), inExpression, Token(SyntaxKind.OnKeyword), leftExpression, Token(SyntaxKind.EqualsKeyword), rightExpression, into);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax JoinClause(SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax inExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightExpression)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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)
|
||
|
|
return JoinClause(Token(SyntaxKind.JoinKeyword), null, identifier, Token(SyntaxKind.InKeyword), inExpression, Token(SyntaxKind.OnKeyword), leftExpression, Token(SyntaxKind.EqualsKeyword), rightExpression, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.JoinClauseSyntax JoinClause(string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax inExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax leftExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax rightExpression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: 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_002c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return JoinClause(Token(SyntaxKind.JoinKeyword), null, Identifier(identifier), Token(SyntaxKind.InKeyword), inExpression, Token(SyntaxKind.OnKeyword), leftExpression, Token(SyntaxKind.EqualsKeyword), rightExpression, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax JoinIntoClause(SyntaxToken intoKeyword, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (intoKeyword.Kind() != SyntaxKind.IntoKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("intoKeyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.JoinIntoClause((SyntaxToken)(object)((SyntaxToken)(ref intoKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax JoinIntoClause(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return JoinIntoClause(Token(SyntaxKind.IntoKeyword), identifier);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.JoinIntoClauseSyntax JoinIntoClause(string identifier)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
return JoinIntoClause(Token(SyntaxKind.IntoKeyword), Identifier(identifier));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax WhereClause(SyntaxToken whereKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (whereKeyword.Kind() != SyntaxKind.WhereKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("whereKeyword");
|
||
|
|
}
|
||
|
|
if (condition == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("condition");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.WhereClause((SyntaxToken)(object)((SyntaxToken)(ref whereKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)condition).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WhereClauseSyntax WhereClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return WhereClause(Token(SyntaxKind.WhereKeyword), condition);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax OrderByClause(SyntaxToken orderByKeyword, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax> orderings)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (orderByKeyword.Kind() != SyntaxKind.OrderByKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("orderByKeyword");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.OrderByClause((SyntaxToken)(object)((SyntaxToken)(ref orderByKeyword)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.OrderingSyntax>(orderings.Node))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OrderByClauseSyntax OrderByClause(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax> orderings = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return OrderByClause(Token(SyntaxKind.OrderByKeyword), orderings);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax Ordering(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken ascendingOrDescendingKeyword)
|
||
|
|
{
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8782 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = ascendingOrDescendingKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind - 8432 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("ascendingOrDescendingKeyword");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Ordering(kind, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref ascendingOrDescendingKeyword)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OrderingSyntax Ordering(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Ordering(kind, expression, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetOrderingAscendingOrDescendingKeywordKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.AscendingOrdering => SyntaxKind.AscendingKeyword,
|
||
|
|
SyntaxKind.DescendingOrdering => SyntaxKind.DescendingKeyword,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax SelectClause(SyntaxToken selectKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (selectKeyword.Kind() != SyntaxKind.SelectKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("selectKeyword");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SelectClause((SyntaxToken)(object)((SyntaxToken)(ref selectKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SelectClauseSyntax SelectClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SelectClause(Token(SyntaxKind.SelectKeyword), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax GroupClause(SyntaxToken groupKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax groupExpression, SyntaxToken byKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax byExpression)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
if (groupKeyword.Kind() != SyntaxKind.GroupKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("groupKeyword");
|
||
|
|
}
|
||
|
|
if (groupExpression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("groupExpression");
|
||
|
|
}
|
||
|
|
if (byKeyword.Kind() != SyntaxKind.ByKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("byKeyword");
|
||
|
|
}
|
||
|
|
if (byExpression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("byExpression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.GroupClause((SyntaxToken)(object)((SyntaxToken)(ref groupKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)groupExpression).Green, (SyntaxToken)(object)((SyntaxToken)(ref byKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)byExpression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GroupClauseSyntax GroupClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax groupExpression, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax byExpression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return GroupClause(Token(SyntaxKind.GroupKeyword), groupExpression, Token(SyntaxKind.ByKeyword), byExpression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax QueryContinuation(SyntaxToken intoKeyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (intoKeyword.Kind() != SyntaxKind.IntoKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("intoKeyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (body == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("body");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.QueryContinuation((SyntaxToken)(object)((SyntaxToken)(ref intoKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.QueryBodySyntax)(object)((SyntaxNode)body).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax QueryContinuation(SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return QueryContinuation(Token(SyntaxKind.IntoKeyword), identifier, body);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.QueryContinuationSyntax QueryContinuation(string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.QueryBodySyntax body)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
return QueryContinuation(Token(SyntaxKind.IntoKeyword), Identifier(identifier), body);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax OmittedArraySizeExpression(SyntaxToken omittedArraySizeExpressionToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (omittedArraySizeExpressionToken.Kind() != SyntaxKind.OmittedArraySizeExpressionToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("omittedArraySizeExpressionToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.OmittedArraySizeExpression((SyntaxToken)(object)((SyntaxToken)(ref omittedArraySizeExpressionToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OmittedArraySizeExpressionSyntax OmittedArraySizeExpression()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return OmittedArraySizeExpression(Token(SyntaxKind.OmittedArraySizeExpressionToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax InterpolatedStringExpression(SyntaxToken stringStartToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax> contents, SyntaxToken stringEndToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0061: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = stringStartToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.InterpolatedStringStartToken && syntaxKind != SyntaxKind.InterpolatedVerbatimStringStartToken && syntaxKind - 9072 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("stringStartToken");
|
||
|
|
}
|
||
|
|
syntaxKind = stringEndToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.InterpolatedStringEndToken && syntaxKind != SyntaxKind.InterpolatedRawStringEndToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("stringEndToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.InterpolatedStringExpression((SyntaxToken)(object)((SyntaxToken)(ref stringStartToken)).Node, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.InterpolatedStringContentSyntax>(contents.Node), (SyntaxToken)(object)((SyntaxToken)(ref stringEndToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringExpressionSyntax InterpolatedStringExpression(SyntaxToken stringStartToken, SyntaxToken stringEndToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return InterpolatedStringExpression(stringStartToken, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringContentSyntax>), stringEndToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken isKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (isKeyword.Kind() != SyntaxKind.IsKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("isKeyword");
|
||
|
|
}
|
||
|
|
if (pattern == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("pattern");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.IsPatternExpression((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref isKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PatternSyntax)(object)((SyntaxNode)pattern).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax IsPatternExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IsPatternExpression(expression, Token(SyntaxKind.IsKeyword), pattern);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax ThrowExpression(SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (throwKeyword.Kind() != SyntaxKind.ThrowKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("throwKeyword");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ThrowExpression((SyntaxToken)(object)((SyntaxToken)(ref throwKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax ThrowExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ThrowExpression(Token(SyntaxKind.ThrowKeyword), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax WhenClause(SyntaxToken whenKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (whenKeyword.Kind() != SyntaxKind.WhenKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("whenKeyword");
|
||
|
|
}
|
||
|
|
if (condition == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("condition");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.WhenClause((SyntaxToken)(object)((SyntaxToken)(ref whenKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)condition).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax WhenClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return WhenClause(Token(SyntaxKind.WhenKeyword), condition);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax DiscardPattern(SyntaxToken underscoreToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (underscoreToken.Kind() != SyntaxKind.UnderscoreToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("underscoreToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DiscardPattern((SyntaxToken)(object)((SyntaxToken)(ref underscoreToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax DiscardPattern()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DiscardPattern(Token(SyntaxKind.UnderscoreToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax DeclarationPattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation)
|
||
|
|
{
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (designation == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("designation");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DeclarationPattern((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDesignationSyntax)(object)((SyntaxNode)designation).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax VarPattern(SyntaxToken varKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (varKeyword.Kind() != SyntaxKind.VarKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("varKeyword");
|
||
|
|
}
|
||
|
|
if (designation == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("designation");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.VarPattern((SyntaxToken)(object)((SyntaxToken)(ref varKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDesignationSyntax)(object)((SyntaxNode)designation).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax VarPattern(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax designation)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return VarPattern(Token(SyntaxKind.VarKeyword), designation);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax RecursivePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax? positionalPatternClause, Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax? propertyPatternClause, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation)
|
||
|
|
{
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.RecursivePattern((type == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green), (positionalPatternClause == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PositionalPatternClauseSyntax)(object)((SyntaxNode)positionalPatternClause).Green), (propertyPatternClause == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PropertyPatternClauseSyntax)(object)((SyntaxNode)propertyPatternClause).Green), (designation == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDesignationSyntax)(object)((SyntaxNode)designation).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax RecursivePattern()
|
||
|
|
{
|
||
|
|
return RecursivePattern(null, null, null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax PositionalPatternClause(SyntaxToken openParenToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PositionalPatternClause((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SubpatternSyntax>(subpatterns.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax PositionalPatternClause(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return PositionalPatternClause(Token(SyntaxKind.OpenParenToken), subpatterns, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax PropertyPatternClause(SyntaxToken openBraceToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns, SyntaxToken closeBraceToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBraceToken.Kind() != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
if (closeBraceToken.Kind() != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PropertyPatternClause((SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SubpatternSyntax>(subpatterns.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax PropertyPatternClause(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax> subpatterns = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return PropertyPatternClause(Token(SyntaxKind.OpenBraceToken), subpatterns, Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.BaseExpressionColonSyntax? expressionColon, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern)
|
||
|
|
{
|
||
|
|
if (pattern == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("pattern");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Subpattern((expressionColon == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BaseExpressionColonSyntax)(object)((SyntaxNode)expressionColon).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PatternSyntax)(object)((SyntaxNode)pattern).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax Subpattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern)
|
||
|
|
{
|
||
|
|
return Subpattern(null, pattern);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax ConstantPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ConstantPattern((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax ParenthesizedPattern(SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (pattern == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("pattern");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ParenthesizedPattern((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PatternSyntax)(object)((SyntaxNode)pattern).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax ParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ParenthesizedPattern(Token(SyntaxKind.OpenParenToken), pattern, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax RelationalPattern(SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
switch (operatorToken.Kind())
|
||
|
|
{
|
||
|
|
default:
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
case SyntaxKind.LessThanToken:
|
||
|
|
case SyntaxKind.GreaterThanToken:
|
||
|
|
case SyntaxKind.ExclamationEqualsToken:
|
||
|
|
case SyntaxKind.EqualsEqualsToken:
|
||
|
|
case SyntaxKind.LessThanEqualsToken:
|
||
|
|
case SyntaxKind.GreaterThanEqualsToken:
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.RelationalPattern((SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax TypePattern(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TypePattern((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax BinaryPattern(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax left, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax right)
|
||
|
|
{
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 9031 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (left == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("left");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = operatorToken.Kind();
|
||
|
|
if (syntaxKind - 8438 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
}
|
||
|
|
if (right == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("right");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.BinaryPattern(kind, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PatternSyntax)(object)((SyntaxNode)left).Green, (SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PatternSyntax)(object)((SyntaxNode)right).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax BinaryPattern(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax left, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax right)
|
||
|
|
{
|
||
|
|
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return BinaryPattern(kind, left, Token(GetBinaryPatternOperatorTokenKind(kind)), right);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetBinaryPatternOperatorTokenKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.OrPattern => SyntaxKind.OrKeyword,
|
||
|
|
SyntaxKind.AndPattern => SyntaxKind.AndKeyword,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax UnaryPattern(SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (operatorToken.Kind() != SyntaxKind.NotKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
}
|
||
|
|
if (pattern == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("pattern");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.UnaryPattern((SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PatternSyntax)(object)((SyntaxNode)pattern).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax UnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UnaryPattern(Token(SyntaxKind.NotKeyword), pattern);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax ListPattern(SyntaxToken openBracketToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax> patterns, SyntaxToken closeBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBracketToken");
|
||
|
|
}
|
||
|
|
if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBracketToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ListPattern((SyntaxToken)(object)((SyntaxToken)(ref openBracketToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PatternSyntax>(patterns.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBracketToken)).Node, (designation == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDesignationSyntax)(object)((SyntaxNode)designation).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax ListPattern(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax> patterns, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax? designation)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ListPattern(Token(SyntaxKind.OpenBracketToken), patterns, Token(SyntaxKind.CloseBracketToken), designation);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ListPatternSyntax ListPattern(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax> patterns = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ListPattern(Token(SyntaxKind.OpenBracketToken), patterns, Token(SyntaxKind.CloseBracketToken), null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax SlicePattern(SyntaxToken dotDotToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax? pattern)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (dotDotToken.Kind() != SyntaxKind.DotDotToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("dotDotToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SlicePattern((SyntaxToken)(object)((SyntaxToken)(ref dotDotToken)).Node, (pattern == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PatternSyntax)(object)((SyntaxNode)pattern).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SlicePatternSyntax SlicePattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax? pattern = null)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SlicePattern(Token(SyntaxKind.DotDotToken), pattern);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax InterpolatedStringText(SyntaxToken textToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (textToken.Kind() != SyntaxKind.InterpolatedStringTextToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("textToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.InterpolatedStringText((SyntaxToken)(object)((SyntaxToken)(ref textToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolatedStringTextSyntax InterpolatedStringText()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return InterpolatedStringText(Token(SyntaxKind.InterpolatedStringTextToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax Interpolation(SyntaxToken openBraceToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax? alignmentClause, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax? formatClause, SyntaxToken closeBraceToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
if (openBraceToken.Kind() != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (closeBraceToken.Kind() != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Interpolation((SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (alignmentClause == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.InterpolationAlignmentClauseSyntax)(object)((SyntaxNode)alignmentClause).Green), (formatClause == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.InterpolationFormatClauseSyntax)(object)((SyntaxNode)formatClause).Green), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax? alignmentClause, Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax? formatClause)
|
||
|
|
{
|
||
|
|
//IL_0005: 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 Interpolation(Token(SyntaxKind.OpenBraceToken), expression, alignmentClause, formatClause, Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationSyntax Interpolation(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: 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 Interpolation(Token(SyntaxKind.OpenBraceToken), expression, null, null, Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax InterpolationAlignmentClause(SyntaxToken commaToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value)
|
||
|
|
{
|
||
|
|
if (value == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("value");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationAlignmentClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.InterpolationAlignmentClause((SyntaxToken)(object)((SyntaxToken)(ref commaToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)value).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax InterpolationFormatClause(SyntaxToken colonToken, SyntaxToken formatStringToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (formatStringToken.Kind() != SyntaxKind.InterpolatedStringTextToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("formatStringToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.InterpolationFormatClause((SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref formatStringToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterpolationFormatClauseSyntax InterpolationFormatClause(SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
return InterpolationFormatClause(colonToken, Token(SyntaxKind.InterpolatedStringTextToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax GlobalStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0015: 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)
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.GlobalStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GlobalStatementSyntax GlobalStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return GlobalStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax Block(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements, SyntaxToken closeBraceToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_004f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBraceToken.Kind() != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
if (closeBraceToken.Kind() != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Block(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax>(statements.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax Block(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Block(attributeLists, Token(SyntaxKind.OpenBraceToken), statements, Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax Block(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements = default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax>))
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Block(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.OpenBraceToken), statements, Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_000e: 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_005a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (returnType == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("returnType");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (parameterList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameterList");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LocalFunctionStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)returnType).Green, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (typeParameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterListSyntax)(object)((SyntaxNode)typeParameterList).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterConstraintClauseSyntax>(constraintClauses.Node), (body == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)body).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrowExpressionClauseSyntax)(object)((SyntaxNode)expressionBody).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: 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)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LocalFunctionStatement(attributeLists, modifiers, returnType, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0025: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002b: 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_0036: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LocalFunctionStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), returnType, identifier, null, ParameterList(), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax LocalFunctionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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)
|
||
|
|
//IL_001c: 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_002a: 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_003b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LocalFunctionStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), returnType, Identifier(identifier), null, ParameterList(), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken awaitKeyword, SyntaxToken usingKeyword, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0049: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = awaitKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.AwaitKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("awaitKeyword");
|
||
|
|
}
|
||
|
|
syntaxKind = usingKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.UsingKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("usingKeyword");
|
||
|
|
}
|
||
|
|
if (declaration == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("declaration");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LocalDeclarationStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref awaitKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref usingKeyword)).Node, GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDeclarationSyntax)(object)((SyntaxNode)declaration).Green, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LocalDeclarationStatement(attributeLists, default(SyntaxToken), default(SyntaxToken), modifiers, declaration, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LocalDeclarationStatementSyntax LocalDeclarationStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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)
|
||
|
|
//IL_001a: 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_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LocalDeclarationStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxToken), default(SyntaxToken), default(SyntaxTokenList), declaration, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax> variables)
|
||
|
|
{
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.VariableDeclaration((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDeclaratorSyntax>(variables.Node))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax VariableDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return VariableDeclaration(type, default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax>));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax VariableDeclarator(SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedArgumentListSyntax? argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? initializer)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.VariableDeclarator((SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (argumentList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BracketedArgumentListSyntax)(object)((SyntaxNode)argumentList).Green), (initializer == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.EqualsValueClauseSyntax)(object)((SyntaxNode)initializer).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax VariableDeclarator(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return VariableDeclarator(identifier, null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax VariableDeclarator(string identifier)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return VariableDeclarator(Identifier(identifier), null, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax EqualsValueClause(SyntaxToken equalsToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (equalsToken.Kind() != SyntaxKind.EqualsToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("equalsToken");
|
||
|
|
}
|
||
|
|
if (value == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("value");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EqualsValueClause((SyntaxToken)(object)((SyntaxToken)(ref equalsToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)value).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax EqualsValueClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EqualsValueClause(Token(SyntaxKind.EqualsToken), value);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax SingleVariableDesignation(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SingleVariableDesignation((SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax DiscardDesignation(SyntaxToken underscoreToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (underscoreToken.Kind() != SyntaxKind.UnderscoreToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("underscoreToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DiscardDesignation((SyntaxToken)(object)((SyntaxToken)(ref underscoreToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax DiscardDesignation()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DiscardDesignation(Token(SyntaxKind.UnderscoreToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax ParenthesizedVariableDesignation(SyntaxToken openParenToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax> variables, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ParenthesizedVariableDesignation((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDesignationSyntax>(variables.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax ParenthesizedVariableDesignation(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax> variables = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ParenthesizedVariableDesignation(Token(SyntaxKind.OpenParenToken), variables, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax ExpressionStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_000e: 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)
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ExpressionStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax ExpressionStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ExpressionStatement(attributeLists, expression, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionStatementSyntax ExpressionStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ExpressionStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), expression, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax EmptyStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EmptyStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax EmptyStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
return EmptyStatement(attributeLists, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EmptyStatementSyntax EmptyStatement()
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EmptyStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax LabeledStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken identifier, SyntaxToken colonToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LabeledStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax LabeledStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LabeledStatement(attributeLists, identifier, Token(SyntaxKind.ColonToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax LabeledStatement(SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LabeledStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), identifier, Token(SyntaxKind.ColonToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LabeledStatementSyntax LabeledStatement(string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000a: 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 LabeledStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Identifier(identifier), Token(SyntaxKind.ColonToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax GotoStatement(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken gotoKeyword, SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0015: 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_004c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8800 > (SyntaxKind)2)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (gotoKeyword.Kind() != SyntaxKind.GotoKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("gotoKeyword");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = caseOrDefaultKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind - 8332 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("caseOrDefaultKeyword");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.GotoStatement(kind, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref gotoKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref caseOrDefaultKeyword)).Node, (expression == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax GotoStatement(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken caseOrDefaultKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return GotoStatement(kind, attributeLists, Token(SyntaxKind.GotoKeyword), caseOrDefaultKeyword, expression, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.GotoStatementSyntax GotoStatement(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression = null)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return GotoStatement(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.GotoKeyword), default(SyntaxToken), expression, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax BreakStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken breakKeyword, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (breakKeyword.Kind() != SyntaxKind.BreakKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("breakKeyword");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.BreakStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref breakKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax BreakStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return BreakStatement(attributeLists, Token(SyntaxKind.BreakKeyword), Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BreakStatementSyntax BreakStatement()
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return BreakStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.BreakKeyword), Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax ContinueStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken continueKeyword, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (continueKeyword.Kind() != SyntaxKind.ContinueKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("continueKeyword");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ContinueStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref continueKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax ContinueStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ContinueStatement(attributeLists, Token(SyntaxKind.ContinueKeyword), Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ContinueStatementSyntax ContinueStatement()
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ContinueStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.ContinueKeyword), Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax ReturnStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken returnKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (returnKeyword.Kind() != SyntaxKind.ReturnKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("returnKeyword");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ReturnStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref returnKeyword)).Node, (expression == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax ReturnStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ReturnStatement(attributeLists, Token(SyntaxKind.ReturnKeyword), expression, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ReturnStatementSyntax ReturnStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression = null)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ReturnStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.ReturnKeyword), expression, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax ThrowStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken throwKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (throwKeyword.Kind() != SyntaxKind.ThrowKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("throwKeyword");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ThrowStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref throwKeyword)).Node, (expression == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax ThrowStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ThrowStatement(attributeLists, Token(SyntaxKind.ThrowKeyword), expression, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ThrowStatementSyntax ThrowStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression = null)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ThrowStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.ThrowKeyword), expression, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax YieldStatement(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken yieldKeyword, SyntaxToken returnOrBreakKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0015: 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_004f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8806 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (yieldKeyword.Kind() != SyntaxKind.YieldKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("yieldKeyword");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = returnOrBreakKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.BreakKeyword && syntaxKind != SyntaxKind.ReturnKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("returnOrBreakKeyword");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.YieldStatement(kind, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref yieldKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref returnOrBreakKeyword)).Node, (expression == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax YieldStatement(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: 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)
|
||
|
|
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return YieldStatement(kind, attributeLists, Token(SyntaxKind.YieldKeyword), Token(GetYieldStatementReturnOrBreakKeywordKind(kind)), expression, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.YieldStatementSyntax YieldStatement(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression = null)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: 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)
|
||
|
|
return YieldStatement(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.YieldKeyword), Token(GetYieldStatementReturnOrBreakKeywordKind(kind)), expression, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetYieldStatementReturnOrBreakKeywordKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.YieldReturnStatement => SyntaxKind.ReturnKeyword,
|
||
|
|
SyntaxKind.YieldBreakStatement => SyntaxKind.BreakKeyword,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax WhileStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken whileKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (whileKeyword.Kind() != SyntaxKind.WhileKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("whileKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (condition == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("condition");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.WhileStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref whileKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)condition).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax WhileStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return WhileStatement(attributeLists, Token(SyntaxKind.WhileKeyword), Token(SyntaxKind.OpenParenToken), condition, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WhileStatementSyntax WhileStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return WhileStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.WhileKeyword), Token(SyntaxKind.OpenParenToken), condition, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax DoStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken doKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, SyntaxToken whileKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, SyntaxToken closeParenToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (doKeyword.Kind() != SyntaxKind.DoKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("doKeyword");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
if (whileKeyword.Kind() != SyntaxKind.WhileKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("whileKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (condition == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("condition");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DoStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref doKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green, (SyntaxToken)(object)((SyntaxToken)(ref whileKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)condition).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax DoStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: 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)
|
||
|
|
return DoStatement(attributeLists, Token(SyntaxKind.DoKeyword), statement, Token(SyntaxKind.WhileKeyword), Token(SyntaxKind.OpenParenToken), condition, Token(SyntaxKind.CloseParenToken), Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DoStatementSyntax DoStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: 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_0038: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DoStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.DoKeyword), statement, Token(SyntaxKind.WhileKeyword), Token(SyntaxKind.OpenParenToken), condition, Token(SyntaxKind.CloseParenToken), Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax ForStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken forKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers, SyntaxToken firstSemicolonToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition, SyntaxToken secondSemicolonToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0049: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00c6: 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)
|
||
|
|
if (forKeyword.Kind() != SyntaxKind.ForKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("forKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (firstSemicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("firstSemicolonToken");
|
||
|
|
}
|
||
|
|
if (secondSemicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("secondSemicolonToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ForStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref forKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (declaration == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDeclarationSyntax)(object)((SyntaxNode)declaration).Green), GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax>(initializers.Node), (SyntaxToken)(object)((SyntaxToken)(ref firstSemicolonToken)).Node, (condition == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)condition).Green), (SyntaxToken)(object)((SyntaxToken)(ref secondSemicolonToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax>(incrementors.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax ForStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> initializers, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? condition, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> incrementors, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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_0033: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForStatement(attributeLists, Token(SyntaxKind.ForKeyword), Token(SyntaxKind.OpenParenToken), declaration, initializers, Token(SyntaxKind.SemicolonToken), condition, Token(SyntaxKind.SemicolonToken), incrementors, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForStatementSyntax ForStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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_002c: 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_003e: 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_004a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.ForKeyword), Token(SyntaxKind.OpenParenToken), null, default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>), Token(SyntaxKind.SemicolonToken), null, Token(SyntaxKind.SemicolonToken), default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>), Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax ForEachStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken awaitKeyword, SyntaxToken forEachKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken identifier, SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0035: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = awaitKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.AwaitKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("awaitKeyword");
|
||
|
|
}
|
||
|
|
if (forEachKeyword.Kind() != SyntaxKind.ForEachKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("forEachKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (inKeyword.Kind() != SyntaxKind.InKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("inKeyword");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ForEachStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref awaitKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref forEachKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (SyntaxToken)(object)((SyntaxToken)(ref inKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax ForEachStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: 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)
|
||
|
|
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForEachStatement(attributeLists, default(SyntaxToken), Token(SyntaxKind.ForEachKeyword), Token(SyntaxKind.OpenParenToken), type, identifier, Token(SyntaxKind.InKeyword), expression, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0027: 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_0038: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForEachStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxToken), Token(SyntaxKind.ForEachKeyword), Token(SyntaxKind.OpenParenToken), type, identifier, Token(SyntaxKind.InKeyword), expression, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax ForEachStatement(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, string identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0028: 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_003d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForEachStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxToken), Token(SyntaxKind.ForEachKeyword), Token(SyntaxKind.OpenParenToken), type, Identifier(identifier), Token(SyntaxKind.InKeyword), expression, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax ForEachVariableStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken awaitKeyword, SyntaxToken forEachKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, SyntaxToken inKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0035: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = awaitKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.AwaitKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("awaitKeyword");
|
||
|
|
}
|
||
|
|
if (forEachKeyword.Kind() != SyntaxKind.ForEachKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("forEachKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (variable == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("variable");
|
||
|
|
}
|
||
|
|
if (inKeyword.Kind() != SyntaxKind.InKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("inKeyword");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ForEachVariableStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref awaitKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref forEachKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)variable).Green, (SyntaxToken)(object)((SyntaxToken)(ref inKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax ForEachVariableStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ForEachVariableStatement(attributeLists, default(SyntaxToken), Token(SyntaxKind.ForEachKeyword), Token(SyntaxKind.OpenParenToken), variable, Token(SyntaxKind.InKeyword), expression, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax ForEachVariableStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax variable, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_002c: 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)
|
||
|
|
return ForEachVariableStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxToken), Token(SyntaxKind.ForEachKeyword), Token(SyntaxKind.OpenParenToken), variable, Token(SyntaxKind.InKeyword), expression, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax UsingStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken awaitKeyword, SyntaxToken usingKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0035: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = awaitKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.AwaitKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("awaitKeyword");
|
||
|
|
}
|
||
|
|
if (usingKeyword.Kind() != SyntaxKind.UsingKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("usingKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.UsingStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref awaitKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref usingKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (declaration == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDeclarationSyntax)(object)((SyntaxNode)declaration).Green), (expression == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green), (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax UsingStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax? expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: 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)
|
||
|
|
return UsingStatement(attributeLists, default(SyntaxToken), Token(SyntaxKind.UsingKeyword), Token(SyntaxKind.OpenParenToken), declaration, expression, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingStatementSyntax UsingStatement(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_002d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UsingStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxToken), Token(SyntaxKind.UsingKeyword), Token(SyntaxKind.OpenParenToken), null, null, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax FixedStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken fixedKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (fixedKeyword.Kind() != SyntaxKind.FixedKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("fixedKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (declaration == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("declaration");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FixedStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref fixedKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDeclarationSyntax)(object)((SyntaxNode)declaration).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax FixedStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FixedStatement(attributeLists, Token(SyntaxKind.FixedKeyword), Token(SyntaxKind.OpenParenToken), declaration, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FixedStatementSyntax FixedStatement(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FixedStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.FixedKeyword), Token(SyntaxKind.OpenParenToken), declaration, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax CheckedStatement(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8815 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = keyword.Kind();
|
||
|
|
if (syntaxKind - 8379 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (block == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("block");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CheckedStatement(kind, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)block).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax CheckedStatement(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block)
|
||
|
|
{
|
||
|
|
//IL_0001: 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 CheckedStatement(kind, attributeLists, Token(GetCheckedStatementKeywordKind(kind)), block);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CheckedStatementSyntax CheckedStatement(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block = null)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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 CheckedStatement(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(GetCheckedStatementKeywordKind(kind)), block ?? Block());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetCheckedStatementKeywordKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.CheckedStatement => SyntaxKind.CheckedKeyword,
|
||
|
|
SyntaxKind.UncheckedStatement => SyntaxKind.UncheckedKeyword,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax UnsafeStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
if (unsafeKeyword.Kind() != SyntaxKind.UnsafeKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("unsafeKeyword");
|
||
|
|
}
|
||
|
|
if (block == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("block");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.UnsafeStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref unsafeKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)block).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax UnsafeStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
return UnsafeStatement(attributeLists, Token(SyntaxKind.UnsafeKeyword), block);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax UnsafeStatement(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block = null)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UnsafeStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.UnsafeKeyword), block ?? Block());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax LockStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken lockKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (lockKeyword.Kind() != SyntaxKind.LockKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("lockKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LockStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref lockKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax LockStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LockStatement(attributeLists, Token(SyntaxKind.LockKeyword), Token(SyntaxKind.OpenParenToken), expression, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LockStatementSyntax LockStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LockStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.LockKeyword), Token(SyntaxKind.OpenParenToken), expression, Token(SyntaxKind.CloseParenToken), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax IfStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken ifKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, SyntaxToken closeParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? @else)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (ifKeyword.Kind() != SyntaxKind.IfKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("ifKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (condition == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("condition");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.IfStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref ifKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)condition).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green, (@else == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ElseClauseSyntax)(object)((SyntaxNode)@else).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax IfStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement, Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax? @else)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IfStatement(attributeLists, Token(SyntaxKind.IfKeyword), Token(SyntaxKind.OpenParenToken), condition, Token(SyntaxKind.CloseParenToken), statement, @else);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IfStatementSyntax IfStatement(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IfStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.IfKeyword), Token(SyntaxKind.OpenParenToken), condition, Token(SyntaxKind.CloseParenToken), statement, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax ElseClause(SyntaxToken elseKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (elseKeyword.Kind() != SyntaxKind.ElseKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("elseKeyword");
|
||
|
|
}
|
||
|
|
if (statement == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("statement");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElseClause((SyntaxToken)(object)((SyntaxToken)(ref elseKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax)(object)((SyntaxNode)statement).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ElseClauseSyntax ElseClause(Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax statement)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ElseClause(Token(SyntaxKind.ElseKeyword), statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax SwitchStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken switchKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, SyntaxToken closeParenToken, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax> sections, SyntaxToken closeBraceToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: 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_007a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (switchKeyword.Kind() != SyntaxKind.SwitchKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("switchKeyword");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = openParenToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
syntaxKind = closeParenToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
if (openBraceToken.Kind() != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
if (closeBraceToken.Kind() != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SwitchStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SwitchStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref switchKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SwitchSectionSyntax>(sections.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax SwitchSection(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax> labels, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax> statements)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SwitchSection(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SwitchLabelSyntax>(labels.Node), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.StatementSyntax>(statements.Node))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchSectionSyntax SwitchSection()
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SwitchSection(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchLabelSyntax>), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.StatementSyntax>));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax CasePatternSwitchLabel(SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause, SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
if (keyword.Kind() != SyntaxKind.CaseKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (pattern == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("pattern");
|
||
|
|
}
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CasePatternSwitchLabel((SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PatternSyntax)(object)((SyntaxNode)pattern).Green, (whenClause == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.WhenClauseSyntax)(object)((SyntaxNode)whenClause).Green), (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause, SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CasePatternSwitchLabel(Token(SyntaxKind.CaseKeyword), pattern, whenClause, colonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax CasePatternSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CasePatternSwitchLabel(Token(SyntaxKind.CaseKeyword), pattern, null, colonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax CaseSwitchLabel(SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value, SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
if (keyword.Kind() != SyntaxKind.CaseKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (value == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("value");
|
||
|
|
}
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CaseSwitchLabel((SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)value).Green, (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CaseSwitchLabelSyntax CaseSwitchLabel(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax value, SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
return CaseSwitchLabel(Token(SyntaxKind.CaseKeyword), value, colonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax DefaultSwitchLabel(SyntaxToken keyword, SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (keyword.Kind() != SyntaxKind.DefaultKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DefaultSwitchLabel((SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DefaultSwitchLabelSyntax DefaultSwitchLabel(SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DefaultSwitchLabel(Token(SyntaxKind.DefaultKeyword), colonToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax governingExpression, SyntaxToken switchKeyword, SyntaxToken openBraceToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax> arms, SyntaxToken closeBraceToken)
|
||
|
|
{
|
||
|
|
//IL_000e: 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_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (governingExpression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("governingExpression");
|
||
|
|
}
|
||
|
|
if (switchKeyword.Kind() != SyntaxKind.SwitchKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("switchKeyword");
|
||
|
|
}
|
||
|
|
if (openBraceToken.Kind() != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
if (closeBraceToken.Kind() != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SwitchExpression((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)governingExpression).Green, (SyntaxToken)(object)((SyntaxToken)(ref switchKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SwitchExpressionArmSyntax>(arms.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax governingExpression, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax> arms)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SwitchExpression(governingExpression, Token(SyntaxKind.SwitchKeyword), Token(SyntaxKind.OpenBraceToken), arms, Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax SwitchExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax governingExpression)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SwitchExpression(governingExpression, Token(SyntaxKind.SwitchKeyword), Token(SyntaxKind.OpenBraceToken), default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax>), Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause, SyntaxToken equalsGreaterThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (pattern == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("pattern");
|
||
|
|
}
|
||
|
|
if (equalsGreaterThanToken.Kind() != SyntaxKind.EqualsGreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("equalsGreaterThanToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SwitchExpressionArm((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.PatternSyntax)(object)((SyntaxNode)pattern).Green, (whenClause == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.WhenClauseSyntax)(object)((SyntaxNode)whenClause).Green), (SyntaxToken)(object)((SyntaxToken)(ref equalsGreaterThanToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax? whenClause, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SwitchExpressionArm(pattern, whenClause, Token(SyntaxKind.EqualsGreaterThanToken), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax SwitchExpressionArm(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return SwitchExpressionArm(pattern, null, Token(SyntaxKind.EqualsGreaterThanToken), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax TryStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax? @finally)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0050: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (tryKeyword.Kind() != SyntaxKind.TryKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("tryKeyword");
|
||
|
|
}
|
||
|
|
if (block == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("block");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TryStatement(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref tryKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)block).Green, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CatchClauseSyntax>(catches.Node), (@finally == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.FinallyClauseSyntax)(object)((SyntaxNode)@finally).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax TryStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax? @finally)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TryStatement(attributeLists, Token(SyntaxKind.TryKeyword), block, catches, @finally);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax TryStatement(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches = default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax>))
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: 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)
|
||
|
|
return TryStatement(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), Token(SyntaxKind.TryKeyword), Block(), catches, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax CatchClause(SyntaxToken catchKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax? filter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (catchKeyword.Kind() != SyntaxKind.CatchKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("catchKeyword");
|
||
|
|
}
|
||
|
|
if (block == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("block");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CatchClause((SyntaxToken)(object)((SyntaxToken)(ref catchKeyword)).Node, (declaration == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CatchDeclarationSyntax)(object)((SyntaxNode)declaration).Green), (filter == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CatchFilterClauseSyntax)(object)((SyntaxNode)filter).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)block).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax CatchClause(Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax? declaration, Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax? filter, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CatchClause(Token(SyntaxKind.CatchKeyword), declaration, filter, block);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax CatchClause()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: 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 CatchClause(Token(SyntaxKind.CatchKeyword), null, null, Block());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax CatchDeclaration(SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken identifier, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = identifier.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CatchDeclaration((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CatchDeclaration(Token(SyntaxKind.OpenParenToken), type, identifier, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CatchDeclarationSyntax CatchDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CatchDeclaration(Token(SyntaxKind.OpenParenToken), type, default(SyntaxToken), Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax CatchFilterClause(SyntaxToken whenKeyword, SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax filterExpression, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (whenKeyword.Kind() != SyntaxKind.WhenKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("whenKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (filterExpression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("filterExpression");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CatchFilterClause((SyntaxToken)(object)((SyntaxToken)(ref whenKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)filterExpression).Green, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CatchFilterClauseSyntax CatchFilterClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax filterExpression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CatchFilterClause(Token(SyntaxKind.WhenKeyword), Token(SyntaxKind.OpenParenToken), filterExpression, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax FinallyClause(SyntaxToken finallyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (finallyKeyword.Kind() != SyntaxKind.FinallyKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("finallyKeyword");
|
||
|
|
}
|
||
|
|
if (block == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("block");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FinallyClause((SyntaxToken)(object)((SyntaxToken)(ref finallyKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)block).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax FinallyClause(Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? block = null)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FinallyClause(Token(SyntaxKind.FinallyKeyword), block ?? Block());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax CompilationUnit(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken endOfFileToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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_0038: 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)
|
||
|
|
if (endOfFileToken.Kind() != SyntaxKind.EndOfFileToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfFileToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CompilationUnit(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExternAliasDirectiveSyntax>(externs.Node), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.UsingDirectiveSyntax>(usings.Node), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.MemberDeclarationSyntax>(members.Node), (SyntaxToken)(object)((SyntaxToken)(ref endOfFileToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax CompilationUnit(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CompilationUnit(externs, usings, attributeLists, members, Token(SyntaxKind.EndOfFileToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax CompilationUnit()
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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)
|
||
|
|
//IL_001a: 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_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CompilationUnit(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax>), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax>), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), Token(SyntaxKind.EndOfFileToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax ExternAliasDirective(SyntaxToken externKeyword, SyntaxToken aliasKeyword, SyntaxToken identifier, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (externKeyword.Kind() != SyntaxKind.ExternKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("externKeyword");
|
||
|
|
}
|
||
|
|
if (aliasKeyword.Kind() != SyntaxKind.AliasKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("aliasKeyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ExternAliasDirective((SyntaxToken)(object)((SyntaxToken)(ref externKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref aliasKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax ExternAliasDirective(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ExternAliasDirective(Token(SyntaxKind.ExternKeyword), Token(SyntaxKind.AliasKeyword), identifier, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax ExternAliasDirective(string identifier)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ExternAliasDirective(Token(SyntaxKind.ExternKeyword), Token(SyntaxKind.AliasKeyword), Identifier(identifier), Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax UsingDirective(SyntaxToken globalKeyword, SyntaxToken usingKeyword, SyntaxToken staticKeyword, SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax namespaceOrType, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0035: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = globalKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.GlobalKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("globalKeyword");
|
||
|
|
}
|
||
|
|
if (usingKeyword.Kind() != SyntaxKind.UsingKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("usingKeyword");
|
||
|
|
}
|
||
|
|
syntaxKind = staticKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.StaticKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("staticKeyword");
|
||
|
|
}
|
||
|
|
syntaxKind = unsafeKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.UnsafeKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("unsafeKeyword");
|
||
|
|
}
|
||
|
|
if (namespaceOrType == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("namespaceOrType");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.UsingDirective((SyntaxToken)(object)((SyntaxToken)(ref globalKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref usingKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref staticKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref unsafeKeyword)).Node, (alias == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameEqualsSyntax)(object)((SyntaxNode)alias).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)namespaceOrType).Green, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? alias, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax namespaceOrType)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0024: 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)
|
||
|
|
return UsingDirective(default(SyntaxToken), Token(SyntaxKind.UsingKeyword), default(SyntaxToken), default(SyntaxToken), alias, namespaceOrType, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax UsingDirective(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax namespaceOrType)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0024: 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)
|
||
|
|
return UsingDirective(default(SyntaxToken), Token(SyntaxKind.UsingKeyword), default(SyntaxToken), default(SyntaxToken), null, namespaceOrType, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax NamespaceDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_003f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0089: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (namespaceKeyword.Kind() != SyntaxKind.NamespaceKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("namespaceKeyword");
|
||
|
|
}
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (openBraceToken.Kind() != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
if (closeBraceToken.Kind() != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.NamespaceDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref namespaceKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameSyntax)(object)((SyntaxNode)name).Green, (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExternAliasDirectiveSyntax>(externs.Node), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.UsingDirectiveSyntax>(usings.Node), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.MemberDeclarationSyntax>(members.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax NamespaceDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: 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)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: 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_0028: 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)
|
||
|
|
return NamespaceDeclaration(attributeLists, modifiers, Token(SyntaxKind.NamespaceKeyword), name, Token(SyntaxKind.OpenBraceToken), externs, usings, members, Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NamespaceDeclarationSyntax NamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0029: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002f: 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_0038: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return NamespaceDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.NamespaceKeyword), name, Token(SyntaxKind.OpenBraceToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax>), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax>), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), Token(SyntaxKind.CloseBraceToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax FileScopedNamespaceDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken namespaceKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, SyntaxToken semicolonToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0046: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (namespaceKeyword.Kind() != SyntaxKind.NamespaceKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("namespaceKeyword");
|
||
|
|
}
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FileScopedNamespaceDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref namespaceKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameSyntax)(object)((SyntaxNode)name).Green, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExternAliasDirectiveSyntax>(externs.Node), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.UsingDirectiveSyntax>(usings.Node), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.MemberDeclarationSyntax>(members.Node))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax FileScopedNamespaceDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax> externs, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax> usings, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: 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)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FileScopedNamespaceDeclaration(attributeLists, modifiers, Token(SyntaxKind.NamespaceKeyword), name, Token(SyntaxKind.SemicolonToken), externs, usings, members);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FileScopedNamespaceDeclarationSyntax FileScopedNamespaceDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0029: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002f: 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_0038: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FileScopedNamespaceDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.NamespaceKeyword), name, Token(SyntaxKind.SemicolonToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExternAliasDirectiveSyntax>), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax>), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax AttributeList(SyntaxToken openBracketToken, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax? target, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax> attributes, SyntaxToken closeBracketToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBracketToken");
|
||
|
|
}
|
||
|
|
if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBracketToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AttributeList((SyntaxToken)(object)((SyntaxToken)(ref openBracketToken)).Node, (target == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeTargetSpecifierSyntax)(object)((SyntaxNode)target).Green), GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeSyntax>(attributes.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBracketToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax AttributeList(Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax? target, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax> attributes)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AttributeList(Token(SyntaxKind.OpenBracketToken), target, attributes, Token(SyntaxKind.CloseBracketToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax AttributeList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax> attributes = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AttributeList(Token(SyntaxKind.OpenBracketToken), null, attributes, Token(SyntaxKind.CloseBracketToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax AttributeTargetSpecifier(SyntaxToken identifier, SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AttributeTargetSpecifier((SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeTargetSpecifierSyntax AttributeTargetSpecifier(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
return AttributeTargetSpecifier(identifier, Token(SyntaxKind.ColonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax? argumentList)
|
||
|
|
{
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Attribute((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameSyntax)(object)((SyntaxNode)name).Green, (argumentList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeArgumentListSyntax)(object)((SyntaxNode)argumentList).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeSyntax Attribute(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name)
|
||
|
|
{
|
||
|
|
return Attribute(name, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax AttributeArgumentList(SyntaxToken openParenToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax> arguments, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AttributeArgumentList((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeArgumentSyntax>(arguments.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentListSyntax AttributeArgumentList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax> arguments = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AttributeArgumentList(Token(SyntaxKind.OpenParenToken), arguments, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax? nameEquals, Microsoft.CodeAnalysis.CSharp.Syntax.NameColonSyntax? nameColon, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AttributeArgument((nameEquals == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameEqualsSyntax)(object)((SyntaxNode)nameEquals).Green), (nameColon == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameColonSyntax)(object)((SyntaxNode)nameColon).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AttributeArgumentSyntax AttributeArgument(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
return AttributeArgument(null, null, expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, SyntaxToken equalsToken)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (equalsToken.Kind() != SyntaxKind.EqualsToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("equalsToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.NameEquals((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.IdentifierNameSyntax)(object)((SyntaxNode)name).Green, (SyntaxToken)(object)((SyntaxToken)(ref equalsToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax NameEquals(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return NameEquals(name, Token(SyntaxKind.EqualsToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NameEqualsSyntax NameEquals(string name)
|
||
|
|
{
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return NameEquals(IdentifierName(name), Token(SyntaxKind.EqualsToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax TypeParameterList(SyntaxToken lessThanToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax> parameters, SyntaxToken greaterThanToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (lessThanToken.Kind() != SyntaxKind.LessThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("lessThanToken");
|
||
|
|
}
|
||
|
|
if (greaterThanToken.Kind() != SyntaxKind.GreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("greaterThanToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TypeParameterList((SyntaxToken)(object)((SyntaxToken)(ref lessThanToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterSyntax>(parameters.Node), (SyntaxToken)(object)((SyntaxToken)(ref greaterThanToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax TypeParameterList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax> parameters = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TypeParameterList(Token(SyntaxKind.LessThanToken), parameters, Token(SyntaxKind.GreaterThanToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax TypeParameter(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxToken varianceKeyword, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = varianceKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind - 8361 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("varianceKeyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TypeParameter(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), (SyntaxToken)(object)((SyntaxToken)(ref varianceKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax TypeParameter(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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 TypeParameter(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxToken), identifier);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterSyntax TypeParameter(string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TypeParameter(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxToken), Identifier(identifier));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax ClassDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_004e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (keyword.Kind() != SyntaxKind.ClassKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = openBraceToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
syntaxKind = closeBraceToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ClassDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (typeParameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterListSyntax)(object)((SyntaxNode)typeParameterList).Green), (parameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green), (baseList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BaseListSyntax)(object)((SyntaxNode)baseList).Green), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterConstraintClauseSyntax>(constraintClauses.Node), (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.MemberDeclarationSyntax>(members.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax StructDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_004e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (keyword.Kind() != SyntaxKind.StructKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = openBraceToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
syntaxKind = closeBraceToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.StructDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (typeParameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterListSyntax)(object)((SyntaxNode)typeParameterList).Green), (parameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green), (baseList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BaseListSyntax)(object)((SyntaxNode)baseList).Green), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterConstraintClauseSyntax>(constraintClauses.Node), (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.MemberDeclarationSyntax>(members.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax InterfaceDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_004e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (keyword.Kind() != SyntaxKind.InterfaceKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = openBraceToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
syntaxKind = closeBraceToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.InterfaceDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.InterfaceDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (typeParameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterListSyntax)(object)((SyntaxNode)typeParameterList).Green), (parameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green), (baseList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BaseListSyntax)(object)((SyntaxNode)baseList).Green), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterConstraintClauseSyntax>(constraintClauses.Node), (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.MemberDeclarationSyntax>(members.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax RecordDeclaration(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken classOrStructKeyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind != SyntaxKind.RecordDeclaration && kind != SyntaxKind.RecordStructDeclaration)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = classOrStructKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind - 8374 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("classOrStructKeyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
syntaxKind = openBraceToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
syntaxKind = closeBraceToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.RecordDeclaration(kind, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref classOrStructKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (typeParameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterListSyntax)(object)((SyntaxNode)typeParameterList).Green), (parameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green), (baseList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BaseListSyntax)(object)((SyntaxNode)baseList).Green), GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterConstraintClauseSyntax>(constraintClauses.Node), (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.MemberDeclarationSyntax>(members.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax RecordDeclaration(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax? parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax> members)
|
||
|
|
{
|
||
|
|
//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_0003: 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_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002a: 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_0033: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return RecordDeclaration(kind, attributeLists, modifiers, keyword, default(SyntaxToken), identifier, typeParameterList, parameterList, baseList, constraintClauses, default(SyntaxToken), members, default(SyntaxToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax RecordDeclaration(SyntaxKind kind, SyntaxToken keyword, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0029: 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_0032: 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_003b: 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_0045: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0048: 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)
|
||
|
|
return RecordDeclaration(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), keyword, default(SyntaxToken), identifier, null, null, null, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), default(SyntaxToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), default(SyntaxToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax RecordDeclaration(SyntaxKind kind, SyntaxToken keyword, string identifier)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: 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)
|
||
|
|
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0031: 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_003a: 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_0044: 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)
|
||
|
|
//IL_004d: 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)
|
||
|
|
return RecordDeclaration(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), keyword, default(SyntaxToken), Identifier(identifier), null, null, null, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), default(SyntaxToken), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.MemberDeclarationSyntax>), default(SyntaxToken), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetRecordDeclarationClassOrStructKeywordKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.RecordDeclaration => SyntaxKind.ClassKeyword,
|
||
|
|
SyntaxKind.RecordStructDeclaration => SyntaxKind.StructKeyword,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax EnumDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken enumKeyword, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax? baseList, SyntaxToken openBraceToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_004e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (enumKeyword.Kind() != SyntaxKind.EnumKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("enumKeyword");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = openBraceToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
syntaxKind = closeBraceToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.EnumDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EnumDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref enumKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (baseList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BaseListSyntax)(object)((SyntaxNode)baseList).Green), (SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.EnumMemberDeclarationSyntax>(members.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax DelegateDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_004e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (delegateKeyword.Kind() != SyntaxKind.DelegateKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("delegateKeyword");
|
||
|
|
}
|
||
|
|
if (returnType == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("returnType");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (parameterList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameterList");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DelegateDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref delegateKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)returnType).Green, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (typeParameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterListSyntax)(object)((SyntaxNode)typeParameterList).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterConstraintClauseSyntax>(constraintClauses.Node), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax DelegateDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: 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)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DelegateDeclaration(attributeLists, modifiers, Token(SyntaxKind.DelegateKeyword), returnType, identifier, typeParameterList, parameterList, constraintClauses, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0021: 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_002f: 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_003b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DelegateDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.DelegateKeyword), returnType, identifier, null, ParameterList(), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DelegateDeclarationSyntax DelegateDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: 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_002c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003a: 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)
|
||
|
|
return DelegateDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.DelegateKeyword), returnType, Identifier(identifier), null, ParameterList(), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax EnumMemberDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? equalsValue)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EnumMemberDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (equalsValue == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.EqualsValueClauseSyntax)(object)((SyntaxNode)equalsValue).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax EnumMemberDeclaration(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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 EnumMemberDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), identifier, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EnumMemberDeclarationSyntax EnumMemberDeclaration(string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EnumMemberDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Identifier(identifier), null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax BaseList(SyntaxToken colonToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax> types)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.BaseList((SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BaseTypeSyntax>(types.Node))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BaseListSyntax BaseList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax> types = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.BaseTypeSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return BaseList(Token(SyntaxKind.ColonToken), types);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax SimpleBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SimpleBaseTypeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SimpleBaseType((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList)
|
||
|
|
{
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (argumentList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("argumentList");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PrimaryConstructorBaseType((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArgumentListSyntax)(object)((SyntaxNode)argumentList).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax PrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return PrimaryConstructorBaseType(type, ArgumentList());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax TypeParameterConstraintClause(SyntaxToken whereKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, SyntaxToken colonToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax> constraints)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0068: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (whereKeyword.Kind() != SyntaxKind.WhereKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("whereKeyword");
|
||
|
|
}
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TypeParameterConstraintClause((SyntaxToken)(object)((SyntaxToken)(ref whereKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.IdentifierNameSyntax)(object)((SyntaxNode)name).Green, (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterConstraintSyntax>(constraints.Node))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax> constraints)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return TypeParameterConstraintClause(Token(SyntaxKind.WhereKeyword), name, Token(SyntaxKind.ColonToken), constraints);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax TypeParameterConstraintClause(Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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 TypeParameterConstraintClause(Token(SyntaxKind.WhereKeyword), name, Token(SyntaxKind.ColonToken), default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax>));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax TypeParameterConstraintClause(string name)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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 TypeParameterConstraintClause(Token(SyntaxKind.WhereKeyword), IdentifierName(name), Token(SyntaxKind.ColonToken), default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintSyntax>));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax ConstructorConstraint(SyntaxToken newKeyword, SyntaxToken openParenToken, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (newKeyword.Kind() != SyntaxKind.NewKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("newKeyword");
|
||
|
|
}
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ConstructorConstraint((SyntaxToken)(object)((SyntaxToken)(ref newKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorConstraintSyntax ConstructorConstraint()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConstructorConstraint(Token(SyntaxKind.NewKeyword), Token(SyntaxKind.OpenParenToken), Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax ClassOrStructConstraint(SyntaxKind kind, SyntaxToken classOrStructKeyword, SyntaxToken questionToken)
|
||
|
|
{
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8868 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = classOrStructKeyword.Kind();
|
||
|
|
if (syntaxKind - 8374 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("classOrStructKeyword");
|
||
|
|
}
|
||
|
|
syntaxKind = questionToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.QuestionToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("questionToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ClassOrStructConstraint(kind, (SyntaxToken)(object)((SyntaxToken)(ref classOrStructKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref questionToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ClassOrStructConstraintSyntax ClassOrStructConstraint(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: 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 ClassOrStructConstraint(kind, Token(GetClassOrStructConstraintClassOrStructKeywordKind(kind)), default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetClassOrStructConstraintClassOrStructKeywordKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.ClassConstraint => SyntaxKind.ClassKeyword,
|
||
|
|
SyntaxKind.StructConstraint => SyntaxKind.StructKeyword,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax TypeConstraint(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TypeConstraintSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TypeConstraint((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax DefaultConstraint(SyntaxToken defaultKeyword)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (defaultKeyword.Kind() != SyntaxKind.DefaultKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("defaultKeyword");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DefaultConstraint((SyntaxToken)(object)((SyntaxToken)(ref defaultKeyword)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax DefaultConstraint()
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DefaultConstraint(Token(SyntaxKind.DefaultKeyword));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax FieldDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_000e: 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)
|
||
|
|
if (declaration == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("declaration");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FieldDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDeclarationSyntax)(object)((SyntaxNode)declaration).Green, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax FieldDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: 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 FieldDeclaration(attributeLists, modifiers, declaration, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FieldDeclarationSyntax FieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FieldDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), declaration, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax EventFieldDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_0046: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (eventKeyword.Kind() != SyntaxKind.EventKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("eventKeyword");
|
||
|
|
}
|
||
|
|
if (declaration == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("declaration");
|
||
|
|
}
|
||
|
|
if (semicolonToken.Kind() != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EventFieldDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref eventKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.VariableDeclarationSyntax)(object)((SyntaxNode)declaration).Green, (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax EventFieldDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: 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 EventFieldDeclaration(attributeLists, modifiers, Token(SyntaxKind.EventKeyword), declaration, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EventFieldDeclarationSyntax EventFieldDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclarationSyntax declaration)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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 EventFieldDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.EventKeyword), declaration, Token(SyntaxKind.SemicolonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name, SyntaxToken dotToken)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (dotToken.Kind() != SyntaxKind.DotToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("dotToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ExplicitInterfaceSpecifier((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.NameSyntax)(object)((SyntaxNode)name).Green, (SyntaxToken)(object)((SyntaxToken)(ref dotToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax ExplicitInterfaceSpecifier(Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ExplicitInterfaceSpecifier(name, Token(SyntaxKind.DotToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax MethodDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: 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_0067: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (returnType == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("returnType");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (parameterList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameterList");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.MethodDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)returnType).Green, (explicitInterfaceSpecifier == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExplicitInterfaceSpecifierSyntax)(object)((SyntaxNode)explicitInterfaceSpecifier).Green), (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (typeParameterList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterListSyntax)(object)((SyntaxNode)typeParameterList).Green), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeParameterConstraintClauseSyntax>(constraintClauses.Node), (body == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)body).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrowExpressionClauseSyntax)(object)((SyntaxNode)expressionBody).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax MethodDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax? typeParameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax> constraintClauses, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: 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)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return MethodDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: 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_002c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0031: 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)
|
||
|
|
return MethodDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), returnType, null, identifier, null, ParameterList(), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.MethodDeclarationSyntax MethodDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: 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_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: 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)
|
||
|
|
return MethodDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), returnType, null, Identifier(identifier), null, ParameterList(), default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterConstraintClauseSyntax>), null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken checkedKeyword, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_000e: 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_0045: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_017b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (returnType == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("returnType");
|
||
|
|
}
|
||
|
|
if (operatorKeyword.Kind() != SyntaxKind.OperatorKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorKeyword");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = checkedKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.CheckedKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("checkedKeyword");
|
||
|
|
}
|
||
|
|
switch (operatorToken.Kind())
|
||
|
|
{
|
||
|
|
default:
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
case SyntaxKind.TildeToken:
|
||
|
|
case SyntaxKind.ExclamationToken:
|
||
|
|
case SyntaxKind.PercentToken:
|
||
|
|
case SyntaxKind.CaretToken:
|
||
|
|
case SyntaxKind.AmpersandToken:
|
||
|
|
case SyntaxKind.AsteriskToken:
|
||
|
|
case SyntaxKind.MinusToken:
|
||
|
|
case SyntaxKind.PlusToken:
|
||
|
|
case SyntaxKind.BarToken:
|
||
|
|
case SyntaxKind.LessThanToken:
|
||
|
|
case SyntaxKind.GreaterThanToken:
|
||
|
|
case SyntaxKind.SlashToken:
|
||
|
|
case SyntaxKind.MinusMinusToken:
|
||
|
|
case SyntaxKind.PlusPlusToken:
|
||
|
|
case SyntaxKind.ExclamationEqualsToken:
|
||
|
|
case SyntaxKind.EqualsEqualsToken:
|
||
|
|
case SyntaxKind.LessThanEqualsToken:
|
||
|
|
case SyntaxKind.LessThanLessThanToken:
|
||
|
|
case SyntaxKind.GreaterThanEqualsToken:
|
||
|
|
case SyntaxKind.GreaterThanGreaterThanToken:
|
||
|
|
case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
|
||
|
|
case SyntaxKind.TrueKeyword:
|
||
|
|
case SyntaxKind.FalseKeyword:
|
||
|
|
case SyntaxKind.IsKeyword:
|
||
|
|
if (parameterList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameterList");
|
||
|
|
}
|
||
|
|
syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.OperatorDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)returnType).Green, (explicitInterfaceSpecifier == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExplicitInterfaceSpecifierSyntax)(object)((SyntaxNode)explicitInterfaceSpecifier).Green), (SyntaxToken)(object)((SyntaxToken)(ref operatorKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref checkedKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green, (body == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)body).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrowExpressionClauseSyntax)(object)((SyntaxNode)expressionBody).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax OperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0027: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return OperatorDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), operatorToken, parameterList, body, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorDeclarationSyntax OperatorDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax returnType, SyntaxToken operatorToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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_0027: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002a: 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_003a: 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)
|
||
|
|
return OperatorDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), returnType, null, Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), operatorToken, ParameterList(), null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken checkedKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: 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_0071: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = implicitOrExplicitKeyword.Kind();
|
||
|
|
if (syntaxKind - 8383 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("implicitOrExplicitKeyword");
|
||
|
|
}
|
||
|
|
if (operatorKeyword.Kind() != SyntaxKind.OperatorKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorKeyword");
|
||
|
|
}
|
||
|
|
syntaxKind = checkedKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.CheckedKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("checkedKeyword");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (parameterList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameterList");
|
||
|
|
}
|
||
|
|
syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ConversionOperatorDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref implicitOrExplicitKeyword)).Node, (explicitInterfaceSpecifier == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExplicitInterfaceSpecifierSyntax)(object)((SyntaxNode)explicitInterfaceSpecifier).Green), (SyntaxToken)(object)((SyntaxToken)(ref operatorKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref checkedKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green, (body == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)body).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrowExpressionClauseSyntax)(object)((SyntaxNode)expressionBody).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: 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_0027: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, explicitInterfaceSpecifier, Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), type, parameterList, body, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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_002a: 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_003a: 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)
|
||
|
|
return ConversionOperatorDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), implicitOrExplicitKeyword, null, Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), type, ParameterList(), null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax ConstructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax? initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_004b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (parameterList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameterList");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ConstructorDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green, (initializer == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ConstructorInitializerSyntax)(object)((SyntaxNode)initializer).Green), (body == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)body).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrowExpressionClauseSyntax)(object)((SyntaxNode)expressionBody).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax ConstructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax? initializer, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//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_000c: 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 ConstructorDeclaration(attributeLists, modifiers, identifier, parameterList, initializer, body, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax ConstructorDeclaration(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: 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_002c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConstructorDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), identifier, ParameterList(), null, null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorDeclarationSyntax ConstructorDeclaration(string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConstructorDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Identifier(identifier), ParameterList(), null, null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax ConstructorInitializer(SyntaxKind kind, SyntaxToken colonToken, SyntaxToken thisOrBaseKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList)
|
||
|
|
{
|
||
|
|
//IL_0015: 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)
|
||
|
|
if (kind - 8889 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = thisOrBaseKeyword.Kind();
|
||
|
|
if (syntaxKind - 8370 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("thisOrBaseKeyword");
|
||
|
|
}
|
||
|
|
if (argumentList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("argumentList");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ConstructorInitializer(kind, (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref thisOrBaseKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArgumentListSyntax)(object)((SyntaxNode)argumentList).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConstructorInitializerSyntax ConstructorInitializer(SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax? argumentList = null)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConstructorInitializer(kind, Token(SyntaxKind.ColonToken), Token(GetConstructorInitializerThisOrBaseKeywordKind(kind)), argumentList ?? ArgumentList());
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetConstructorInitializerThisOrBaseKeywordKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.BaseConstructorInitializer => SyntaxKind.BaseKeyword,
|
||
|
|
SyntaxKind.ThisConstructorInitializer => SyntaxKind.ThisKeyword,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax DestructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken tildeToken, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0064: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (tildeToken.Kind() != SyntaxKind.TildeToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("tildeToken");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
if (parameterList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameterList");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DestructorDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref tildeToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterListSyntax)(object)((SyntaxNode)parameterList).Green, (body == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)body).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrowExpressionClauseSyntax)(object)((SyntaxNode)expressionBody).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax DestructorDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DestructorDeclaration(attributeLists, modifiers, Token(SyntaxKind.TildeToken), identifier, parameterList, body, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax DestructorDeclaration(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: 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)
|
||
|
|
//IL_002f: 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)
|
||
|
|
return DestructorDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.TildeToken), identifier, ParameterList(), null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DestructorDeclarationSyntax DestructorDeclaration(string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: 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_0024: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DestructorDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.TildeToken), Identifier(identifier), ParameterList(), null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax PropertyDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? initializer, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_000e: 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_004c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PropertyDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (explicitInterfaceSpecifier == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExplicitInterfaceSpecifierSyntax)(object)((SyntaxNode)explicitInterfaceSpecifier).Green), (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (accessorList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AccessorListSyntax)(object)((SyntaxNode)accessorList).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrowExpressionClauseSyntax)(object)((SyntaxNode)expressionBody).Green), (initializer == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.EqualsValueClauseSyntax)(object)((SyntaxNode)initializer).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax PropertyDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? initializer)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: 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 PropertyDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, identifier, accessorList, expressionBody, initializer, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return PropertyDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), type, null, identifier, null, null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PropertyDeclarationSyntax PropertyDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: 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)
|
||
|
|
return PropertyDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), type, null, Identifier(identifier), null, null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax ArrowExpressionClause(SyntaxToken arrowToken, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (arrowToken.Kind() != SyntaxKind.EqualsGreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("arrowToken");
|
||
|
|
}
|
||
|
|
if (expression == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("expression");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ArrowExpressionClause((SyntaxToken)(object)((SyntaxToken)(ref arrowToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)expression).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax ArrowExpressionClause(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ArrowExpressionClause(Token(SyntaxKind.EqualsGreaterThanToken), expression);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax EventDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken eventKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_003f: 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_0070: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (eventKeyword.Kind() != SyntaxKind.EventKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("eventKeyword");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (identifier.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EventDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref eventKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (explicitInterfaceSpecifier == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExplicitInterfaceSpecifierSyntax)(object)((SyntaxNode)explicitInterfaceSpecifier).Green), (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (accessorList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AccessorListSyntax)(object)((SyntaxNode)accessorList).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax EventDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000e: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EventDeclaration(attributeLists, modifiers, Token(SyntaxKind.EventKeyword), type, explicitInterfaceSpecifier, identifier, accessorList, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: 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_0028: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EventDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.EventKeyword), type, null, identifier, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EventDeclarationSyntax EventDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, string identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: 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_002d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EventDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(SyntaxKind.EventKeyword), type, null, Identifier(identifier), null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax IndexerDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0036: 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_0067: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
if (thisKeyword.Kind() != SyntaxKind.ThisKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("thisKeyword");
|
||
|
|
}
|
||
|
|
if (parameterList == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("parameterList");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.IndexerDeclaration(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (explicitInterfaceSpecifier == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExplicitInterfaceSpecifierSyntax)(object)((SyntaxNode)explicitInterfaceSpecifier).Green), (SyntaxToken)(object)((SyntaxToken)(ref thisKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BracketedParameterListSyntax)(object)((SyntaxNode)parameterList).Green, (accessorList == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AccessorListSyntax)(object)((SyntaxNode)accessorList).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrowExpressionClauseSyntax)(object)((SyntaxNode)expressionBody).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax IndexerDeclaration(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax parameterList, Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax? accessorList, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IndexerDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, Token(SyntaxKind.ThisKeyword), parameterList, accessorList, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IndexerDeclarationSyntax IndexerDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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_0036: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IndexerDeclaration(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), type, null, Token(SyntaxKind.ThisKeyword), BracketedParameterList(), null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax AccessorList(SyntaxToken openBraceToken, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax> accessors, SyntaxToken closeBraceToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBraceToken.Kind() != SyntaxKind.OpenBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBraceToken");
|
||
|
|
}
|
||
|
|
if (closeBraceToken.Kind() != SyntaxKind.CloseBraceToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBraceToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AccessorList((SyntaxToken)(object)((SyntaxToken)(ref openBraceToken)).Node, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AccessorDeclarationSyntax>(accessors.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBraceToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AccessorListSyntax AccessorList(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax> accessors = default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AccessorList(Token(SyntaxKind.OpenBraceToken), accessors, Token(SyntaxKind.CloseBraceToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody, SyntaxToken semicolonToken)
|
||
|
|
{
|
||
|
|
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (kind - 8896 > (SyntaxKind)4 && kind != SyntaxKind.InitAccessorDeclaration)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = keyword.Kind();
|
||
|
|
if (syntaxKind - 8417 > (SyntaxKind)3 && syntaxKind != SyntaxKind.InitKeyword && syntaxKind != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("keyword");
|
||
|
|
}
|
||
|
|
syntaxKind = semicolonToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.SemicolonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("semicolonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.AccessorDeclaration(kind, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (SyntaxToken)(object)((SyntaxToken)(ref keyword)).Node, (body == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.BlockSyntax)(object)((SyntaxNode)body).Green), (expressionBody == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ArrowExpressionClauseSyntax)(object)((SyntaxNode)expressionBody).Green), (SyntaxToken)(object)((SyntaxToken)(ref semicolonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax? body, Microsoft.CodeAnalysis.CSharp.Syntax.ArrowExpressionClauseSyntax? expressionBody)
|
||
|
|
{
|
||
|
|
//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_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AccessorDeclaration(kind, attributeLists, modifiers, Token(GetAccessorDeclarationKeywordKind(kind)), body, expressionBody, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_0019: 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_0028: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return AccessorDeclaration(kind, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), Token(GetAccessorDeclarationKeywordKind(kind)), null, null, default(SyntaxToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static SyntaxKind GetAccessorDeclarationKeywordKind(SyntaxKind kind)
|
||
|
|
{
|
||
|
|
return kind switch
|
||
|
|
{
|
||
|
|
SyntaxKind.GetAccessorDeclaration => SyntaxKind.GetKeyword,
|
||
|
|
SyntaxKind.SetAccessorDeclaration => SyntaxKind.SetKeyword,
|
||
|
|
SyntaxKind.InitAccessorDeclaration => SyntaxKind.InitKeyword,
|
||
|
|
SyntaxKind.AddAccessorDeclaration => SyntaxKind.AddKeyword,
|
||
|
|
SyntaxKind.RemoveAccessorDeclaration => SyntaxKind.RemoveKeyword,
|
||
|
|
SyntaxKind.UnknownAccessorDeclaration => SyntaxKind.IdentifierToken,
|
||
|
|
_ => throw new ArgumentOutOfRangeException(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax ParameterList(SyntaxToken openParenToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ParameterList((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterSyntax>(parameters.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax ParameterList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ParameterList(Token(SyntaxKind.OpenParenToken), parameters, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax BracketedParameterList(SyntaxToken openBracketToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters, SyntaxToken closeBracketToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBracketToken");
|
||
|
|
}
|
||
|
|
if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBracketToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.BracketedParameterList((SyntaxToken)(object)((SyntaxToken)(ref openBracketToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ParameterSyntax>(parameters.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBracketToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BracketedParameterListSyntax BracketedParameterList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax> parameters = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return BracketedParameterList(Token(SyntaxKind.OpenBracketToken), parameters, Token(SyntaxKind.CloseBracketToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax Parameter(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type, SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax? @default)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0029: 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)
|
||
|
|
SyntaxKind syntaxKind = identifier.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.ArgListKeyword && syntaxKind != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("identifier");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.Parameter(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (type == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green), (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (@default == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.EqualsValueClauseSyntax)(object)((SyntaxNode)@default).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax Parameter(SyntaxToken identifier)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return Parameter(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), null, identifier, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax FunctionPointerParameter(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0015: 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)
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.FunctionPointerParameter(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax FunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return FunctionPointerParameter(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), type);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax IncompleteMember(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.IncompleteMember(GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.AttributeListSyntax>(attributeLists.Node), GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref modifiers)).Node), (type == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IncompleteMemberSyntax IncompleteMember(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax? type = null)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IncompleteMember(default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax>), default(SyntaxTokenList), type);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax SkippedTokensTrivia(SyntaxTokenList tokens)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.SkippedTokensTrivia(GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref tokens)).Node))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.SkippedTokensTriviaSyntax SkippedTokensTrivia()
|
||
|
|
{
|
||
|
|
//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 SkippedTokensTrivia(default(SyntaxTokenList));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax DocumentationCommentTrivia(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content, SyntaxToken endOfComment)
|
||
|
|
{
|
||
|
|
//IL_0015: 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)
|
||
|
|
if (kind - 8544 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("kind");
|
||
|
|
}
|
||
|
|
if (endOfComment.Kind() != SyntaxKind.EndOfDocumentationCommentToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfComment");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DocumentationCommentTrivia(kind, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlNodeSyntax>(content.Node), (SyntaxToken)(object)((SyntaxToken)(ref endOfComment)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DocumentationCommentTriviaSyntax DocumentationCommentTrivia(SyntaxKind kind, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content = default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DocumentationCommentTrivia(kind, content, Token(SyntaxKind.EndOfDocumentationCommentToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax TypeCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.TypeCrefSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.TypeCref((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax container, SyntaxToken dotToken, Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax member)
|
||
|
|
{
|
||
|
|
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (container == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("container");
|
||
|
|
}
|
||
|
|
if (dotToken.Kind() != SyntaxKind.DotToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("dotToken");
|
||
|
|
}
|
||
|
|
if (member == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("member");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.QualifiedCref((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)container).Green, (SyntaxToken)(object)((SyntaxToken)(ref dotToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.MemberCrefSyntax)(object)((SyntaxNode)member).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.QualifiedCrefSyntax QualifiedCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax container, Microsoft.CodeAnalysis.CSharp.Syntax.MemberCrefSyntax member)
|
||
|
|
{
|
||
|
|
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return QualifiedCref(container, Token(SyntaxKind.DotToken), member);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax name, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters)
|
||
|
|
{
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.NameMemberCref((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)name).Green, (parameters == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CrefParameterListSyntax)(object)((SyntaxNode)parameters).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NameMemberCrefSyntax NameMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax name)
|
||
|
|
{
|
||
|
|
return NameMemberCref(name, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax IndexerMemberCref(SyntaxToken thisKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax? parameters)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (thisKeyword.Kind() != SyntaxKind.ThisKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("thisKeyword");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.IndexerMemberCref((SyntaxToken)(object)((SyntaxToken)(ref thisKeyword)).Node, (parameters == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CrefBracketedParameterListSyntax)(object)((SyntaxNode)parameters).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IndexerMemberCrefSyntax IndexerMemberCref(Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax? parameters = null)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IndexerMemberCref(Token(SyntaxKind.ThisKeyword), parameters);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax OperatorMemberCref(SyntaxToken operatorKeyword, SyntaxToken checkedKeyword, SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (operatorKeyword.Kind() != SyntaxKind.OperatorKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorKeyword");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = checkedKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.CheckedKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("checkedKeyword");
|
||
|
|
}
|
||
|
|
switch (operatorToken.Kind())
|
||
|
|
{
|
||
|
|
default:
|
||
|
|
throw new ArgumentException("operatorToken");
|
||
|
|
case SyntaxKind.TildeToken:
|
||
|
|
case SyntaxKind.ExclamationToken:
|
||
|
|
case SyntaxKind.PercentToken:
|
||
|
|
case SyntaxKind.CaretToken:
|
||
|
|
case SyntaxKind.AmpersandToken:
|
||
|
|
case SyntaxKind.AsteriskToken:
|
||
|
|
case SyntaxKind.MinusToken:
|
||
|
|
case SyntaxKind.PlusToken:
|
||
|
|
case SyntaxKind.BarToken:
|
||
|
|
case SyntaxKind.LessThanToken:
|
||
|
|
case SyntaxKind.GreaterThanToken:
|
||
|
|
case SyntaxKind.SlashToken:
|
||
|
|
case SyntaxKind.MinusMinusToken:
|
||
|
|
case SyntaxKind.PlusPlusToken:
|
||
|
|
case SyntaxKind.ExclamationEqualsToken:
|
||
|
|
case SyntaxKind.EqualsEqualsToken:
|
||
|
|
case SyntaxKind.LessThanEqualsToken:
|
||
|
|
case SyntaxKind.LessThanLessThanToken:
|
||
|
|
case SyntaxKind.GreaterThanEqualsToken:
|
||
|
|
case SyntaxKind.GreaterThanGreaterThanToken:
|
||
|
|
case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
|
||
|
|
case SyntaxKind.TrueKeyword:
|
||
|
|
case SyntaxKind.FalseKeyword:
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.OperatorMemberCref((SyntaxToken)(object)((SyntaxToken)(ref operatorKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref checkedKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref operatorToken)).Node, (parameters == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CrefParameterListSyntax)(object)((SyntaxNode)parameters).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax OperatorMemberCref(SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return OperatorMemberCref(Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), operatorToken, parameters);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.OperatorMemberCrefSyntax OperatorMemberCref(SyntaxToken operatorToken)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000c: 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)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return OperatorMemberCref(Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), operatorToken, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax ConversionOperatorMemberCref(SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, SyntaxToken checkedKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = implicitOrExplicitKeyword.Kind();
|
||
|
|
if (syntaxKind - 8383 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("implicitOrExplicitKeyword");
|
||
|
|
}
|
||
|
|
if (operatorKeyword.Kind() != SyntaxKind.OperatorKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("operatorKeyword");
|
||
|
|
}
|
||
|
|
syntaxKind = checkedKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.CheckedKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("checkedKeyword");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ConversionOperatorMemberCref((SyntaxToken)(object)((SyntaxToken)(ref implicitOrExplicitKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref operatorKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref checkedKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green, (parameters == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CrefParameterListSyntax)(object)((SyntaxNode)parameters).Green))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax ConversionOperatorMemberCref(SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax? parameters)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConversionOperatorMemberCref(implicitOrExplicitKeyword, Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), type, parameters);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ConversionOperatorMemberCrefSyntax ConversionOperatorMemberCref(SyntaxToken implicitOrExplicitKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ConversionOperatorMemberCref(implicitOrExplicitKeyword, Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), type, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax CrefParameterList(SyntaxToken openParenToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CrefParameterList((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CrefParameterSyntax>(parameters.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterListSyntax CrefParameterList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CrefParameterList(Token(SyntaxKind.OpenParenToken), parameters, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax CrefBracketedParameterList(SyntaxToken openBracketToken, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters, SyntaxToken closeBracketToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openBracketToken");
|
||
|
|
}
|
||
|
|
if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeBracketToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CrefBracketedParameterList((SyntaxToken)(object)((SyntaxToken)(ref openBracketToken)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CrefParameterSyntax>(parameters.Node), (SyntaxToken)(object)((SyntaxToken)(ref closeBracketToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CrefBracketedParameterListSyntax CrefBracketedParameterList(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax> parameters = default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax>))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CrefBracketedParameterList(Token(SyntaxKind.OpenBracketToken), parameters, Token(SyntaxKind.CloseBracketToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax CrefParameter(SyntaxToken refKindKeyword, SyntaxToken readOnlyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
SyntaxKind syntaxKind = refKindKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind - 8360 > (SyntaxKind)2)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("refKindKeyword");
|
||
|
|
}
|
||
|
|
syntaxKind = readOnlyKeyword.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.ReadOnlyKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("readOnlyKeyword");
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("type");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.CrefParameter((SyntaxToken)(object)((SyntaxToken)(ref refKindKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref readOnlyKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.TypeSyntax)(object)((SyntaxNode)type).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax CrefParameter(SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CrefParameter(refKindKeyword, default(SyntaxToken), type);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax CrefParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return CrefParameter(default(SyntaxToken), default(SyntaxToken), type);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax startTag, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax> content, Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax endTag)
|
||
|
|
{
|
||
|
|
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (startTag == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("startTag");
|
||
|
|
}
|
||
|
|
if (endTag == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("endTag");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlElement((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlElementStartTagSyntax)(object)((SyntaxNode)startTag).Green, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlNodeSyntax>(content.Node), (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlElementEndTagSyntax)(object)((SyntaxNode)endTag).Green)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementSyntax XmlElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax startTag, Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax endTag)
|
||
|
|
{
|
||
|
|
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlElement(startTag, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlNodeSyntax>), endTag);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax XmlElementStartTag(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes, SyntaxToken greaterThanToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_005c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (lessThanToken.Kind() != SyntaxKind.LessThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("lessThanToken");
|
||
|
|
}
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (greaterThanToken.Kind() != SyntaxKind.GreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("greaterThanToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlElementStartTag((SyntaxToken)(object)((SyntaxToken)(ref lessThanToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlNameSyntax)(object)((SyntaxNode)name).Green, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlAttributeSyntax>(attributes.Node), (SyntaxToken)(object)((SyntaxToken)(ref greaterThanToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlElementStartTag(Token(SyntaxKind.LessThanToken), name, attributes, Token(SyntaxKind.GreaterThanToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementStartTagSyntax XmlElementStartTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlElementStartTag(Token(SyntaxKind.LessThanToken), name, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax>), Token(SyntaxKind.GreaterThanToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax XmlElementEndTag(SyntaxToken lessThanSlashToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxToken greaterThanToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
if (lessThanSlashToken.Kind() != SyntaxKind.LessThanSlashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("lessThanSlashToken");
|
||
|
|
}
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (greaterThanToken.Kind() != SyntaxKind.GreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("greaterThanToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlElementEndTag((SyntaxToken)(object)((SyntaxToken)(ref lessThanSlashToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlNameSyntax)(object)((SyntaxNode)name).Green, (SyntaxToken)(object)((SyntaxToken)(ref greaterThanToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlElementEndTagSyntax XmlElementEndTag(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlElementEndTag(Token(SyntaxKind.LessThanSlashToken), name, Token(SyntaxKind.GreaterThanToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlEmptyElement(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes, SyntaxToken slashGreaterThanToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_005c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (lessThanToken.Kind() != SyntaxKind.LessThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("lessThanToken");
|
||
|
|
}
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (slashGreaterThanToken.Kind() != SyntaxKind.SlashGreaterThanToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("slashGreaterThanToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlEmptyElement((SyntaxToken)(object)((SyntaxToken)(ref lessThanToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlNameSyntax)(object)((SyntaxNode)name).Green, GreenNodeExtensions.ToGreenList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlAttributeSyntax>(attributes.Node), (SyntaxToken)(object)((SyntaxToken)(ref slashGreaterThanToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax> attributes)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlEmptyElement(Token(SyntaxKind.LessThanToken), name, attributes, Token(SyntaxKind.SlashGreaterThanToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlEmptyElementSyntax XmlEmptyElement(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlEmptyElement(Token(SyntaxKind.LessThanToken), name, default(SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.XmlAttributeSyntax>), Token(SyntaxKind.SlashGreaterThanToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax XmlName(Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax? prefix, SyntaxToken localName)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (localName.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("localName");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlName((prefix == null) ? null : ((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlPrefixSyntax)(object)((SyntaxNode)prefix).Green), (SyntaxToken)(object)((SyntaxToken)(ref localName)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax XmlName(SyntaxToken localName)
|
||
|
|
{
|
||
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlName(null, localName);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax XmlName(string localName)
|
||
|
|
{
|
||
|
|
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlName(null, Identifier(localName));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax XmlPrefix(SyntaxToken prefix, SyntaxToken colonToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (prefix.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("prefix");
|
||
|
|
}
|
||
|
|
if (colonToken.Kind() != SyntaxKind.ColonToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("colonToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlPrefix((SyntaxToken)(object)((SyntaxToken)(ref prefix)).Node, (SyntaxToken)(object)((SyntaxToken)(ref colonToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax XmlPrefix(SyntaxToken prefix)
|
||
|
|
{
|
||
|
|
//IL_0000: 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)
|
||
|
|
return XmlPrefix(prefix, Token(SyntaxKind.ColonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlPrefixSyntax XmlPrefix(string prefix)
|
||
|
|
{
|
||
|
|
//IL_0001: 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)
|
||
|
|
return XmlPrefix(Identifier(prefix), Token(SyntaxKind.ColonToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxToken equalsToken, SyntaxToken startQuoteToken, SyntaxTokenList textTokens, SyntaxToken endQuoteToken)
|
||
|
|
{
|
||
|
|
//IL_000e: 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_0042: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (equalsToken.Kind() != SyntaxKind.EqualsToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("equalsToken");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = startQuoteToken.Kind();
|
||
|
|
if (syntaxKind - 8213 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("startQuoteToken");
|
||
|
|
}
|
||
|
|
syntaxKind = endQuoteToken.Kind();
|
||
|
|
if (syntaxKind - 8213 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endQuoteToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlTextAttribute((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlNameSyntax)(object)((SyntaxNode)name).Green, (SyntaxToken)(object)((SyntaxToken)(ref equalsToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref startQuoteToken)).Node, GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref textTokens)).Node), (SyntaxToken)(object)((SyntaxToken)(ref endQuoteToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxToken startQuoteToken, SyntaxTokenList textTokens, SyntaxToken endQuoteToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlTextAttribute(name, Token(SyntaxKind.EqualsToken), startQuoteToken, textTokens, endQuoteToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextAttributeSyntax XmlTextAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxToken startQuoteToken, SyntaxToken endQuoteToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000e: 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)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlTextAttribute(name, Token(SyntaxKind.EqualsToken), startQuoteToken, default(SyntaxTokenList), endQuoteToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxToken equalsToken, SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, SyntaxToken endQuoteToken)
|
||
|
|
{
|
||
|
|
//IL_000e: 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_0050: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (equalsToken.Kind() != SyntaxKind.EqualsToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("equalsToken");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = startQuoteToken.Kind();
|
||
|
|
if (syntaxKind - 8213 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("startQuoteToken");
|
||
|
|
}
|
||
|
|
if (cref == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("cref");
|
||
|
|
}
|
||
|
|
syntaxKind = endQuoteToken.Kind();
|
||
|
|
if (syntaxKind - 8213 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endQuoteToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlCrefAttribute((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlNameSyntax)(object)((SyntaxNode)name).Green, (SyntaxToken)(object)((SyntaxToken)(ref equalsToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref startQuoteToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.CrefSyntax)(object)((SyntaxNode)cref).Green, (SyntaxToken)(object)((SyntaxToken)(ref endQuoteToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlCrefAttributeSyntax XmlCrefAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.CrefSyntax cref, SyntaxToken endQuoteToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlCrefAttribute(name, Token(SyntaxKind.EqualsToken), startQuoteToken, cref, endQuoteToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxToken equalsToken, SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax identifier, SyntaxToken endQuoteToken)
|
||
|
|
{
|
||
|
|
//IL_000e: 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_0050: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (equalsToken.Kind() != SyntaxKind.EqualsToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("equalsToken");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = startQuoteToken.Kind();
|
||
|
|
if (syntaxKind - 8213 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("startQuoteToken");
|
||
|
|
}
|
||
|
|
if (identifier == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("identifier");
|
||
|
|
}
|
||
|
|
syntaxKind = endQuoteToken.Kind();
|
||
|
|
if (syntaxKind - 8213 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endQuoteToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlNameAttribute((Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlNameSyntax)(object)((SyntaxNode)name).Green, (SyntaxToken)(object)((SyntaxToken)(ref equalsToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref startQuoteToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.IdentifierNameSyntax)(object)((SyntaxNode)identifier).Green, (SyntaxToken)(object)((SyntaxToken)(ref endQuoteToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxToken startQuoteToken, Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax identifier, SyntaxToken endQuoteToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlNameAttribute(name, Token(SyntaxKind.EqualsToken), startQuoteToken, identifier, endQuoteToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameAttributeSyntax XmlNameAttribute(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxToken startQuoteToken, string identifier, SyntaxToken endQuoteToken)
|
||
|
|
{
|
||
|
|
//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)
|
||
|
|
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlNameAttribute(name, Token(SyntaxKind.EqualsToken), startQuoteToken, IdentifierName(identifier), endQuoteToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax XmlText(SyntaxTokenList textTokens)
|
||
|
|
{
|
||
|
|
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlText(GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref textTokens)).Node))).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlTextSyntax XmlText()
|
||
|
|
{
|
||
|
|
//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 SyntaxFactory.XmlText(default(SyntaxTokenList));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax XmlCDataSection(SyntaxToken startCDataToken, SyntaxTokenList textTokens, SyntaxToken endCDataToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (startCDataToken.Kind() != SyntaxKind.XmlCDataStartToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("startCDataToken");
|
||
|
|
}
|
||
|
|
if (endCDataToken.Kind() != SyntaxKind.XmlCDataEndToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endCDataToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlCDataSection((SyntaxToken)(object)((SyntaxToken)(ref startCDataToken)).Node, GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref textTokens)).Node), (SyntaxToken)(object)((SyntaxToken)(ref endCDataToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlCDataSectionSyntax XmlCDataSection(SyntaxTokenList textTokens = default(SyntaxTokenList))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlCDataSection(Token(SyntaxKind.XmlCDataStartToken), textTokens, Token(SyntaxKind.XmlCDataEndToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax XmlProcessingInstruction(SyntaxToken startProcessingInstructionToken, Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxTokenList textTokens, SyntaxToken endProcessingInstructionToken)
|
||
|
|
{
|
||
|
|
//IL_0000: 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_005c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (startProcessingInstructionToken.Kind() != SyntaxKind.XmlProcessingInstructionStartToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("startProcessingInstructionToken");
|
||
|
|
}
|
||
|
|
if (name == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("name");
|
||
|
|
}
|
||
|
|
if (endProcessingInstructionToken.Kind() != SyntaxKind.XmlProcessingInstructionEndToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endProcessingInstructionToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlProcessingInstruction((SyntaxToken)(object)((SyntaxToken)(ref startProcessingInstructionToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.XmlNameSyntax)(object)((SyntaxNode)name).Green, GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref textTokens)).Node), (SyntaxToken)(object)((SyntaxToken)(ref endProcessingInstructionToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name, SyntaxTokenList textTokens)
|
||
|
|
{
|
||
|
|
//IL_0005: 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)
|
||
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlProcessingInstruction(Token(SyntaxKind.XmlProcessingInstructionStartToken), name, textTokens, Token(SyntaxKind.XmlProcessingInstructionEndToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlProcessingInstructionSyntax XmlProcessingInstruction(Microsoft.CodeAnalysis.CSharp.Syntax.XmlNameSyntax name)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlProcessingInstruction(Token(SyntaxKind.XmlProcessingInstructionStartToken), name, default(SyntaxTokenList), Token(SyntaxKind.XmlProcessingInstructionEndToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax XmlComment(SyntaxToken lessThanExclamationMinusMinusToken, SyntaxTokenList textTokens, SyntaxToken minusMinusGreaterThanToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (lessThanExclamationMinusMinusToken.Kind() != SyntaxKind.XmlCommentStartToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("lessThanExclamationMinusMinusToken");
|
||
|
|
}
|
||
|
|
if (minusMinusGreaterThanToken.Kind() != SyntaxKind.XmlCommentEndToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("minusMinusGreaterThanToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.XmlComment((SyntaxToken)(object)((SyntaxToken)(ref lessThanExclamationMinusMinusToken)).Node, GreenNodeExtensions.ToGreenList<SyntaxToken>(((SyntaxTokenList)(ref textTokens)).Node), (SyntaxToken)(object)((SyntaxToken)(ref minusMinusGreaterThanToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.XmlCommentSyntax XmlComment(SyntaxTokenList textTokens = default(SyntaxTokenList))
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return XmlComment(Token(SyntaxKind.XmlCommentStartToken), textTokens, Token(SyntaxKind.XmlCommentEndToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax IfDirectiveTrivia(SyntaxToken hashToken, SyntaxToken ifKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (ifKeyword.Kind() != SyntaxKind.IfKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("ifKeyword");
|
||
|
|
}
|
||
|
|
if (condition == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("condition");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.IfDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref ifKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)condition).Green, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive, branchTaken, conditionValue)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.IfDirectiveTriviaSyntax IfDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, bool isActive, bool branchTaken, bool conditionValue)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return IfDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.IfKeyword), condition, Token(SyntaxKind.EndOfDirectiveToken), isActive, branchTaken, conditionValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax ElifDirectiveTrivia(SyntaxToken hashToken, SyntaxToken elifKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (elifKeyword.Kind() != SyntaxKind.ElifKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("elifKeyword");
|
||
|
|
}
|
||
|
|
if (condition == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("condition");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElifDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref elifKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax)(object)((SyntaxNode)condition).Green, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive, branchTaken, conditionValue)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ElifDirectiveTriviaSyntax ElifDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax condition, bool isActive, bool branchTaken, bool conditionValue)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ElifDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.ElifKeyword), condition, Token(SyntaxKind.EndOfDirectiveToken), isActive, branchTaken, conditionValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax ElseDirectiveTrivia(SyntaxToken hashToken, SyntaxToken elseKeyword, SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (elseKeyword.Kind() != SyntaxKind.ElseKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("elseKeyword");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ElseDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref elseKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive, branchTaken)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ElseDirectiveTriviaSyntax ElseDirectiveTrivia(bool isActive, bool branchTaken)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ElseDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.ElseKeyword), Token(SyntaxKind.EndOfDirectiveToken), isActive, branchTaken);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax EndIfDirectiveTrivia(SyntaxToken hashToken, SyntaxToken endIfKeyword, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (endIfKeyword.Kind() != SyntaxKind.EndIfKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endIfKeyword");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EndIfDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endIfKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EndIfDirectiveTriviaSyntax EndIfDirectiveTrivia(bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EndIfDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.EndIfKeyword), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax RegionDirectiveTrivia(SyntaxToken hashToken, SyntaxToken regionKeyword, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (regionKeyword.Kind() != SyntaxKind.RegionKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("regionKeyword");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.RegionDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref regionKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.RegionDirectiveTriviaSyntax RegionDirectiveTrivia(bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return RegionDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.RegionKeyword), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax EndRegionDirectiveTrivia(SyntaxToken hashToken, SyntaxToken endRegionKeyword, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (endRegionKeyword.Kind() != SyntaxKind.EndRegionKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endRegionKeyword");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.EndRegionDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endRegionKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.EndRegionDirectiveTriviaSyntax EndRegionDirectiveTrivia(bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return EndRegionDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.EndRegionKeyword), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax ErrorDirectiveTrivia(SyntaxToken hashToken, SyntaxToken errorKeyword, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (errorKeyword.Kind() != SyntaxKind.ErrorKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("errorKeyword");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ErrorDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref errorKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ErrorDirectiveTriviaSyntax ErrorDirectiveTrivia(bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ErrorDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.ErrorKeyword), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax WarningDirectiveTrivia(SyntaxToken hashToken, SyntaxToken warningKeyword, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (warningKeyword.Kind() != SyntaxKind.WarningKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("warningKeyword");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.WarningDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref warningKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.WarningDirectiveTriviaSyntax WarningDirectiveTrivia(bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return WarningDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.WarningKeyword), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax BadDirectiveTrivia(SyntaxToken hashToken, SyntaxToken identifier, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.BadDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref identifier)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.BadDirectiveTriviaSyntax BadDirectiveTrivia(SyntaxToken identifier, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return BadDirectiveTrivia(Token(SyntaxKind.HashToken), identifier, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax DefineDirectiveTrivia(SyntaxToken hashToken, SyntaxToken defineKeyword, SyntaxToken name, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (defineKeyword.Kind() != SyntaxKind.DefineKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("defineKeyword");
|
||
|
|
}
|
||
|
|
if (name.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("name");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.DefineDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref defineKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref name)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax DefineDirectiveTrivia(SyntaxToken name, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DefineDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.DefineKeyword), name, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.DefineDirectiveTriviaSyntax DefineDirectiveTrivia(string name, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return DefineDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.DefineKeyword), Identifier(name), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax UndefDirectiveTrivia(SyntaxToken hashToken, SyntaxToken undefKeyword, SyntaxToken name, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (undefKeyword.Kind() != SyntaxKind.UndefKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("undefKeyword");
|
||
|
|
}
|
||
|
|
if (name.Kind() != SyntaxKind.IdentifierToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("name");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.UndefDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref undefKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref name)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax UndefDirectiveTrivia(SyntaxToken name, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UndefDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.UndefKeyword), name, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.UndefDirectiveTriviaSyntax UndefDirectiveTrivia(string name, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return UndefDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.UndefKeyword), Identifier(name), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax LineDirectiveTrivia(SyntaxToken hashToken, SyntaxToken lineKeyword, SyntaxToken line, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_005a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (lineKeyword.Kind() != SyntaxKind.LineKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("lineKeyword");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = line.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.DefaultKeyword && syntaxKind != SyntaxKind.HiddenKeyword && syntaxKind != SyntaxKind.NumericLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("line");
|
||
|
|
}
|
||
|
|
syntaxKind = file.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.StringLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("file");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LineDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref lineKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref line)).Node, (SyntaxToken)(object)((SyntaxToken)(ref file)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax LineDirectiveTrivia(SyntaxToken line, SyntaxToken file, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LineDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.LineKeyword), line, file, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectiveTriviaSyntax LineDirectiveTrivia(SyntaxToken line, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0017: 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_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LineDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.LineKeyword), line, default(SyntaxToken), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax LineDirectivePosition(SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (openParenToken.Kind() != SyntaxKind.OpenParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("openParenToken");
|
||
|
|
}
|
||
|
|
if (line.Kind() != SyntaxKind.NumericLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("line");
|
||
|
|
}
|
||
|
|
if (commaToken.Kind() != SyntaxKind.CommaToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("commaToken");
|
||
|
|
}
|
||
|
|
if (character.Kind() != SyntaxKind.NumericLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("character");
|
||
|
|
}
|
||
|
|
if (closeParenToken.Kind() != SyntaxKind.CloseParenToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("closeParenToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LineDirectivePosition((SyntaxToken)(object)((SyntaxToken)(ref openParenToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref line)).Node, (SyntaxToken)(object)((SyntaxToken)(ref commaToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref character)).Node, (SyntaxToken)(object)((SyntaxToken)(ref closeParenToken)).Node)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax LineDirectivePosition(SyntaxToken line, SyntaxToken character)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LineDirectivePosition(Token(SyntaxKind.OpenParenToken), line, Token(SyntaxKind.CommaToken), character, Token(SyntaxKind.CloseParenToken));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax LineSpanDirectiveTrivia(SyntaxToken hashToken, SyntaxToken lineKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, SyntaxToken minusToken, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, SyntaxToken characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (lineKeyword.Kind() != SyntaxKind.LineKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("lineKeyword");
|
||
|
|
}
|
||
|
|
if (start == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("start");
|
||
|
|
}
|
||
|
|
if (minusToken.Kind() != SyntaxKind.MinusToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("minusToken");
|
||
|
|
}
|
||
|
|
if (end == null)
|
||
|
|
{
|
||
|
|
throw new ArgumentNullException("end");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = characterOffset.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind != SyntaxKind.NumericLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("characterOffset");
|
||
|
|
}
|
||
|
|
if (file.Kind() != SyntaxKind.StringLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("file");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LineSpanDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref lineKeyword)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.LineDirectivePositionSyntax)(object)((SyntaxNode)start).Green, (SyntaxToken)(object)((SyntaxToken)(ref minusToken)).Node, (Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.LineDirectivePositionSyntax)(object)((SyntaxNode)end).Green, (SyntaxToken)(object)((SyntaxToken)(ref characterOffset)).Node, (SyntaxToken)(object)((SyntaxToken)(ref file)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, SyntaxToken characterOffset, SyntaxToken file, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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_0027: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LineSpanDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.LineKeyword), start, Token(SyntaxKind.MinusToken), end, characterOffset, file, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LineSpanDirectiveTriviaSyntax LineSpanDirectiveTrivia(Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax start, Microsoft.CodeAnalysis.CSharp.Syntax.LineDirectivePositionSyntax end, SyntaxToken file, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001a: 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_0028: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LineSpanDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.LineKeyword), start, Token(SyntaxKind.MinusToken), end, default(SyntaxToken), file, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax PragmaWarningDirectiveTrivia(SyntaxToken hashToken, SyntaxToken pragmaKeyword, SyntaxToken warningKeyword, SyntaxToken disableOrRestoreKeyword, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> errorCodes, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0048: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (pragmaKeyword.Kind() != SyntaxKind.PragmaKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("pragmaKeyword");
|
||
|
|
}
|
||
|
|
if (warningKeyword.Kind() != SyntaxKind.WarningKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("warningKeyword");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = disableOrRestoreKeyword.Kind();
|
||
|
|
if (syntaxKind - 8479 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("disableOrRestoreKeyword");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PragmaWarningDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref pragmaKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref warningKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref disableOrRestoreKeyword)).Node, GreenNodeExtensions.ToGreenSeparatedList<Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.ExpressionSyntax>(errorCodes.Node), (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax PragmaWarningDirectiveTrivia(SyntaxToken disableOrRestoreKeyword, SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> errorCodes, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: 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)
|
||
|
|
return PragmaWarningDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.PragmaKeyword), Token(SyntaxKind.WarningKeyword), disableOrRestoreKeyword, errorCodes, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PragmaWarningDirectiveTriviaSyntax PragmaWarningDirectiveTrivia(SyntaxToken disableOrRestoreKeyword, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: 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_0027: 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)
|
||
|
|
return PragmaWarningDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.PragmaKeyword), Token(SyntaxKind.WarningKeyword), disableOrRestoreKeyword, default(SeparatedSyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax>), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax PragmaChecksumDirectiveTrivia(SyntaxToken hashToken, SyntaxToken pragmaKeyword, SyntaxToken checksumKeyword, SyntaxToken file, SyntaxToken guid, SyntaxToken bytes, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0060: 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_0092: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (pragmaKeyword.Kind() != SyntaxKind.PragmaKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("pragmaKeyword");
|
||
|
|
}
|
||
|
|
if (checksumKeyword.Kind() != SyntaxKind.ChecksumKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("checksumKeyword");
|
||
|
|
}
|
||
|
|
if (file.Kind() != SyntaxKind.StringLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("file");
|
||
|
|
}
|
||
|
|
if (guid.Kind() != SyntaxKind.StringLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("guid");
|
||
|
|
}
|
||
|
|
if (bytes.Kind() != SyntaxKind.StringLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("bytes");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.PragmaChecksumDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref pragmaKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref checksumKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref file)).Node, (SyntaxToken)(object)((SyntaxToken)(ref guid)).Node, (SyntaxToken)(object)((SyntaxToken)(ref bytes)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.PragmaChecksumDirectiveTriviaSyntax PragmaChecksumDirectiveTrivia(SyntaxToken file, SyntaxToken guid, SyntaxToken bytes, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0020: 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)
|
||
|
|
return PragmaChecksumDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.PragmaKeyword), Token(SyntaxKind.ChecksumKeyword), file, guid, bytes, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax ReferenceDirectiveTrivia(SyntaxToken hashToken, SyntaxToken referenceKeyword, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (referenceKeyword.Kind() != SyntaxKind.ReferenceKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("referenceKeyword");
|
||
|
|
}
|
||
|
|
if (file.Kind() != SyntaxKind.StringLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("file");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ReferenceDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref referenceKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref file)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ReferenceDirectiveTriviaSyntax ReferenceDirectiveTrivia(SyntaxToken file, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ReferenceDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.ReferenceKeyword), file, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax LoadDirectiveTrivia(SyntaxToken hashToken, SyntaxToken loadKeyword, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0048: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (loadKeyword.Kind() != SyntaxKind.LoadKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("loadKeyword");
|
||
|
|
}
|
||
|
|
if (file.Kind() != SyntaxKind.StringLiteralToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("file");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.LoadDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref loadKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref file)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.LoadDirectiveTriviaSyntax LoadDirectiveTrivia(SyntaxToken file, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return LoadDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.LoadKeyword), file, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax ShebangDirectiveTrivia(SyntaxToken hashToken, SyntaxToken exclamationToken, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (exclamationToken.Kind() != SyntaxKind.ExclamationToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("exclamationToken");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.ShebangDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref exclamationToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.ShebangDirectiveTriviaSyntax ShebangDirectiveTrivia(bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return ShebangDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.ExclamationToken), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax NullableDirectiveTrivia(SyntaxToken hashToken, SyntaxToken nullableKeyword, SyntaxToken settingToken, SyntaxToken targetToken, SyntaxToken endOfDirectiveToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0018: 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_0054: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
if (hashToken.Kind() != SyntaxKind.HashToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("hashToken");
|
||
|
|
}
|
||
|
|
if (nullableKeyword.Kind() != SyntaxKind.NullableKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("nullableKeyword");
|
||
|
|
}
|
||
|
|
SyntaxKind syntaxKind = settingToken.Kind();
|
||
|
|
if (syntaxKind - 8479 > SyntaxKind.List && syntaxKind != SyntaxKind.EnableKeyword)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("settingToken");
|
||
|
|
}
|
||
|
|
syntaxKind = targetToken.Kind();
|
||
|
|
if (syntaxKind != SyntaxKind.None && syntaxKind - 8488 > SyntaxKind.List)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("targetToken");
|
||
|
|
}
|
||
|
|
if (endOfDirectiveToken.Kind() != SyntaxKind.EndOfDirectiveToken)
|
||
|
|
{
|
||
|
|
throw new ArgumentException("endOfDirectiveToken");
|
||
|
|
}
|
||
|
|
return (Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax)(object)((GreenNode)Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax.SyntaxFactory.NullableDirectiveTrivia((SyntaxToken)(object)((SyntaxToken)(ref hashToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref nullableKeyword)).Node, (SyntaxToken)(object)((SyntaxToken)(ref settingToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref targetToken)).Node, (SyntaxToken)(object)((SyntaxToken)(ref endOfDirectiveToken)).Node, isActive)).CreateRed();
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax NullableDirectiveTrivia(SyntaxToken settingToken, SyntaxToken targetToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return NullableDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.NullableKeyword), settingToken, targetToken, Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax NullableDirectiveTrivia(SyntaxToken settingToken, bool isActive)
|
||
|
|
{
|
||
|
|
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
//IL_000f: 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)
|
||
|
|
//IL_0017: 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_0023: Unknown result type (might be due to invalid IL or missing references)
|
||
|
|
return NullableDirectiveTrivia(Token(SyntaxKind.HashToken), Token(SyntaxKind.NullableKeyword), settingToken, default(SyntaxToken), Token(SyntaxKind.EndOfDirectiveToken), isActive);
|
||
|
|
}
|
||
|
|
}
|