using System; using Microsoft.CodeAnalysis.Syntax.InternalSyntax; namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax; internal class ContextAwareSyntax { private SyntaxFactoryContext context; public GlobalStatementSyntax GlobalStatement(StatementSyntax statement) { //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) return GlobalStatement(default(SyntaxList), default(SyntaxList), statement); } public ContextAwareSyntax(SyntaxFactoryContext context) { this.context = context; } public IdentifierNameSyntax IdentifierName(SyntaxToken identifier) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8616, (GreenNode)(object)identifier, context, out hash); if (val != null) { return (IdentifierNameSyntax)(object)val; } IdentifierNameSyntax identifierNameSyntax = new IdentifierNameSyntax(SyntaxKind.IdentifierName, identifier, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)identifierNameSyntax, hash); } return identifierNameSyntax; } public QualifiedNameSyntax QualifiedName(NameSyntax left, SyntaxToken dotToken, SimpleNameSyntax right) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8617, (GreenNode)(object)left, (GreenNode)(object)dotToken, (GreenNode)(object)right, context, out hash); if (val != null) { return (QualifiedNameSyntax)(object)val; } QualifiedNameSyntax qualifiedNameSyntax = new QualifiedNameSyntax(SyntaxKind.QualifiedName, left, dotToken, right, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)qualifiedNameSyntax, hash); } return qualifiedNameSyntax; } public GenericNameSyntax GenericName(SyntaxToken identifier, TypeArgumentListSyntax typeArgumentList) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8618, (GreenNode)(object)identifier, (GreenNode)(object)typeArgumentList, context, out hash); if (val != null) { return (GenericNameSyntax)(object)val; } GenericNameSyntax genericNameSyntax = new GenericNameSyntax(SyntaxKind.GenericName, identifier, typeArgumentList, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)genericNameSyntax, hash); } return genericNameSyntax; } public TypeArgumentListSyntax TypeArgumentList(SyntaxToken lessThanToken, SeparatedSyntaxList arguments, SyntaxToken greaterThanToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8619, (GreenNode)(object)lessThanToken, arguments.Node, (GreenNode)(object)greaterThanToken, context, out hash); if (val != null) { return (TypeArgumentListSyntax)(object)val; } TypeArgumentListSyntax typeArgumentListSyntax = new TypeArgumentListSyntax(SyntaxKind.TypeArgumentList, lessThanToken, arguments.Node, greaterThanToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)typeArgumentListSyntax, hash); } return typeArgumentListSyntax; } public AliasQualifiedNameSyntax AliasQualifiedName(IdentifierNameSyntax alias, SyntaxToken colonColonToken, SimpleNameSyntax name) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8620, (GreenNode)(object)alias, (GreenNode)(object)colonColonToken, (GreenNode)(object)name, context, out hash); if (val != null) { return (AliasQualifiedNameSyntax)(object)val; } AliasQualifiedNameSyntax aliasQualifiedNameSyntax = new AliasQualifiedNameSyntax(SyntaxKind.AliasQualifiedName, alias, colonColonToken, name, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)aliasQualifiedNameSyntax, hash); } return aliasQualifiedNameSyntax; } public PredefinedTypeSyntax PredefinedType(SyntaxToken keyword) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8621, (GreenNode)(object)keyword, context, out hash); if (val != null) { return (PredefinedTypeSyntax)(object)val; } PredefinedTypeSyntax predefinedTypeSyntax = new PredefinedTypeSyntax(SyntaxKind.PredefinedType, keyword, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)predefinedTypeSyntax, hash); } return predefinedTypeSyntax; } public ArrayTypeSyntax ArrayType(TypeSyntax elementType, SyntaxList rankSpecifiers) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8622, (GreenNode)(object)elementType, rankSpecifiers.Node, context, out hash); if (val != null) { return (ArrayTypeSyntax)(object)val; } ArrayTypeSyntax arrayTypeSyntax = new ArrayTypeSyntax(SyntaxKind.ArrayType, elementType, rankSpecifiers.Node, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)arrayTypeSyntax, hash); } return arrayTypeSyntax; } public ArrayRankSpecifierSyntax ArrayRankSpecifier(SyntaxToken openBracketToken, SeparatedSyntaxList sizes, SyntaxToken closeBracketToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8623, (GreenNode)(object)openBracketToken, sizes.Node, (GreenNode)(object)closeBracketToken, context, out hash); if (val != null) { return (ArrayRankSpecifierSyntax)(object)val; } ArrayRankSpecifierSyntax arrayRankSpecifierSyntax = new ArrayRankSpecifierSyntax(SyntaxKind.ArrayRankSpecifier, openBracketToken, sizes.Node, closeBracketToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)arrayRankSpecifierSyntax, hash); } return arrayRankSpecifierSyntax; } public PointerTypeSyntax PointerType(TypeSyntax elementType, SyntaxToken asteriskToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8624, (GreenNode)(object)elementType, (GreenNode)(object)asteriskToken, context, out hash); if (val != null) { return (PointerTypeSyntax)(object)val; } PointerTypeSyntax pointerTypeSyntax = new PointerTypeSyntax(SyntaxKind.PointerType, elementType, asteriskToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)pointerTypeSyntax, hash); } return pointerTypeSyntax; } public FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterListSyntax parameterList) { return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, parameterList, context); } public FunctionPointerParameterListSyntax FunctionPointerParameterList(SyntaxToken lessThanToken, SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9058, (GreenNode)(object)lessThanToken, parameters.Node, (GreenNode)(object)greaterThanToken, context, out hash); if (val != null) { return (FunctionPointerParameterListSyntax)(object)val; } FunctionPointerParameterListSyntax functionPointerParameterListSyntax = new FunctionPointerParameterListSyntax(SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerParameterListSyntax, hash); } return functionPointerParameterListSyntax; } public FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedOrUnmanagedKeyword, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9059, (GreenNode)(object)managedOrUnmanagedKeyword, (GreenNode)(object)unmanagedCallingConventionList, context, out hash); if (val != null) { return (FunctionPointerCallingConventionSyntax)(object)val; } FunctionPointerCallingConventionSyntax functionPointerCallingConventionSyntax = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConvention, managedOrUnmanagedKeyword, unmanagedCallingConventionList, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerCallingConventionSyntax, hash); } return functionPointerCallingConventionSyntax; } public FunctionPointerUnmanagedCallingConventionListSyntax FunctionPointerUnmanagedCallingConventionList(SyntaxToken openBracketToken, SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9066, (GreenNode)(object)openBracketToken, callingConventions.Node, (GreenNode)(object)closeBracketToken, context, out hash); if (val != null) { return (FunctionPointerUnmanagedCallingConventionListSyntax)(object)val; } FunctionPointerUnmanagedCallingConventionListSyntax functionPointerUnmanagedCallingConventionListSyntax = new FunctionPointerUnmanagedCallingConventionListSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerUnmanagedCallingConventionListSyntax, hash); } return functionPointerUnmanagedCallingConventionListSyntax; } public FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken name) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9067, (GreenNode)(object)name, context, out hash); if (val != null) { return (FunctionPointerUnmanagedCallingConventionSyntax)(object)val; } FunctionPointerUnmanagedCallingConventionSyntax functionPointerUnmanagedCallingConventionSyntax = new FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConvention, name, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerUnmanagedCallingConventionSyntax, hash); } return functionPointerUnmanagedCallingConventionSyntax; } public NullableTypeSyntax NullableType(TypeSyntax elementType, SyntaxToken questionToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8625, (GreenNode)(object)elementType, (GreenNode)(object)questionToken, context, out hash); if (val != null) { return (NullableTypeSyntax)(object)val; } NullableTypeSyntax nullableTypeSyntax = new NullableTypeSyntax(SyntaxKind.NullableType, elementType, questionToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)nullableTypeSyntax, hash); } return nullableTypeSyntax; } public TupleTypeSyntax TupleType(SyntaxToken openParenToken, SeparatedSyntaxList elements, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8924, (GreenNode)(object)openParenToken, elements.Node, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (TupleTypeSyntax)(object)val; } TupleTypeSyntax tupleTypeSyntax = new TupleTypeSyntax(SyntaxKind.TupleType, openParenToken, elements.Node, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)tupleTypeSyntax, hash); } return tupleTypeSyntax; } public TupleElementSyntax TupleElement(TypeSyntax type, SyntaxToken? identifier) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8925, (GreenNode)(object)type, (GreenNode)(object)identifier, context, out hash); if (val != null) { return (TupleElementSyntax)(object)val; } TupleElementSyntax tupleElementSyntax = new TupleElementSyntax(SyntaxKind.TupleElement, type, identifier, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)tupleElementSyntax, hash); } return tupleElementSyntax; } public OmittedTypeArgumentSyntax OmittedTypeArgument(SyntaxToken omittedTypeArgumentToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8626, (GreenNode)(object)omittedTypeArgumentToken, context, out hash); if (val != null) { return (OmittedTypeArgumentSyntax)(object)val; } OmittedTypeArgumentSyntax omittedTypeArgumentSyntax = new OmittedTypeArgumentSyntax(SyntaxKind.OmittedTypeArgument, omittedTypeArgumentToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)omittedTypeArgumentSyntax, hash); } return omittedTypeArgumentSyntax; } public RefTypeSyntax RefType(SyntaxToken refKeyword, SyntaxToken? readOnlyKeyword, TypeSyntax type) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9051, (GreenNode)(object)refKeyword, (GreenNode)(object)readOnlyKeyword, (GreenNode)(object)type, context, out hash); if (val != null) { return (RefTypeSyntax)(object)val; } RefTypeSyntax refTypeSyntax = new RefTypeSyntax(SyntaxKind.RefType, refKeyword, readOnlyKeyword, type, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)refTypeSyntax, hash); } return refTypeSyntax; } public ScopedTypeSyntax ScopedType(SyntaxToken scopedKeyword, TypeSyntax type) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9075, (GreenNode)(object)scopedKeyword, (GreenNode)(object)type, context, out hash); if (val != null) { return (ScopedTypeSyntax)(object)val; } ScopedTypeSyntax scopedTypeSyntax = new ScopedTypeSyntax(SyntaxKind.ScopedType, scopedKeyword, type, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)scopedTypeSyntax, hash); } return scopedTypeSyntax; } public ParenthesizedExpressionSyntax ParenthesizedExpression(SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8632, (GreenNode)(object)openParenToken, (GreenNode)(object)expression, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (ParenthesizedExpressionSyntax)(object)val; } ParenthesizedExpressionSyntax parenthesizedExpressionSyntax = new ParenthesizedExpressionSyntax(SyntaxKind.ParenthesizedExpression, openParenToken, expression, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)parenthesizedExpressionSyntax, hash); } return parenthesizedExpressionSyntax; } public TupleExpressionSyntax TupleExpression(SyntaxToken openParenToken, SeparatedSyntaxList arguments, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8926, (GreenNode)(object)openParenToken, arguments.Node, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (TupleExpressionSyntax)(object)val; } TupleExpressionSyntax tupleExpressionSyntax = new TupleExpressionSyntax(SyntaxKind.TupleExpression, openParenToken, arguments.Node, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)tupleExpressionSyntax, hash); } return tupleExpressionSyntax; } public PrefixUnaryExpressionSyntax PrefixUnaryExpression(SyntaxKind kind, SyntaxToken operatorToken, ExpressionSyntax operand) { if (kind - 8730 > (SyntaxKind)7 && kind != SyntaxKind.IndexExpression) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)operatorToken, (GreenNode)(object)operand, context, out hash); if (val != null) { return (PrefixUnaryExpressionSyntax)(object)val; } PrefixUnaryExpressionSyntax prefixUnaryExpressionSyntax = new PrefixUnaryExpressionSyntax(kind, operatorToken, operand, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)prefixUnaryExpressionSyntax, hash); } return prefixUnaryExpressionSyntax; } public AwaitExpressionSyntax AwaitExpression(SyntaxToken awaitKeyword, ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8740, (GreenNode)(object)awaitKeyword, (GreenNode)(object)expression, context, out hash); if (val != null) { return (AwaitExpressionSyntax)(object)val; } AwaitExpressionSyntax awaitExpressionSyntax = new AwaitExpressionSyntax(SyntaxKind.AwaitExpression, awaitKeyword, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)awaitExpressionSyntax, hash); } return awaitExpressionSyntax; } public PostfixUnaryExpressionSyntax PostfixUnaryExpression(SyntaxKind kind, ExpressionSyntax operand, SyntaxToken operatorToken) { if (kind - 8738 > SyntaxKind.List && kind != SyntaxKind.SuppressNullableWarningExpression) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)operand, (GreenNode)(object)operatorToken, context, out hash); if (val != null) { return (PostfixUnaryExpressionSyntax)(object)val; } PostfixUnaryExpressionSyntax postfixUnaryExpressionSyntax = new PostfixUnaryExpressionSyntax(kind, operand, operatorToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)postfixUnaryExpressionSyntax, hash); } return postfixUnaryExpressionSyntax; } public MemberAccessExpressionSyntax MemberAccessExpression(SyntaxKind kind, ExpressionSyntax expression, SyntaxToken operatorToken, SimpleNameSyntax name) { if (kind - 8689 > SyntaxKind.List) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)expression, (GreenNode)(object)operatorToken, (GreenNode)(object)name, context, out hash); if (val != null) { return (MemberAccessExpressionSyntax)(object)val; } MemberAccessExpressionSyntax memberAccessExpressionSyntax = new MemberAccessExpressionSyntax(kind, expression, operatorToken, name, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)memberAccessExpressionSyntax, hash); } return memberAccessExpressionSyntax; } public ConditionalAccessExpressionSyntax ConditionalAccessExpression(ExpressionSyntax expression, SyntaxToken operatorToken, ExpressionSyntax whenNotNull) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8691, (GreenNode)(object)expression, (GreenNode)(object)operatorToken, (GreenNode)(object)whenNotNull, context, out hash); if (val != null) { return (ConditionalAccessExpressionSyntax)(object)val; } ConditionalAccessExpressionSyntax conditionalAccessExpressionSyntax = new ConditionalAccessExpressionSyntax(SyntaxKind.ConditionalAccessExpression, expression, operatorToken, whenNotNull, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)conditionalAccessExpressionSyntax, hash); } return conditionalAccessExpressionSyntax; } public MemberBindingExpressionSyntax MemberBindingExpression(SyntaxToken operatorToken, SimpleNameSyntax name) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8707, (GreenNode)(object)operatorToken, (GreenNode)(object)name, context, out hash); if (val != null) { return (MemberBindingExpressionSyntax)(object)val; } MemberBindingExpressionSyntax memberBindingExpressionSyntax = new MemberBindingExpressionSyntax(SyntaxKind.MemberBindingExpression, operatorToken, name, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)memberBindingExpressionSyntax, hash); } return memberBindingExpressionSyntax; } public ElementBindingExpressionSyntax ElementBindingExpression(BracketedArgumentListSyntax argumentList) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8708, (GreenNode)(object)argumentList, context, out hash); if (val != null) { return (ElementBindingExpressionSyntax)(object)val; } ElementBindingExpressionSyntax elementBindingExpressionSyntax = new ElementBindingExpressionSyntax(SyntaxKind.ElementBindingExpression, argumentList, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)elementBindingExpressionSyntax, hash); } return elementBindingExpressionSyntax; } public RangeExpressionSyntax RangeExpression(ExpressionSyntax? leftOperand, SyntaxToken operatorToken, ExpressionSyntax? rightOperand) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8658, (GreenNode)(object)leftOperand, (GreenNode)(object)operatorToken, (GreenNode)(object)rightOperand, context, out hash); if (val != null) { return (RangeExpressionSyntax)(object)val; } RangeExpressionSyntax rangeExpressionSyntax = new RangeExpressionSyntax(SyntaxKind.RangeExpression, leftOperand, operatorToken, rightOperand, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)rangeExpressionSyntax, hash); } return rangeExpressionSyntax; } public ImplicitElementAccessSyntax ImplicitElementAccess(BracketedArgumentListSyntax argumentList) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8656, (GreenNode)(object)argumentList, context, out hash); if (val != null) { return (ImplicitElementAccessSyntax)(object)val; } ImplicitElementAccessSyntax implicitElementAccessSyntax = new ImplicitElementAccessSyntax(SyntaxKind.ImplicitElementAccess, argumentList, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)implicitElementAccessSyntax, hash); } return implicitElementAccessSyntax; } public BinaryExpressionSyntax BinaryExpression(SyntaxKind kind, ExpressionSyntax left, SyntaxToken operatorToken, ExpressionSyntax right) { if (kind - 8668 > (SyntaxKind)20 && kind != SyntaxKind.UnsignedRightShiftExpression) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)left, (GreenNode)(object)operatorToken, (GreenNode)(object)right, context, out hash); if (val != null) { return (BinaryExpressionSyntax)(object)val; } BinaryExpressionSyntax binaryExpressionSyntax = new BinaryExpressionSyntax(kind, left, operatorToken, right, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)binaryExpressionSyntax, hash); } return binaryExpressionSyntax; } public AssignmentExpressionSyntax AssignmentExpression(SyntaxKind kind, ExpressionSyntax left, SyntaxToken operatorToken, ExpressionSyntax right) { if (kind - 8714 > (SyntaxKind)12) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)left, (GreenNode)(object)operatorToken, (GreenNode)(object)right, context, out hash); if (val != null) { return (AssignmentExpressionSyntax)(object)val; } AssignmentExpressionSyntax assignmentExpressionSyntax = new AssignmentExpressionSyntax(kind, left, operatorToken, right, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)assignmentExpressionSyntax, hash); } return assignmentExpressionSyntax; } public ConditionalExpressionSyntax ConditionalExpression(ExpressionSyntax condition, SyntaxToken questionToken, ExpressionSyntax whenTrue, SyntaxToken colonToken, ExpressionSyntax whenFalse) { return new ConditionalExpressionSyntax(SyntaxKind.ConditionalExpression, condition, questionToken, whenTrue, colonToken, whenFalse, context); } public ThisExpressionSyntax ThisExpression(SyntaxToken token) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8746, (GreenNode)(object)token, context, out hash); if (val != null) { return (ThisExpressionSyntax)(object)val; } ThisExpressionSyntax thisExpressionSyntax = new ThisExpressionSyntax(SyntaxKind.ThisExpression, token, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)thisExpressionSyntax, hash); } return thisExpressionSyntax; } public BaseExpressionSyntax BaseExpression(SyntaxToken token) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8747, (GreenNode)(object)token, context, out hash); if (val != null) { return (BaseExpressionSyntax)(object)val; } BaseExpressionSyntax baseExpressionSyntax = new BaseExpressionSyntax(SyntaxKind.BaseExpression, token, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)baseExpressionSyntax, hash); } return baseExpressionSyntax; } public LiteralExpressionSyntax LiteralExpression(SyntaxKind kind, SyntaxToken token) { if (kind - 8748 > (SyntaxKind)8) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)token, context, out hash); if (val != null) { return (LiteralExpressionSyntax)(object)val; } LiteralExpressionSyntax literalExpressionSyntax = new LiteralExpressionSyntax(kind, token, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)literalExpressionSyntax, hash); } return literalExpressionSyntax; } public MakeRefExpressionSyntax MakeRefExpression(SyntaxToken keyword, SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken closeParenToken) { return new MakeRefExpressionSyntax(SyntaxKind.MakeRefExpression, keyword, openParenToken, expression, closeParenToken, context); } public RefTypeExpressionSyntax RefTypeExpression(SyntaxToken keyword, SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken closeParenToken) { return new RefTypeExpressionSyntax(SyntaxKind.RefTypeExpression, keyword, openParenToken, expression, closeParenToken, context); } public RefValueExpressionSyntax RefValueExpression(SyntaxToken keyword, SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken comma, TypeSyntax type, SyntaxToken closeParenToken) { return new RefValueExpressionSyntax(SyntaxKind.RefValueExpression, keyword, openParenToken, expression, comma, type, closeParenToken, context); } public CheckedExpressionSyntax CheckedExpression(SyntaxKind kind, SyntaxToken keyword, SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken closeParenToken) { if (kind - 8762 > SyntaxKind.List) { throw new ArgumentException("kind"); } return new CheckedExpressionSyntax(kind, keyword, openParenToken, expression, closeParenToken, context); } public DefaultExpressionSyntax DefaultExpression(SyntaxToken keyword, SyntaxToken openParenToken, TypeSyntax type, SyntaxToken closeParenToken) { return new DefaultExpressionSyntax(SyntaxKind.DefaultExpression, keyword, openParenToken, type, closeParenToken, context); } public TypeOfExpressionSyntax TypeOfExpression(SyntaxToken keyword, SyntaxToken openParenToken, TypeSyntax type, SyntaxToken closeParenToken) { return new TypeOfExpressionSyntax(SyntaxKind.TypeOfExpression, keyword, openParenToken, type, closeParenToken, context); } public SizeOfExpressionSyntax SizeOfExpression(SyntaxToken keyword, SyntaxToken openParenToken, TypeSyntax type, SyntaxToken closeParenToken) { return new SizeOfExpressionSyntax(SyntaxKind.SizeOfExpression, keyword, openParenToken, type, closeParenToken, context); } public InvocationExpressionSyntax InvocationExpression(ExpressionSyntax expression, ArgumentListSyntax argumentList) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8634, (GreenNode)(object)expression, (GreenNode)(object)argumentList, context, out hash); if (val != null) { return (InvocationExpressionSyntax)(object)val; } InvocationExpressionSyntax invocationExpressionSyntax = new InvocationExpressionSyntax(SyntaxKind.InvocationExpression, expression, argumentList, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)invocationExpressionSyntax, hash); } return invocationExpressionSyntax; } public ElementAccessExpressionSyntax ElementAccessExpression(ExpressionSyntax expression, BracketedArgumentListSyntax argumentList) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8635, (GreenNode)(object)expression, (GreenNode)(object)argumentList, context, out hash); if (val != null) { return (ElementAccessExpressionSyntax)(object)val; } ElementAccessExpressionSyntax elementAccessExpressionSyntax = new ElementAccessExpressionSyntax(SyntaxKind.ElementAccessExpression, expression, argumentList, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)elementAccessExpressionSyntax, hash); } return elementAccessExpressionSyntax; } public ArgumentListSyntax ArgumentList(SyntaxToken openParenToken, SeparatedSyntaxList arguments, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8636, (GreenNode)(object)openParenToken, arguments.Node, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (ArgumentListSyntax)(object)val; } ArgumentListSyntax argumentListSyntax = new ArgumentListSyntax(SyntaxKind.ArgumentList, openParenToken, arguments.Node, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)argumentListSyntax, hash); } return argumentListSyntax; } public BracketedArgumentListSyntax BracketedArgumentList(SyntaxToken openBracketToken, SeparatedSyntaxList arguments, SyntaxToken closeBracketToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8637, (GreenNode)(object)openBracketToken, arguments.Node, (GreenNode)(object)closeBracketToken, context, out hash); if (val != null) { return (BracketedArgumentListSyntax)(object)val; } BracketedArgumentListSyntax bracketedArgumentListSyntax = new BracketedArgumentListSyntax(SyntaxKind.BracketedArgumentList, openBracketToken, arguments.Node, closeBracketToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)bracketedArgumentListSyntax, hash); } return bracketedArgumentListSyntax; } public ArgumentSyntax Argument(NameColonSyntax? nameColon, SyntaxToken? refKindKeyword, ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8638, (GreenNode)(object)nameColon, (GreenNode)(object)refKindKeyword, (GreenNode)(object)expression, context, out hash); if (val != null) { return (ArgumentSyntax)(object)val; } ArgumentSyntax argumentSyntax = new ArgumentSyntax(SyntaxKind.Argument, nameColon, refKindKeyword, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)argumentSyntax, hash); } return argumentSyntax; } public ExpressionColonSyntax ExpressionColon(ExpressionSyntax expression, SyntaxToken colonToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9069, (GreenNode)(object)expression, (GreenNode)(object)colonToken, context, out hash); if (val != null) { return (ExpressionColonSyntax)(object)val; } ExpressionColonSyntax expressionColonSyntax = new ExpressionColonSyntax(SyntaxKind.ExpressionColon, expression, colonToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)expressionColonSyntax, hash); } return expressionColonSyntax; } public NameColonSyntax NameColon(IdentifierNameSyntax name, SyntaxToken colonToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8639, (GreenNode)(object)name, (GreenNode)(object)colonToken, context, out hash); if (val != null) { return (NameColonSyntax)(object)val; } NameColonSyntax nameColonSyntax = new NameColonSyntax(SyntaxKind.NameColon, name, colonToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)nameColonSyntax, hash); } return nameColonSyntax; } public DeclarationExpressionSyntax DeclarationExpression(TypeSyntax type, VariableDesignationSyntax designation) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9040, (GreenNode)(object)type, (GreenNode)(object)designation, context, out hash); if (val != null) { return (DeclarationExpressionSyntax)(object)val; } DeclarationExpressionSyntax declarationExpressionSyntax = new DeclarationExpressionSyntax(SyntaxKind.DeclarationExpression, type, designation, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)declarationExpressionSyntax, hash); } return declarationExpressionSyntax; } public CastExpressionSyntax CastExpression(SyntaxToken openParenToken, TypeSyntax type, SyntaxToken closeParenToken, ExpressionSyntax expression) { return new CastExpressionSyntax(SyntaxKind.CastExpression, openParenToken, type, closeParenToken, expression, context); } public AnonymousMethodExpressionSyntax AnonymousMethodExpression(SyntaxList modifiers, SyntaxToken delegateKeyword, ParameterListSyntax? parameterList, BlockSyntax block, ExpressionSyntax? expressionBody) { return new AnonymousMethodExpressionSyntax(SyntaxKind.AnonymousMethodExpression, modifiers.Node, delegateKeyword, parameterList, block, expressionBody, context); } public SimpleLambdaExpressionSyntax SimpleLambdaExpression(SyntaxList attributeLists, SyntaxList modifiers, ParameterSyntax parameter, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody) { return new SimpleLambdaExpressionSyntax(SyntaxKind.SimpleLambdaExpression, attributeLists.Node, modifiers.Node, parameter, arrowToken, block, expressionBody, context); } public RefExpressionSyntax RefExpression(SyntaxToken refKeyword, ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9050, (GreenNode)(object)refKeyword, (GreenNode)(object)expression, context, out hash); if (val != null) { return (RefExpressionSyntax)(object)val; } RefExpressionSyntax refExpressionSyntax = new RefExpressionSyntax(SyntaxKind.RefExpression, refKeyword, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)refExpressionSyntax, hash); } return refExpressionSyntax; } public ParenthesizedLambdaExpressionSyntax ParenthesizedLambdaExpression(SyntaxList attributeLists, SyntaxList modifiers, TypeSyntax? returnType, ParameterListSyntax parameterList, SyntaxToken arrowToken, BlockSyntax? block, ExpressionSyntax? expressionBody) { return new ParenthesizedLambdaExpressionSyntax(SyntaxKind.ParenthesizedLambdaExpression, attributeLists.Node, modifiers.Node, returnType, parameterList, arrowToken, block, expressionBody, context); } public InitializerExpressionSyntax InitializerExpression(SyntaxKind kind, SyntaxToken openBraceToken, SeparatedSyntaxList expressions, SyntaxToken closeBraceToken) { if (kind - 8644 > (SyntaxKind)2 && kind != SyntaxKind.ComplexElementInitializerExpression && kind != SyntaxKind.WithInitializerExpression) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)openBraceToken, expressions.Node, (GreenNode)(object)closeBraceToken, context, out hash); if (val != null) { return (InitializerExpressionSyntax)(object)val; } InitializerExpressionSyntax initializerExpressionSyntax = new InitializerExpressionSyntax(kind, openBraceToken, expressions.Node, closeBraceToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)initializerExpressionSyntax, hash); } return initializerExpressionSyntax; } public ImplicitObjectCreationExpressionSyntax ImplicitObjectCreationExpression(SyntaxToken newKeyword, ArgumentListSyntax argumentList, InitializerExpressionSyntax? initializer) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8659, (GreenNode)(object)newKeyword, (GreenNode)(object)argumentList, (GreenNode)(object)initializer, context, out hash); if (val != null) { return (ImplicitObjectCreationExpressionSyntax)(object)val; } ImplicitObjectCreationExpressionSyntax implicitObjectCreationExpressionSyntax = new ImplicitObjectCreationExpressionSyntax(SyntaxKind.ImplicitObjectCreationExpression, newKeyword, argumentList, initializer, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)implicitObjectCreationExpressionSyntax, hash); } return implicitObjectCreationExpressionSyntax; } public ObjectCreationExpressionSyntax ObjectCreationExpression(SyntaxToken newKeyword, TypeSyntax type, ArgumentListSyntax? argumentList, InitializerExpressionSyntax? initializer) { return new ObjectCreationExpressionSyntax(SyntaxKind.ObjectCreationExpression, newKeyword, type, argumentList, initializer, context); } public WithExpressionSyntax WithExpression(ExpressionSyntax expression, SyntaxToken withKeyword, InitializerExpressionSyntax initializer) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9061, (GreenNode)(object)expression, (GreenNode)(object)withKeyword, (GreenNode)(object)initializer, context, out hash); if (val != null) { return (WithExpressionSyntax)(object)val; } WithExpressionSyntax withExpressionSyntax = new WithExpressionSyntax(SyntaxKind.WithExpression, expression, withKeyword, initializer, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)withExpressionSyntax, hash); } return withExpressionSyntax; } public AnonymousObjectMemberDeclaratorSyntax AnonymousObjectMemberDeclarator(NameEqualsSyntax? nameEquals, ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8647, (GreenNode)(object)nameEquals, (GreenNode)(object)expression, context, out hash); if (val != null) { return (AnonymousObjectMemberDeclaratorSyntax)(object)val; } AnonymousObjectMemberDeclaratorSyntax anonymousObjectMemberDeclaratorSyntax = new AnonymousObjectMemberDeclaratorSyntax(SyntaxKind.AnonymousObjectMemberDeclarator, nameEquals, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)anonymousObjectMemberDeclaratorSyntax, hash); } return anonymousObjectMemberDeclaratorSyntax; } public AnonymousObjectCreationExpressionSyntax AnonymousObjectCreationExpression(SyntaxToken newKeyword, SyntaxToken openBraceToken, SeparatedSyntaxList initializers, SyntaxToken closeBraceToken) { return new AnonymousObjectCreationExpressionSyntax(SyntaxKind.AnonymousObjectCreationExpression, newKeyword, openBraceToken, initializers.Node, closeBraceToken, context); } public ArrayCreationExpressionSyntax ArrayCreationExpression(SyntaxToken newKeyword, ArrayTypeSyntax type, InitializerExpressionSyntax? initializer) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8651, (GreenNode)(object)newKeyword, (GreenNode)(object)type, (GreenNode)(object)initializer, context, out hash); if (val != null) { return (ArrayCreationExpressionSyntax)(object)val; } ArrayCreationExpressionSyntax arrayCreationExpressionSyntax = new ArrayCreationExpressionSyntax(SyntaxKind.ArrayCreationExpression, newKeyword, type, initializer, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)arrayCreationExpressionSyntax, hash); } return arrayCreationExpressionSyntax; } public ImplicitArrayCreationExpressionSyntax ImplicitArrayCreationExpression(SyntaxToken newKeyword, SyntaxToken openBracketToken, SyntaxList commas, SyntaxToken closeBracketToken, InitializerExpressionSyntax initializer) { return new ImplicitArrayCreationExpressionSyntax(SyntaxKind.ImplicitArrayCreationExpression, newKeyword, openBracketToken, commas.Node, closeBracketToken, initializer, context); } public StackAllocArrayCreationExpressionSyntax StackAllocArrayCreationExpression(SyntaxToken stackAllocKeyword, TypeSyntax type, InitializerExpressionSyntax? initializer) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8653, (GreenNode)(object)stackAllocKeyword, (GreenNode)(object)type, (GreenNode)(object)initializer, context, out hash); if (val != null) { return (StackAllocArrayCreationExpressionSyntax)(object)val; } StackAllocArrayCreationExpressionSyntax stackAllocArrayCreationExpressionSyntax = new StackAllocArrayCreationExpressionSyntax(SyntaxKind.StackAllocArrayCreationExpression, stackAllocKeyword, type, initializer, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)stackAllocArrayCreationExpressionSyntax, hash); } return stackAllocArrayCreationExpressionSyntax; } public ImplicitStackAllocArrayCreationExpressionSyntax ImplicitStackAllocArrayCreationExpression(SyntaxToken stackAllocKeyword, SyntaxToken openBracketToken, SyntaxToken closeBracketToken, InitializerExpressionSyntax initializer) { return new ImplicitStackAllocArrayCreationExpressionSyntax(SyntaxKind.ImplicitStackAllocArrayCreationExpression, stackAllocKeyword, openBracketToken, closeBracketToken, initializer, context); } public CollectionExpressionSyntax CollectionExpression(SyntaxToken openBracketToken, SeparatedSyntaxList elements, SyntaxToken closeBracketToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9076, (GreenNode)(object)openBracketToken, elements.Node, (GreenNode)(object)closeBracketToken, context, out hash); if (val != null) { return (CollectionExpressionSyntax)(object)val; } CollectionExpressionSyntax collectionExpressionSyntax = new CollectionExpressionSyntax(SyntaxKind.CollectionExpression, openBracketToken, elements.Node, closeBracketToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)collectionExpressionSyntax, hash); } return collectionExpressionSyntax; } public ExpressionElementSyntax ExpressionElement(ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9077, (GreenNode)(object)expression, context, out hash); if (val != null) { return (ExpressionElementSyntax)(object)val; } ExpressionElementSyntax expressionElementSyntax = new ExpressionElementSyntax(SyntaxKind.ExpressionElement, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)expressionElementSyntax, hash); } return expressionElementSyntax; } public SpreadElementSyntax SpreadElement(SyntaxToken operatorToken, ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9078, (GreenNode)(object)operatorToken, (GreenNode)(object)expression, context, out hash); if (val != null) { return (SpreadElementSyntax)(object)val; } SpreadElementSyntax spreadElementSyntax = new SpreadElementSyntax(SyntaxKind.SpreadElement, operatorToken, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)spreadElementSyntax, hash); } return spreadElementSyntax; } public QueryExpressionSyntax QueryExpression(FromClauseSyntax fromClause, QueryBodySyntax body) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8774, (GreenNode)(object)fromClause, (GreenNode)(object)body, context, out hash); if (val != null) { return (QueryExpressionSyntax)(object)val; } QueryExpressionSyntax queryExpressionSyntax = new QueryExpressionSyntax(SyntaxKind.QueryExpression, fromClause, body, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)queryExpressionSyntax, hash); } return queryExpressionSyntax; } public QueryBodySyntax QueryBody(SyntaxList clauses, SelectOrGroupClauseSyntax selectOrGroup, QueryContinuationSyntax? continuation) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8775, clauses.Node, (GreenNode)(object)selectOrGroup, (GreenNode)(object)continuation, context, out hash); if (val != null) { return (QueryBodySyntax)(object)val; } QueryBodySyntax queryBodySyntax = new QueryBodySyntax(SyntaxKind.QueryBody, clauses.Node, selectOrGroup, continuation, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)queryBodySyntax, hash); } return queryBodySyntax; } public FromClauseSyntax FromClause(SyntaxToken fromKeyword, TypeSyntax? type, SyntaxToken identifier, SyntaxToken inKeyword, ExpressionSyntax expression) { return new FromClauseSyntax(SyntaxKind.FromClause, fromKeyword, type, identifier, inKeyword, expression, context); } public LetClauseSyntax LetClause(SyntaxToken letKeyword, SyntaxToken identifier, SyntaxToken equalsToken, ExpressionSyntax expression) { return new LetClauseSyntax(SyntaxKind.LetClause, letKeyword, identifier, equalsToken, expression, context); } public JoinClauseSyntax JoinClause(SyntaxToken joinKeyword, TypeSyntax? type, SyntaxToken identifier, SyntaxToken inKeyword, ExpressionSyntax inExpression, SyntaxToken onKeyword, ExpressionSyntax leftExpression, SyntaxToken equalsKeyword, ExpressionSyntax rightExpression, JoinIntoClauseSyntax? into) { return new JoinClauseSyntax(SyntaxKind.JoinClause, joinKeyword, type, identifier, inKeyword, inExpression, onKeyword, leftExpression, equalsKeyword, rightExpression, into, context); } public JoinIntoClauseSyntax JoinIntoClause(SyntaxToken intoKeyword, SyntaxToken identifier) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8779, (GreenNode)(object)intoKeyword, (GreenNode)(object)identifier, context, out hash); if (val != null) { return (JoinIntoClauseSyntax)(object)val; } JoinIntoClauseSyntax joinIntoClauseSyntax = new JoinIntoClauseSyntax(SyntaxKind.JoinIntoClause, intoKeyword, identifier, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)joinIntoClauseSyntax, hash); } return joinIntoClauseSyntax; } public WhereClauseSyntax WhereClause(SyntaxToken whereKeyword, ExpressionSyntax condition) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8780, (GreenNode)(object)whereKeyword, (GreenNode)(object)condition, context, out hash); if (val != null) { return (WhereClauseSyntax)(object)val; } WhereClauseSyntax whereClauseSyntax = new WhereClauseSyntax(SyntaxKind.WhereClause, whereKeyword, condition, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)whereClauseSyntax, hash); } return whereClauseSyntax; } public OrderByClauseSyntax OrderByClause(SyntaxToken orderByKeyword, SeparatedSyntaxList orderings) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8781, (GreenNode)(object)orderByKeyword, orderings.Node, context, out hash); if (val != null) { return (OrderByClauseSyntax)(object)val; } OrderByClauseSyntax orderByClauseSyntax = new OrderByClauseSyntax(SyntaxKind.OrderByClause, orderByKeyword, orderings.Node, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)orderByClauseSyntax, hash); } return orderByClauseSyntax; } public OrderingSyntax Ordering(SyntaxKind kind, ExpressionSyntax expression, SyntaxToken? ascendingOrDescendingKeyword) { if (kind - 8782 > SyntaxKind.List) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)expression, (GreenNode)(object)ascendingOrDescendingKeyword, context, out hash); if (val != null) { return (OrderingSyntax)(object)val; } OrderingSyntax orderingSyntax = new OrderingSyntax(kind, expression, ascendingOrDescendingKeyword, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)orderingSyntax, hash); } return orderingSyntax; } public SelectClauseSyntax SelectClause(SyntaxToken selectKeyword, ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8784, (GreenNode)(object)selectKeyword, (GreenNode)(object)expression, context, out hash); if (val != null) { return (SelectClauseSyntax)(object)val; } SelectClauseSyntax selectClauseSyntax = new SelectClauseSyntax(SyntaxKind.SelectClause, selectKeyword, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)selectClauseSyntax, hash); } return selectClauseSyntax; } public GroupClauseSyntax GroupClause(SyntaxToken groupKeyword, ExpressionSyntax groupExpression, SyntaxToken byKeyword, ExpressionSyntax byExpression) { return new GroupClauseSyntax(SyntaxKind.GroupClause, groupKeyword, groupExpression, byKeyword, byExpression, context); } public QueryContinuationSyntax QueryContinuation(SyntaxToken intoKeyword, SyntaxToken identifier, QueryBodySyntax body) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8786, (GreenNode)(object)intoKeyword, (GreenNode)(object)identifier, (GreenNode)(object)body, context, out hash); if (val != null) { return (QueryContinuationSyntax)(object)val; } QueryContinuationSyntax queryContinuationSyntax = new QueryContinuationSyntax(SyntaxKind.QueryContinuation, intoKeyword, identifier, body, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)queryContinuationSyntax, hash); } return queryContinuationSyntax; } public OmittedArraySizeExpressionSyntax OmittedArraySizeExpression(SyntaxToken omittedArraySizeExpressionToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8654, (GreenNode)(object)omittedArraySizeExpressionToken, context, out hash); if (val != null) { return (OmittedArraySizeExpressionSyntax)(object)val; } OmittedArraySizeExpressionSyntax omittedArraySizeExpressionSyntax = new OmittedArraySizeExpressionSyntax(SyntaxKind.OmittedArraySizeExpression, omittedArraySizeExpressionToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)omittedArraySizeExpressionSyntax, hash); } return omittedArraySizeExpressionSyntax; } public InterpolatedStringExpressionSyntax InterpolatedStringExpression(SyntaxToken stringStartToken, SyntaxList contents, SyntaxToken stringEndToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8655, (GreenNode)(object)stringStartToken, contents.Node, (GreenNode)(object)stringEndToken, context, out hash); if (val != null) { return (InterpolatedStringExpressionSyntax)(object)val; } InterpolatedStringExpressionSyntax interpolatedStringExpressionSyntax = new InterpolatedStringExpressionSyntax(SyntaxKind.InterpolatedStringExpression, stringStartToken, contents.Node, stringEndToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)interpolatedStringExpressionSyntax, hash); } return interpolatedStringExpressionSyntax; } public IsPatternExpressionSyntax IsPatternExpression(ExpressionSyntax expression, SyntaxToken isKeyword, PatternSyntax pattern) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8657, (GreenNode)(object)expression, (GreenNode)(object)isKeyword, (GreenNode)(object)pattern, context, out hash); if (val != null) { return (IsPatternExpressionSyntax)(object)val; } IsPatternExpressionSyntax isPatternExpressionSyntax = new IsPatternExpressionSyntax(SyntaxKind.IsPatternExpression, expression, isKeyword, pattern, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)isPatternExpressionSyntax, hash); } return isPatternExpressionSyntax; } public ThrowExpressionSyntax ThrowExpression(SyntaxToken throwKeyword, ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9052, (GreenNode)(object)throwKeyword, (GreenNode)(object)expression, context, out hash); if (val != null) { return (ThrowExpressionSyntax)(object)val; } ThrowExpressionSyntax throwExpressionSyntax = new ThrowExpressionSyntax(SyntaxKind.ThrowExpression, throwKeyword, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)throwExpressionSyntax, hash); } return throwExpressionSyntax; } public WhenClauseSyntax WhenClause(SyntaxToken whenKeyword, ExpressionSyntax condition) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9013, (GreenNode)(object)whenKeyword, (GreenNode)(object)condition, context, out hash); if (val != null) { return (WhenClauseSyntax)(object)val; } WhenClauseSyntax whenClauseSyntax = new WhenClauseSyntax(SyntaxKind.WhenClause, whenKeyword, condition, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)whenClauseSyntax, hash); } return whenClauseSyntax; } public DiscardPatternSyntax DiscardPattern(SyntaxToken underscoreToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9024, (GreenNode)(object)underscoreToken, context, out hash); if (val != null) { return (DiscardPatternSyntax)(object)val; } DiscardPatternSyntax discardPatternSyntax = new DiscardPatternSyntax(SyntaxKind.DiscardPattern, underscoreToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)discardPatternSyntax, hash); } return discardPatternSyntax; } public DeclarationPatternSyntax DeclarationPattern(TypeSyntax type, VariableDesignationSyntax designation) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9000, (GreenNode)(object)type, (GreenNode)(object)designation, context, out hash); if (val != null) { return (DeclarationPatternSyntax)(object)val; } DeclarationPatternSyntax declarationPatternSyntax = new DeclarationPatternSyntax(SyntaxKind.DeclarationPattern, type, designation, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)declarationPatternSyntax, hash); } return declarationPatternSyntax; } public VarPatternSyntax VarPattern(SyntaxToken varKeyword, VariableDesignationSyntax designation) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9027, (GreenNode)(object)varKeyword, (GreenNode)(object)designation, context, out hash); if (val != null) { return (VarPatternSyntax)(object)val; } VarPatternSyntax varPatternSyntax = new VarPatternSyntax(SyntaxKind.VarPattern, varKeyword, designation, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)varPatternSyntax, hash); } return varPatternSyntax; } public RecursivePatternSyntax RecursivePattern(TypeSyntax? type, PositionalPatternClauseSyntax? positionalPatternClause, PropertyPatternClauseSyntax? propertyPatternClause, VariableDesignationSyntax? designation) { return new RecursivePatternSyntax(SyntaxKind.RecursivePattern, type, positionalPatternClause, propertyPatternClause, designation, context); } public PositionalPatternClauseSyntax PositionalPatternClause(SyntaxToken openParenToken, SeparatedSyntaxList subpatterns, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9023, (GreenNode)(object)openParenToken, subpatterns.Node, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (PositionalPatternClauseSyntax)(object)val; } PositionalPatternClauseSyntax positionalPatternClauseSyntax = new PositionalPatternClauseSyntax(SyntaxKind.PositionalPatternClause, openParenToken, subpatterns.Node, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)positionalPatternClauseSyntax, hash); } return positionalPatternClauseSyntax; } public PropertyPatternClauseSyntax PropertyPatternClause(SyntaxToken openBraceToken, SeparatedSyntaxList subpatterns, SyntaxToken closeBraceToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9021, (GreenNode)(object)openBraceToken, subpatterns.Node, (GreenNode)(object)closeBraceToken, context, out hash); if (val != null) { return (PropertyPatternClauseSyntax)(object)val; } PropertyPatternClauseSyntax propertyPatternClauseSyntax = new PropertyPatternClauseSyntax(SyntaxKind.PropertyPatternClause, openBraceToken, subpatterns.Node, closeBraceToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)propertyPatternClauseSyntax, hash); } return propertyPatternClauseSyntax; } public SubpatternSyntax Subpattern(BaseExpressionColonSyntax? expressionColon, PatternSyntax pattern) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9022, (GreenNode)(object)expressionColon, (GreenNode)(object)pattern, context, out hash); if (val != null) { return (SubpatternSyntax)(object)val; } SubpatternSyntax subpatternSyntax = new SubpatternSyntax(SyntaxKind.Subpattern, expressionColon, pattern, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)subpatternSyntax, hash); } return subpatternSyntax; } public ConstantPatternSyntax ConstantPattern(ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9002, (GreenNode)(object)expression, context, out hash); if (val != null) { return (ConstantPatternSyntax)(object)val; } ConstantPatternSyntax constantPatternSyntax = new ConstantPatternSyntax(SyntaxKind.ConstantPattern, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)constantPatternSyntax, hash); } return constantPatternSyntax; } public ParenthesizedPatternSyntax ParenthesizedPattern(SyntaxToken openParenToken, PatternSyntax pattern, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9028, (GreenNode)(object)openParenToken, (GreenNode)(object)pattern, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (ParenthesizedPatternSyntax)(object)val; } ParenthesizedPatternSyntax parenthesizedPatternSyntax = new ParenthesizedPatternSyntax(SyntaxKind.ParenthesizedPattern, openParenToken, pattern, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)parenthesizedPatternSyntax, hash); } return parenthesizedPatternSyntax; } public RelationalPatternSyntax RelationalPattern(SyntaxToken operatorToken, ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9029, (GreenNode)(object)operatorToken, (GreenNode)(object)expression, context, out hash); if (val != null) { return (RelationalPatternSyntax)(object)val; } RelationalPatternSyntax relationalPatternSyntax = new RelationalPatternSyntax(SyntaxKind.RelationalPattern, operatorToken, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)relationalPatternSyntax, hash); } return relationalPatternSyntax; } public TypePatternSyntax TypePattern(TypeSyntax type) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9030, (GreenNode)(object)type, context, out hash); if (val != null) { return (TypePatternSyntax)(object)val; } TypePatternSyntax typePatternSyntax = new TypePatternSyntax(SyntaxKind.TypePattern, type, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)typePatternSyntax, hash); } return typePatternSyntax; } public BinaryPatternSyntax BinaryPattern(SyntaxKind kind, PatternSyntax left, SyntaxToken operatorToken, PatternSyntax right) { if (kind - 9031 > SyntaxKind.List) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)left, (GreenNode)(object)operatorToken, (GreenNode)(object)right, context, out hash); if (val != null) { return (BinaryPatternSyntax)(object)val; } BinaryPatternSyntax binaryPatternSyntax = new BinaryPatternSyntax(kind, left, operatorToken, right, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)binaryPatternSyntax, hash); } return binaryPatternSyntax; } public UnaryPatternSyntax UnaryPattern(SyntaxToken operatorToken, PatternSyntax pattern) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9033, (GreenNode)(object)operatorToken, (GreenNode)(object)pattern, context, out hash); if (val != null) { return (UnaryPatternSyntax)(object)val; } UnaryPatternSyntax unaryPatternSyntax = new UnaryPatternSyntax(SyntaxKind.NotPattern, operatorToken, pattern, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)unaryPatternSyntax, hash); } return unaryPatternSyntax; } public ListPatternSyntax ListPattern(SyntaxToken openBracketToken, SeparatedSyntaxList patterns, SyntaxToken closeBracketToken, VariableDesignationSyntax? designation) { return new ListPatternSyntax(SyntaxKind.ListPattern, openBracketToken, patterns.Node, closeBracketToken, designation, context); } public SlicePatternSyntax SlicePattern(SyntaxToken dotDotToken, PatternSyntax? pattern) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9034, (GreenNode)(object)dotDotToken, (GreenNode)(object)pattern, context, out hash); if (val != null) { return (SlicePatternSyntax)(object)val; } SlicePatternSyntax slicePatternSyntax = new SlicePatternSyntax(SyntaxKind.SlicePattern, dotDotToken, pattern, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)slicePatternSyntax, hash); } return slicePatternSyntax; } public InterpolatedStringTextSyntax InterpolatedStringText(SyntaxToken textToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8919, (GreenNode)(object)textToken, context, out hash); if (val != null) { return (InterpolatedStringTextSyntax)(object)val; } InterpolatedStringTextSyntax interpolatedStringTextSyntax = new InterpolatedStringTextSyntax(SyntaxKind.InterpolatedStringText, textToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)interpolatedStringTextSyntax, hash); } return interpolatedStringTextSyntax; } public InterpolationSyntax Interpolation(SyntaxToken openBraceToken, ExpressionSyntax expression, InterpolationAlignmentClauseSyntax? alignmentClause, InterpolationFormatClauseSyntax? formatClause, SyntaxToken closeBraceToken) { return new InterpolationSyntax(SyntaxKind.Interpolation, openBraceToken, expression, alignmentClause, formatClause, closeBraceToken, context); } public InterpolationAlignmentClauseSyntax InterpolationAlignmentClause(SyntaxToken commaToken, ExpressionSyntax value) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8920, (GreenNode)(object)commaToken, (GreenNode)(object)value, context, out hash); if (val != null) { return (InterpolationAlignmentClauseSyntax)(object)val; } InterpolationAlignmentClauseSyntax interpolationAlignmentClauseSyntax = new InterpolationAlignmentClauseSyntax(SyntaxKind.InterpolationAlignmentClause, commaToken, value, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)interpolationAlignmentClauseSyntax, hash); } return interpolationAlignmentClauseSyntax; } public InterpolationFormatClauseSyntax InterpolationFormatClause(SyntaxToken colonToken, SyntaxToken formatStringToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8921, (GreenNode)(object)colonToken, (GreenNode)(object)formatStringToken, context, out hash); if (val != null) { return (InterpolationFormatClauseSyntax)(object)val; } InterpolationFormatClauseSyntax interpolationFormatClauseSyntax = new InterpolationFormatClauseSyntax(SyntaxKind.InterpolationFormatClause, colonToken, formatStringToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)interpolationFormatClauseSyntax, hash); } return interpolationFormatClauseSyntax; } public GlobalStatementSyntax GlobalStatement(SyntaxList attributeLists, SyntaxList modifiers, StatementSyntax statement) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8841, attributeLists.Node, modifiers.Node, (GreenNode)(object)statement, context, out hash); if (val != null) { return (GlobalStatementSyntax)(object)val; } GlobalStatementSyntax globalStatementSyntax = new GlobalStatementSyntax(SyntaxKind.GlobalStatement, attributeLists.Node, modifiers.Node, statement, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)globalStatementSyntax, hash); } return globalStatementSyntax; } public BlockSyntax Block(SyntaxList attributeLists, SyntaxToken openBraceToken, SyntaxList statements, SyntaxToken closeBraceToken) { return new BlockSyntax(SyntaxKind.Block, attributeLists.Node, openBraceToken, statements.Node, closeBraceToken, context); } public LocalFunctionStatementSyntax LocalFunctionStatement(SyntaxList attributeLists, SyntaxList modifiers, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax parameterList, SyntaxList constraintClauses, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken) { return new LocalFunctionStatementSyntax(SyntaxKind.LocalFunctionStatement, attributeLists.Node, modifiers.Node, returnType, identifier, typeParameterList, parameterList, constraintClauses.Node, body, expressionBody, semicolonToken, context); } public LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxList attributeLists, SyntaxToken? awaitKeyword, SyntaxToken? usingKeyword, SyntaxList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken) { return new LocalDeclarationStatementSyntax(SyntaxKind.LocalDeclarationStatement, attributeLists.Node, awaitKeyword, usingKeyword, modifiers.Node, declaration, semicolonToken, context); } public VariableDeclarationSyntax VariableDeclaration(TypeSyntax type, SeparatedSyntaxList variables) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8794, (GreenNode)(object)type, variables.Node, context, out hash); if (val != null) { return (VariableDeclarationSyntax)(object)val; } VariableDeclarationSyntax variableDeclarationSyntax = new VariableDeclarationSyntax(SyntaxKind.VariableDeclaration, type, variables.Node, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)variableDeclarationSyntax, hash); } return variableDeclarationSyntax; } public VariableDeclaratorSyntax VariableDeclarator(SyntaxToken identifier, BracketedArgumentListSyntax? argumentList, EqualsValueClauseSyntax? initializer) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8795, (GreenNode)(object)identifier, (GreenNode)(object)argumentList, (GreenNode)(object)initializer, context, out hash); if (val != null) { return (VariableDeclaratorSyntax)(object)val; } VariableDeclaratorSyntax variableDeclaratorSyntax = new VariableDeclaratorSyntax(SyntaxKind.VariableDeclarator, identifier, argumentList, initializer, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)variableDeclaratorSyntax, hash); } return variableDeclaratorSyntax; } public EqualsValueClauseSyntax EqualsValueClause(SyntaxToken equalsToken, ExpressionSyntax value) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8796, (GreenNode)(object)equalsToken, (GreenNode)(object)value, context, out hash); if (val != null) { return (EqualsValueClauseSyntax)(object)val; } EqualsValueClauseSyntax equalsValueClauseSyntax = new EqualsValueClauseSyntax(SyntaxKind.EqualsValueClause, equalsToken, value, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)equalsValueClauseSyntax, hash); } return equalsValueClauseSyntax; } public SingleVariableDesignationSyntax SingleVariableDesignation(SyntaxToken identifier) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8927, (GreenNode)(object)identifier, context, out hash); if (val != null) { return (SingleVariableDesignationSyntax)(object)val; } SingleVariableDesignationSyntax singleVariableDesignationSyntax = new SingleVariableDesignationSyntax(SyntaxKind.SingleVariableDesignation, identifier, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)singleVariableDesignationSyntax, hash); } return singleVariableDesignationSyntax; } public DiscardDesignationSyntax DiscardDesignation(SyntaxToken underscoreToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9014, (GreenNode)(object)underscoreToken, context, out hash); if (val != null) { return (DiscardDesignationSyntax)(object)val; } DiscardDesignationSyntax discardDesignationSyntax = new DiscardDesignationSyntax(SyntaxKind.DiscardDesignation, underscoreToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)discardDesignationSyntax, hash); } return discardDesignationSyntax; } public ParenthesizedVariableDesignationSyntax ParenthesizedVariableDesignation(SyntaxToken openParenToken, SeparatedSyntaxList variables, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8928, (GreenNode)(object)openParenToken, variables.Node, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (ParenthesizedVariableDesignationSyntax)(object)val; } ParenthesizedVariableDesignationSyntax parenthesizedVariableDesignationSyntax = new ParenthesizedVariableDesignationSyntax(SyntaxKind.ParenthesizedVariableDesignation, openParenToken, variables.Node, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)parenthesizedVariableDesignationSyntax, hash); } return parenthesizedVariableDesignationSyntax; } public ExpressionStatementSyntax ExpressionStatement(SyntaxList attributeLists, ExpressionSyntax expression, SyntaxToken semicolonToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8797, attributeLists.Node, (GreenNode)(object)expression, (GreenNode)(object)semicolonToken, context, out hash); if (val != null) { return (ExpressionStatementSyntax)(object)val; } ExpressionStatementSyntax expressionStatementSyntax = new ExpressionStatementSyntax(SyntaxKind.ExpressionStatement, attributeLists.Node, expression, semicolonToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)expressionStatementSyntax, hash); } return expressionStatementSyntax; } public EmptyStatementSyntax EmptyStatement(SyntaxList attributeLists, SyntaxToken semicolonToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8798, attributeLists.Node, (GreenNode)(object)semicolonToken, context, out hash); if (val != null) { return (EmptyStatementSyntax)(object)val; } EmptyStatementSyntax emptyStatementSyntax = new EmptyStatementSyntax(SyntaxKind.EmptyStatement, attributeLists.Node, semicolonToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)emptyStatementSyntax, hash); } return emptyStatementSyntax; } public LabeledStatementSyntax LabeledStatement(SyntaxList attributeLists, SyntaxToken identifier, SyntaxToken colonToken, StatementSyntax statement) { return new LabeledStatementSyntax(SyntaxKind.LabeledStatement, attributeLists.Node, identifier, colonToken, statement, context); } public GotoStatementSyntax GotoStatement(SyntaxKind kind, SyntaxList attributeLists, SyntaxToken gotoKeyword, SyntaxToken? caseOrDefaultKeyword, ExpressionSyntax? expression, SyntaxToken semicolonToken) { if (kind - 8800 > (SyntaxKind)2) { throw new ArgumentException("kind"); } return new GotoStatementSyntax(kind, attributeLists.Node, gotoKeyword, caseOrDefaultKeyword, expression, semicolonToken, context); } public BreakStatementSyntax BreakStatement(SyntaxList attributeLists, SyntaxToken breakKeyword, SyntaxToken semicolonToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8803, attributeLists.Node, (GreenNode)(object)breakKeyword, (GreenNode)(object)semicolonToken, context, out hash); if (val != null) { return (BreakStatementSyntax)(object)val; } BreakStatementSyntax breakStatementSyntax = new BreakStatementSyntax(SyntaxKind.BreakStatement, attributeLists.Node, breakKeyword, semicolonToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)breakStatementSyntax, hash); } return breakStatementSyntax; } public ContinueStatementSyntax ContinueStatement(SyntaxList attributeLists, SyntaxToken continueKeyword, SyntaxToken semicolonToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8804, attributeLists.Node, (GreenNode)(object)continueKeyword, (GreenNode)(object)semicolonToken, context, out hash); if (val != null) { return (ContinueStatementSyntax)(object)val; } ContinueStatementSyntax continueStatementSyntax = new ContinueStatementSyntax(SyntaxKind.ContinueStatement, attributeLists.Node, continueKeyword, semicolonToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)continueStatementSyntax, hash); } return continueStatementSyntax; } public ReturnStatementSyntax ReturnStatement(SyntaxList attributeLists, SyntaxToken returnKeyword, ExpressionSyntax? expression, SyntaxToken semicolonToken) { return new ReturnStatementSyntax(SyntaxKind.ReturnStatement, attributeLists.Node, returnKeyword, expression, semicolonToken, context); } public ThrowStatementSyntax ThrowStatement(SyntaxList attributeLists, SyntaxToken throwKeyword, ExpressionSyntax? expression, SyntaxToken semicolonToken) { return new ThrowStatementSyntax(SyntaxKind.ThrowStatement, attributeLists.Node, throwKeyword, expression, semicolonToken, context); } public YieldStatementSyntax YieldStatement(SyntaxKind kind, SyntaxList attributeLists, SyntaxToken yieldKeyword, SyntaxToken returnOrBreakKeyword, ExpressionSyntax? expression, SyntaxToken semicolonToken) { if (kind - 8806 > SyntaxKind.List) { throw new ArgumentException("kind"); } return new YieldStatementSyntax(kind, attributeLists.Node, yieldKeyword, returnOrBreakKeyword, expression, semicolonToken, context); } public WhileStatementSyntax WhileStatement(SyntaxList attributeLists, SyntaxToken whileKeyword, SyntaxToken openParenToken, ExpressionSyntax condition, SyntaxToken closeParenToken, StatementSyntax statement) { return new WhileStatementSyntax(SyntaxKind.WhileStatement, attributeLists.Node, whileKeyword, openParenToken, condition, closeParenToken, statement, context); } public DoStatementSyntax DoStatement(SyntaxList attributeLists, SyntaxToken doKeyword, StatementSyntax statement, SyntaxToken whileKeyword, SyntaxToken openParenToken, ExpressionSyntax condition, SyntaxToken closeParenToken, SyntaxToken semicolonToken) { return new DoStatementSyntax(SyntaxKind.DoStatement, attributeLists.Node, doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, context); } public ForStatementSyntax ForStatement(SyntaxList attributeLists, SyntaxToken forKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax? declaration, SeparatedSyntaxList initializers, SyntaxToken firstSemicolonToken, ExpressionSyntax? condition, SyntaxToken secondSemicolonToken, SeparatedSyntaxList incrementors, SyntaxToken closeParenToken, StatementSyntax statement) { return new ForStatementSyntax(SyntaxKind.ForStatement, attributeLists.Node, forKeyword, openParenToken, declaration, initializers.Node, firstSemicolonToken, condition, secondSemicolonToken, incrementors.Node, closeParenToken, statement, context); } public ForEachStatementSyntax ForEachStatement(SyntaxList attributeLists, SyntaxToken? awaitKeyword, SyntaxToken forEachKeyword, SyntaxToken openParenToken, TypeSyntax type, SyntaxToken identifier, SyntaxToken inKeyword, ExpressionSyntax expression, SyntaxToken closeParenToken, StatementSyntax statement) { return new ForEachStatementSyntax(SyntaxKind.ForEachStatement, attributeLists.Node, awaitKeyword, forEachKeyword, openParenToken, type, identifier, inKeyword, expression, closeParenToken, statement, context); } public ForEachVariableStatementSyntax ForEachVariableStatement(SyntaxList attributeLists, SyntaxToken? awaitKeyword, SyntaxToken forEachKeyword, SyntaxToken openParenToken, ExpressionSyntax variable, SyntaxToken inKeyword, ExpressionSyntax expression, SyntaxToken closeParenToken, StatementSyntax statement) { return new ForEachVariableStatementSyntax(SyntaxKind.ForEachVariableStatement, attributeLists.Node, awaitKeyword, forEachKeyword, openParenToken, variable, inKeyword, expression, closeParenToken, statement, context); } public UsingStatementSyntax UsingStatement(SyntaxList attributeLists, SyntaxToken? awaitKeyword, SyntaxToken usingKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax? declaration, ExpressionSyntax? expression, SyntaxToken closeParenToken, StatementSyntax statement) { return new UsingStatementSyntax(SyntaxKind.UsingStatement, attributeLists.Node, awaitKeyword, usingKeyword, openParenToken, declaration, expression, closeParenToken, statement, context); } public FixedStatementSyntax FixedStatement(SyntaxList attributeLists, SyntaxToken fixedKeyword, SyntaxToken openParenToken, VariableDeclarationSyntax declaration, SyntaxToken closeParenToken, StatementSyntax statement) { return new FixedStatementSyntax(SyntaxKind.FixedStatement, attributeLists.Node, fixedKeyword, openParenToken, declaration, closeParenToken, statement, context); } public CheckedStatementSyntax CheckedStatement(SyntaxKind kind, SyntaxList attributeLists, SyntaxToken keyword, BlockSyntax block) { if (kind - 8815 > SyntaxKind.List) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, attributeLists.Node, (GreenNode)(object)keyword, (GreenNode)(object)block, context, out hash); if (val != null) { return (CheckedStatementSyntax)(object)val; } CheckedStatementSyntax checkedStatementSyntax = new CheckedStatementSyntax(kind, attributeLists.Node, keyword, block, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)checkedStatementSyntax, hash); } return checkedStatementSyntax; } public UnsafeStatementSyntax UnsafeStatement(SyntaxList attributeLists, SyntaxToken unsafeKeyword, BlockSyntax block) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8817, attributeLists.Node, (GreenNode)(object)unsafeKeyword, (GreenNode)(object)block, context, out hash); if (val != null) { return (UnsafeStatementSyntax)(object)val; } UnsafeStatementSyntax unsafeStatementSyntax = new UnsafeStatementSyntax(SyntaxKind.UnsafeStatement, attributeLists.Node, unsafeKeyword, block, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)unsafeStatementSyntax, hash); } return unsafeStatementSyntax; } public LockStatementSyntax LockStatement(SyntaxList attributeLists, SyntaxToken lockKeyword, SyntaxToken openParenToken, ExpressionSyntax expression, SyntaxToken closeParenToken, StatementSyntax statement) { return new LockStatementSyntax(SyntaxKind.LockStatement, attributeLists.Node, lockKeyword, openParenToken, expression, closeParenToken, statement, context); } public IfStatementSyntax IfStatement(SyntaxList attributeLists, SyntaxToken ifKeyword, SyntaxToken openParenToken, ExpressionSyntax condition, SyntaxToken closeParenToken, StatementSyntax statement, ElseClauseSyntax? @else) { return new IfStatementSyntax(SyntaxKind.IfStatement, attributeLists.Node, ifKeyword, openParenToken, condition, closeParenToken, statement, @else, context); } public ElseClauseSyntax ElseClause(SyntaxToken elseKeyword, StatementSyntax statement) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8820, (GreenNode)(object)elseKeyword, (GreenNode)(object)statement, context, out hash); if (val != null) { return (ElseClauseSyntax)(object)val; } ElseClauseSyntax elseClauseSyntax = new ElseClauseSyntax(SyntaxKind.ElseClause, elseKeyword, statement, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)elseClauseSyntax, hash); } return elseClauseSyntax; } public SwitchStatementSyntax SwitchStatement(SyntaxList attributeLists, SyntaxToken switchKeyword, SyntaxToken? openParenToken, ExpressionSyntax expression, SyntaxToken? closeParenToken, SyntaxToken openBraceToken, SyntaxList sections, SyntaxToken closeBraceToken) { return new SwitchStatementSyntax(SyntaxKind.SwitchStatement, attributeLists.Node, switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, sections.Node, closeBraceToken, context); } public SwitchSectionSyntax SwitchSection(SyntaxList labels, SyntaxList statements) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8822, labels.Node, statements.Node, context, out hash); if (val != null) { return (SwitchSectionSyntax)(object)val; } SwitchSectionSyntax switchSectionSyntax = new SwitchSectionSyntax(SyntaxKind.SwitchSection, labels.Node, statements.Node, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)switchSectionSyntax, hash); } return switchSectionSyntax; } public CasePatternSwitchLabelSyntax CasePatternSwitchLabel(SyntaxToken keyword, PatternSyntax pattern, WhenClauseSyntax? whenClause, SyntaxToken colonToken) { return new CasePatternSwitchLabelSyntax(SyntaxKind.CasePatternSwitchLabel, keyword, pattern, whenClause, colonToken, context); } public CaseSwitchLabelSyntax CaseSwitchLabel(SyntaxToken keyword, ExpressionSyntax value, SyntaxToken colonToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8823, (GreenNode)(object)keyword, (GreenNode)(object)value, (GreenNode)(object)colonToken, context, out hash); if (val != null) { return (CaseSwitchLabelSyntax)(object)val; } CaseSwitchLabelSyntax caseSwitchLabelSyntax = new CaseSwitchLabelSyntax(SyntaxKind.CaseSwitchLabel, keyword, value, colonToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)caseSwitchLabelSyntax, hash); } return caseSwitchLabelSyntax; } public DefaultSwitchLabelSyntax DefaultSwitchLabel(SyntaxToken keyword, SyntaxToken colonToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8824, (GreenNode)(object)keyword, (GreenNode)(object)colonToken, context, out hash); if (val != null) { return (DefaultSwitchLabelSyntax)(object)val; } DefaultSwitchLabelSyntax defaultSwitchLabelSyntax = new DefaultSwitchLabelSyntax(SyntaxKind.DefaultSwitchLabel, keyword, colonToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)defaultSwitchLabelSyntax, hash); } return defaultSwitchLabelSyntax; } public SwitchExpressionSyntax SwitchExpression(ExpressionSyntax governingExpression, SyntaxToken switchKeyword, SyntaxToken openBraceToken, SeparatedSyntaxList arms, SyntaxToken closeBraceToken) { return new SwitchExpressionSyntax(SyntaxKind.SwitchExpression, governingExpression, switchKeyword, openBraceToken, arms.Node, closeBraceToken, context); } public SwitchExpressionArmSyntax SwitchExpressionArm(PatternSyntax pattern, WhenClauseSyntax? whenClause, SyntaxToken equalsGreaterThanToken, ExpressionSyntax expression) { return new SwitchExpressionArmSyntax(SyntaxKind.SwitchExpressionArm, pattern, whenClause, equalsGreaterThanToken, expression, context); } public TryStatementSyntax TryStatement(SyntaxList attributeLists, SyntaxToken tryKeyword, BlockSyntax block, SyntaxList catches, FinallyClauseSyntax? @finally) { return new TryStatementSyntax(SyntaxKind.TryStatement, attributeLists.Node, tryKeyword, block, catches.Node, @finally, context); } public CatchClauseSyntax CatchClause(SyntaxToken catchKeyword, CatchDeclarationSyntax? declaration, CatchFilterClauseSyntax? filter, BlockSyntax block) { return new CatchClauseSyntax(SyntaxKind.CatchClause, catchKeyword, declaration, filter, block, context); } public CatchDeclarationSyntax CatchDeclaration(SyntaxToken openParenToken, TypeSyntax type, SyntaxToken? identifier, SyntaxToken closeParenToken) { return new CatchDeclarationSyntax(SyntaxKind.CatchDeclaration, openParenToken, type, identifier, closeParenToken, context); } public CatchFilterClauseSyntax CatchFilterClause(SyntaxToken whenKeyword, SyntaxToken openParenToken, ExpressionSyntax filterExpression, SyntaxToken closeParenToken) { return new CatchFilterClauseSyntax(SyntaxKind.CatchFilterClause, whenKeyword, openParenToken, filterExpression, closeParenToken, context); } public FinallyClauseSyntax FinallyClause(SyntaxToken finallyKeyword, BlockSyntax block) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8829, (GreenNode)(object)finallyKeyword, (GreenNode)(object)block, context, out hash); if (val != null) { return (FinallyClauseSyntax)(object)val; } FinallyClauseSyntax finallyClauseSyntax = new FinallyClauseSyntax(SyntaxKind.FinallyClause, finallyKeyword, block, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)finallyClauseSyntax, hash); } return finallyClauseSyntax; } public CompilationUnitSyntax CompilationUnit(SyntaxList externs, SyntaxList usings, SyntaxList attributeLists, SyntaxList members, SyntaxToken endOfFileToken) { return new CompilationUnitSyntax(SyntaxKind.CompilationUnit, externs.Node, usings.Node, attributeLists.Node, members.Node, endOfFileToken, context); } public ExternAliasDirectiveSyntax ExternAliasDirective(SyntaxToken externKeyword, SyntaxToken aliasKeyword, SyntaxToken identifier, SyntaxToken semicolonToken) { return new ExternAliasDirectiveSyntax(SyntaxKind.ExternAliasDirective, externKeyword, aliasKeyword, identifier, semicolonToken, context); } public UsingDirectiveSyntax UsingDirective(SyntaxToken? globalKeyword, SyntaxToken usingKeyword, SyntaxToken? staticKeyword, SyntaxToken? unsafeKeyword, NameEqualsSyntax? alias, TypeSyntax namespaceOrType, SyntaxToken semicolonToken) { return new UsingDirectiveSyntax(SyntaxKind.UsingDirective, globalKeyword, usingKeyword, staticKeyword, unsafeKeyword, alias, namespaceOrType, semicolonToken, context); } public NamespaceDeclarationSyntax NamespaceDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken namespaceKeyword, NameSyntax name, SyntaxToken openBraceToken, SyntaxList externs, SyntaxList usings, SyntaxList members, SyntaxToken closeBraceToken, SyntaxToken? semicolonToken) { return new NamespaceDeclarationSyntax(SyntaxKind.NamespaceDeclaration, attributeLists.Node, modifiers.Node, namespaceKeyword, name, openBraceToken, externs.Node, usings.Node, members.Node, closeBraceToken, semicolonToken, context); } public FileScopedNamespaceDeclarationSyntax FileScopedNamespaceDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken namespaceKeyword, NameSyntax name, SyntaxToken semicolonToken, SyntaxList externs, SyntaxList usings, SyntaxList members) { return new FileScopedNamespaceDeclarationSyntax(SyntaxKind.FileScopedNamespaceDeclaration, attributeLists.Node, modifiers.Node, namespaceKeyword, name, semicolonToken, externs.Node, usings.Node, members.Node, context); } public AttributeListSyntax AttributeList(SyntaxToken openBracketToken, AttributeTargetSpecifierSyntax? target, SeparatedSyntaxList attributes, SyntaxToken closeBracketToken) { return new AttributeListSyntax(SyntaxKind.AttributeList, openBracketToken, target, attributes.Node, closeBracketToken, context); } public AttributeTargetSpecifierSyntax AttributeTargetSpecifier(SyntaxToken identifier, SyntaxToken colonToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8848, (GreenNode)(object)identifier, (GreenNode)(object)colonToken, context, out hash); if (val != null) { return (AttributeTargetSpecifierSyntax)(object)val; } AttributeTargetSpecifierSyntax attributeTargetSpecifierSyntax = new AttributeTargetSpecifierSyntax(SyntaxKind.AttributeTargetSpecifier, identifier, colonToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)attributeTargetSpecifierSyntax, hash); } return attributeTargetSpecifierSyntax; } public AttributeSyntax Attribute(NameSyntax name, AttributeArgumentListSyntax? argumentList) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8849, (GreenNode)(object)name, (GreenNode)(object)argumentList, context, out hash); if (val != null) { return (AttributeSyntax)(object)val; } AttributeSyntax attributeSyntax = new AttributeSyntax(SyntaxKind.Attribute, name, argumentList, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)attributeSyntax, hash); } return attributeSyntax; } public AttributeArgumentListSyntax AttributeArgumentList(SyntaxToken openParenToken, SeparatedSyntaxList arguments, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8850, (GreenNode)(object)openParenToken, arguments.Node, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (AttributeArgumentListSyntax)(object)val; } AttributeArgumentListSyntax attributeArgumentListSyntax = new AttributeArgumentListSyntax(SyntaxKind.AttributeArgumentList, openParenToken, arguments.Node, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)attributeArgumentListSyntax, hash); } return attributeArgumentListSyntax; } public AttributeArgumentSyntax AttributeArgument(NameEqualsSyntax? nameEquals, NameColonSyntax? nameColon, ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8851, (GreenNode)(object)nameEquals, (GreenNode)(object)nameColon, (GreenNode)(object)expression, context, out hash); if (val != null) { return (AttributeArgumentSyntax)(object)val; } AttributeArgumentSyntax attributeArgumentSyntax = new AttributeArgumentSyntax(SyntaxKind.AttributeArgument, nameEquals, nameColon, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)attributeArgumentSyntax, hash); } return attributeArgumentSyntax; } public NameEqualsSyntax NameEquals(IdentifierNameSyntax name, SyntaxToken equalsToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8852, (GreenNode)(object)name, (GreenNode)(object)equalsToken, context, out hash); if (val != null) { return (NameEqualsSyntax)(object)val; } NameEqualsSyntax nameEqualsSyntax = new NameEqualsSyntax(SyntaxKind.NameEquals, name, equalsToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)nameEqualsSyntax, hash); } return nameEqualsSyntax; } public TypeParameterListSyntax TypeParameterList(SyntaxToken lessThanToken, SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8909, (GreenNode)(object)lessThanToken, parameters.Node, (GreenNode)(object)greaterThanToken, context, out hash); if (val != null) { return (TypeParameterListSyntax)(object)val; } TypeParameterListSyntax typeParameterListSyntax = new TypeParameterListSyntax(SyntaxKind.TypeParameterList, lessThanToken, parameters.Node, greaterThanToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)typeParameterListSyntax, hash); } return typeParameterListSyntax; } public TypeParameterSyntax TypeParameter(SyntaxList attributeLists, SyntaxToken? varianceKeyword, SyntaxToken identifier) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8910, attributeLists.Node, (GreenNode)(object)varianceKeyword, (GreenNode)(object)identifier, context, out hash); if (val != null) { return (TypeParameterSyntax)(object)val; } TypeParameterSyntax typeParameterSyntax = new TypeParameterSyntax(SyntaxKind.TypeParameter, attributeLists.Node, varianceKeyword, identifier, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)typeParameterSyntax, hash); } return typeParameterSyntax; } public ClassDeclarationSyntax ClassDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax? parameterList, BaseListSyntax? baseList, SyntaxList constraintClauses, SyntaxToken? openBraceToken, SyntaxList members, SyntaxToken? closeBraceToken, SyntaxToken? semicolonToken) { return new ClassDeclarationSyntax(SyntaxKind.ClassDeclaration, attributeLists.Node, modifiers.Node, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses.Node, openBraceToken, members.Node, closeBraceToken, semicolonToken, context); } public StructDeclarationSyntax StructDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax? parameterList, BaseListSyntax? baseList, SyntaxList constraintClauses, SyntaxToken? openBraceToken, SyntaxList members, SyntaxToken? closeBraceToken, SyntaxToken? semicolonToken) { return new StructDeclarationSyntax(SyntaxKind.StructDeclaration, attributeLists.Node, modifiers.Node, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses.Node, openBraceToken, members.Node, closeBraceToken, semicolonToken, context); } public InterfaceDeclarationSyntax InterfaceDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax? parameterList, BaseListSyntax? baseList, SyntaxList constraintClauses, SyntaxToken? openBraceToken, SyntaxList members, SyntaxToken? closeBraceToken, SyntaxToken? semicolonToken) { return new InterfaceDeclarationSyntax(SyntaxKind.InterfaceDeclaration, attributeLists.Node, modifiers.Node, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses.Node, openBraceToken, members.Node, closeBraceToken, semicolonToken, context); } public RecordDeclarationSyntax RecordDeclaration(SyntaxKind kind, SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken keyword, SyntaxToken? classOrStructKeyword, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax? parameterList, BaseListSyntax? baseList, SyntaxList constraintClauses, SyntaxToken? openBraceToken, SyntaxList members, SyntaxToken? closeBraceToken, SyntaxToken? semicolonToken) { if (kind != SyntaxKind.RecordDeclaration && kind != SyntaxKind.RecordStructDeclaration) { throw new ArgumentException("kind"); } return new RecordDeclarationSyntax(kind, attributeLists.Node, modifiers.Node, keyword, classOrStructKeyword, identifier, typeParameterList, parameterList, baseList, constraintClauses.Node, openBraceToken, members.Node, closeBraceToken, semicolonToken, context); } public EnumDeclarationSyntax EnumDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken enumKeyword, SyntaxToken identifier, BaseListSyntax? baseList, SyntaxToken? openBraceToken, SeparatedSyntaxList members, SyntaxToken? closeBraceToken, SyntaxToken? semicolonToken) { return new EnumDeclarationSyntax(SyntaxKind.EnumDeclaration, attributeLists.Node, modifiers.Node, enumKeyword, identifier, baseList, openBraceToken, members.Node, closeBraceToken, semicolonToken, context); } public DelegateDeclarationSyntax DelegateDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken delegateKeyword, TypeSyntax returnType, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax parameterList, SyntaxList constraintClauses, SyntaxToken semicolonToken) { return new DelegateDeclarationSyntax(SyntaxKind.DelegateDeclaration, attributeLists.Node, modifiers.Node, delegateKeyword, returnType, identifier, typeParameterList, parameterList, constraintClauses.Node, semicolonToken, context); } public EnumMemberDeclarationSyntax EnumMemberDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken identifier, EqualsValueClauseSyntax? equalsValue) { return new EnumMemberDeclarationSyntax(SyntaxKind.EnumMemberDeclaration, attributeLists.Node, modifiers.Node, identifier, equalsValue, context); } public BaseListSyntax BaseList(SyntaxToken colonToken, SeparatedSyntaxList types) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8864, (GreenNode)(object)colonToken, types.Node, context, out hash); if (val != null) { return (BaseListSyntax)(object)val; } BaseListSyntax baseListSyntax = new BaseListSyntax(SyntaxKind.BaseList, colonToken, types.Node, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)baseListSyntax, hash); } return baseListSyntax; } public SimpleBaseTypeSyntax SimpleBaseType(TypeSyntax type) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8865, (GreenNode)(object)type, context, out hash); if (val != null) { return (SimpleBaseTypeSyntax)(object)val; } SimpleBaseTypeSyntax simpleBaseTypeSyntax = new SimpleBaseTypeSyntax(SyntaxKind.SimpleBaseType, type, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)simpleBaseTypeSyntax, hash); } return simpleBaseTypeSyntax; } public PrimaryConstructorBaseTypeSyntax PrimaryConstructorBaseType(TypeSyntax type, ArgumentListSyntax argumentList) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9065, (GreenNode)(object)type, (GreenNode)(object)argumentList, context, out hash); if (val != null) { return (PrimaryConstructorBaseTypeSyntax)(object)val; } PrimaryConstructorBaseTypeSyntax primaryConstructorBaseTypeSyntax = new PrimaryConstructorBaseTypeSyntax(SyntaxKind.PrimaryConstructorBaseType, type, argumentList, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)primaryConstructorBaseTypeSyntax, hash); } return primaryConstructorBaseTypeSyntax; } public TypeParameterConstraintClauseSyntax TypeParameterConstraintClause(SyntaxToken whereKeyword, IdentifierNameSyntax name, SyntaxToken colonToken, SeparatedSyntaxList constraints) { return new TypeParameterConstraintClauseSyntax(SyntaxKind.TypeParameterConstraintClause, whereKeyword, name, colonToken, constraints.Node, context); } public ConstructorConstraintSyntax ConstructorConstraint(SyntaxToken newKeyword, SyntaxToken openParenToken, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8867, (GreenNode)(object)newKeyword, (GreenNode)(object)openParenToken, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (ConstructorConstraintSyntax)(object)val; } ConstructorConstraintSyntax constructorConstraintSyntax = new ConstructorConstraintSyntax(SyntaxKind.ConstructorConstraint, newKeyword, openParenToken, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)constructorConstraintSyntax, hash); } return constructorConstraintSyntax; } public ClassOrStructConstraintSyntax ClassOrStructConstraint(SyntaxKind kind, SyntaxToken classOrStructKeyword, SyntaxToken? questionToken) { if (kind - 8868 > SyntaxKind.List) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)classOrStructKeyword, (GreenNode)(object)questionToken, context, out hash); if (val != null) { return (ClassOrStructConstraintSyntax)(object)val; } ClassOrStructConstraintSyntax classOrStructConstraintSyntax = new ClassOrStructConstraintSyntax(kind, classOrStructKeyword, questionToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)classOrStructConstraintSyntax, hash); } return classOrStructConstraintSyntax; } public TypeConstraintSyntax TypeConstraint(TypeSyntax type) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8870, (GreenNode)(object)type, context, out hash); if (val != null) { return (TypeConstraintSyntax)(object)val; } TypeConstraintSyntax typeConstraintSyntax = new TypeConstraintSyntax(SyntaxKind.TypeConstraint, type, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)typeConstraintSyntax, hash); } return typeConstraintSyntax; } public DefaultConstraintSyntax DefaultConstraint(SyntaxToken defaultKeyword) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9064, (GreenNode)(object)defaultKeyword, context, out hash); if (val != null) { return (DefaultConstraintSyntax)(object)val; } DefaultConstraintSyntax defaultConstraintSyntax = new DefaultConstraintSyntax(SyntaxKind.DefaultConstraint, defaultKeyword, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)defaultConstraintSyntax, hash); } return defaultConstraintSyntax; } public FieldDeclarationSyntax FieldDeclaration(SyntaxList attributeLists, SyntaxList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken) { return new FieldDeclarationSyntax(SyntaxKind.FieldDeclaration, attributeLists.Node, modifiers.Node, declaration, semicolonToken, context); } public EventFieldDeclarationSyntax EventFieldDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken eventKeyword, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken) { return new EventFieldDeclarationSyntax(SyntaxKind.EventFieldDeclaration, attributeLists.Node, modifiers.Node, eventKeyword, declaration, semicolonToken, context); } public ExplicitInterfaceSpecifierSyntax ExplicitInterfaceSpecifier(NameSyntax name, SyntaxToken dotToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8871, (GreenNode)(object)name, (GreenNode)(object)dotToken, context, out hash); if (val != null) { return (ExplicitInterfaceSpecifierSyntax)(object)val; } ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifierSyntax = new ExplicitInterfaceSpecifierSyntax(SyntaxKind.ExplicitInterfaceSpecifier, name, dotToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)explicitInterfaceSpecifierSyntax, hash); } return explicitInterfaceSpecifierSyntax; } public MethodDeclarationSyntax MethodDeclaration(SyntaxList attributeLists, SyntaxList modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, TypeParameterListSyntax? typeParameterList, ParameterListSyntax parameterList, SyntaxList constraintClauses, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken) { return new MethodDeclarationSyntax(SyntaxKind.MethodDeclaration, attributeLists.Node, modifiers.Node, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses.Node, body, expressionBody, semicolonToken, context); } public OperatorDeclarationSyntax OperatorDeclaration(SyntaxList attributeLists, SyntaxList modifiers, TypeSyntax returnType, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken? checkedKeyword, SyntaxToken operatorToken, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken) { return new OperatorDeclarationSyntax(SyntaxKind.OperatorDeclaration, attributeLists.Node, modifiers.Node, returnType, explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken, context); } public ConversionOperatorDeclarationSyntax ConversionOperatorDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken implicitOrExplicitKeyword, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken operatorKeyword, SyntaxToken? checkedKeyword, TypeSyntax type, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken) { return new ConversionOperatorDeclarationSyntax(SyntaxKind.ConversionOperatorDeclaration, attributeLists.Node, modifiers.Node, implicitOrExplicitKeyword, explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, type, parameterList, body, expressionBody, semicolonToken, context); } public ConstructorDeclarationSyntax ConstructorDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken identifier, ParameterListSyntax parameterList, ConstructorInitializerSyntax? initializer, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken) { return new ConstructorDeclarationSyntax(SyntaxKind.ConstructorDeclaration, attributeLists.Node, modifiers.Node, identifier, parameterList, initializer, body, expressionBody, semicolonToken, context); } public ConstructorInitializerSyntax ConstructorInitializer(SyntaxKind kind, SyntaxToken colonToken, SyntaxToken thisOrBaseKeyword, ArgumentListSyntax argumentList) { if (kind - 8889 > SyntaxKind.List) { throw new ArgumentException("kind"); } int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode((int)kind, (GreenNode)(object)colonToken, (GreenNode)(object)thisOrBaseKeyword, (GreenNode)(object)argumentList, context, out hash); if (val != null) { return (ConstructorInitializerSyntax)(object)val; } ConstructorInitializerSyntax constructorInitializerSyntax = new ConstructorInitializerSyntax(kind, colonToken, thisOrBaseKeyword, argumentList, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)constructorInitializerSyntax, hash); } return constructorInitializerSyntax; } public DestructorDeclarationSyntax DestructorDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken tildeToken, SyntaxToken identifier, ParameterListSyntax parameterList, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken) { return new DestructorDeclarationSyntax(SyntaxKind.DestructorDeclaration, attributeLists.Node, modifiers.Node, tildeToken, identifier, parameterList, body, expressionBody, semicolonToken, context); } public PropertyDeclarationSyntax PropertyDeclaration(SyntaxList attributeLists, SyntaxList modifiers, TypeSyntax type, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, AccessorListSyntax? accessorList, ArrowExpressionClauseSyntax? expressionBody, EqualsValueClauseSyntax? initializer, SyntaxToken? semicolonToken) { return new PropertyDeclarationSyntax(SyntaxKind.PropertyDeclaration, attributeLists.Node, modifiers.Node, type, explicitInterfaceSpecifier, identifier, accessorList, expressionBody, initializer, semicolonToken, context); } public ArrowExpressionClauseSyntax ArrowExpressionClause(SyntaxToken arrowToken, ExpressionSyntax expression) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8917, (GreenNode)(object)arrowToken, (GreenNode)(object)expression, context, out hash); if (val != null) { return (ArrowExpressionClauseSyntax)(object)val; } ArrowExpressionClauseSyntax arrowExpressionClauseSyntax = new ArrowExpressionClauseSyntax(SyntaxKind.ArrowExpressionClause, arrowToken, expression, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)arrowExpressionClauseSyntax, hash); } return arrowExpressionClauseSyntax; } public EventDeclarationSyntax EventDeclaration(SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken eventKeyword, TypeSyntax type, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken identifier, AccessorListSyntax? accessorList, SyntaxToken? semicolonToken) { return new EventDeclarationSyntax(SyntaxKind.EventDeclaration, attributeLists.Node, modifiers.Node, eventKeyword, type, explicitInterfaceSpecifier, identifier, accessorList, semicolonToken, context); } public IndexerDeclarationSyntax IndexerDeclaration(SyntaxList attributeLists, SyntaxList modifiers, TypeSyntax type, ExplicitInterfaceSpecifierSyntax? explicitInterfaceSpecifier, SyntaxToken thisKeyword, BracketedParameterListSyntax parameterList, AccessorListSyntax? accessorList, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken) { return new IndexerDeclarationSyntax(SyntaxKind.IndexerDeclaration, attributeLists.Node, modifiers.Node, type, explicitInterfaceSpecifier, thisKeyword, parameterList, accessorList, expressionBody, semicolonToken, context); } public AccessorListSyntax AccessorList(SyntaxToken openBraceToken, SyntaxList accessors, SyntaxToken closeBraceToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8895, (GreenNode)(object)openBraceToken, accessors.Node, (GreenNode)(object)closeBraceToken, context, out hash); if (val != null) { return (AccessorListSyntax)(object)val; } AccessorListSyntax accessorListSyntax = new AccessorListSyntax(SyntaxKind.AccessorList, openBraceToken, accessors.Node, closeBraceToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)accessorListSyntax, hash); } return accessorListSyntax; } public AccessorDeclarationSyntax AccessorDeclaration(SyntaxKind kind, SyntaxList attributeLists, SyntaxList modifiers, SyntaxToken keyword, BlockSyntax? body, ArrowExpressionClauseSyntax? expressionBody, SyntaxToken? semicolonToken) { if (kind - 8896 > (SyntaxKind)4 && kind != SyntaxKind.InitAccessorDeclaration) { throw new ArgumentException("kind"); } return new AccessorDeclarationSyntax(kind, attributeLists.Node, modifiers.Node, keyword, body, expressionBody, semicolonToken, context); } public ParameterListSyntax ParameterList(SyntaxToken openParenToken, SeparatedSyntaxList parameters, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8906, (GreenNode)(object)openParenToken, parameters.Node, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (ParameterListSyntax)(object)val; } ParameterListSyntax parameterListSyntax = new ParameterListSyntax(SyntaxKind.ParameterList, openParenToken, parameters.Node, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)parameterListSyntax, hash); } return parameterListSyntax; } public BracketedParameterListSyntax BracketedParameterList(SyntaxToken openBracketToken, SeparatedSyntaxList parameters, SyntaxToken closeBracketToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8907, (GreenNode)(object)openBracketToken, parameters.Node, (GreenNode)(object)closeBracketToken, context, out hash); if (val != null) { return (BracketedParameterListSyntax)(object)val; } BracketedParameterListSyntax bracketedParameterListSyntax = new BracketedParameterListSyntax(SyntaxKind.BracketedParameterList, openBracketToken, parameters.Node, closeBracketToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)bracketedParameterListSyntax, hash); } return bracketedParameterListSyntax; } public ParameterSyntax Parameter(SyntaxList attributeLists, SyntaxList modifiers, TypeSyntax? type, SyntaxToken identifier, EqualsValueClauseSyntax? @default) { return new ParameterSyntax(SyntaxKind.Parameter, attributeLists.Node, modifiers.Node, type, identifier, @default, context); } public FunctionPointerParameterSyntax FunctionPointerParameter(SyntaxList attributeLists, SyntaxList modifiers, TypeSyntax type) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(9057, attributeLists.Node, modifiers.Node, (GreenNode)(object)type, context, out hash); if (val != null) { return (FunctionPointerParameterSyntax)(object)val; } FunctionPointerParameterSyntax functionPointerParameterSyntax = new FunctionPointerParameterSyntax(SyntaxKind.FunctionPointerParameter, attributeLists.Node, modifiers.Node, type, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)functionPointerParameterSyntax, hash); } return functionPointerParameterSyntax; } public IncompleteMemberSyntax IncompleteMember(SyntaxList attributeLists, SyntaxList modifiers, TypeSyntax? type) { return new IncompleteMemberSyntax(SyntaxKind.IncompleteMember, attributeLists.Node, modifiers.Node, type, context); } public SkippedTokensTriviaSyntax SkippedTokensTrivia(SyntaxList tokens) { return new SkippedTokensTriviaSyntax(SyntaxKind.SkippedTokensTrivia, tokens.Node, context); } public DocumentationCommentTriviaSyntax DocumentationCommentTrivia(SyntaxKind kind, SyntaxList content, SyntaxToken endOfComment) { if (kind - 8544 > SyntaxKind.List) { throw new ArgumentException("kind"); } return new DocumentationCommentTriviaSyntax(kind, content.Node, endOfComment, context); } public TypeCrefSyntax TypeCref(TypeSyntax type) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8597, (GreenNode)(object)type, context, out hash); if (val != null) { return (TypeCrefSyntax)(object)val; } TypeCrefSyntax typeCrefSyntax = new TypeCrefSyntax(SyntaxKind.TypeCref, type, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)typeCrefSyntax, hash); } return typeCrefSyntax; } public QualifiedCrefSyntax QualifiedCref(TypeSyntax container, SyntaxToken dotToken, MemberCrefSyntax member) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8598, (GreenNode)(object)container, (GreenNode)(object)dotToken, (GreenNode)(object)member, context, out hash); if (val != null) { return (QualifiedCrefSyntax)(object)val; } QualifiedCrefSyntax qualifiedCrefSyntax = new QualifiedCrefSyntax(SyntaxKind.QualifiedCref, container, dotToken, member, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)qualifiedCrefSyntax, hash); } return qualifiedCrefSyntax; } public NameMemberCrefSyntax NameMemberCref(TypeSyntax name, CrefParameterListSyntax? parameters) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8599, (GreenNode)(object)name, (GreenNode)(object)parameters, context, out hash); if (val != null) { return (NameMemberCrefSyntax)(object)val; } NameMemberCrefSyntax nameMemberCrefSyntax = new NameMemberCrefSyntax(SyntaxKind.NameMemberCref, name, parameters, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)nameMemberCrefSyntax, hash); } return nameMemberCrefSyntax; } public IndexerMemberCrefSyntax IndexerMemberCref(SyntaxToken thisKeyword, CrefBracketedParameterListSyntax? parameters) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8600, (GreenNode)(object)thisKeyword, (GreenNode)(object)parameters, context, out hash); if (val != null) { return (IndexerMemberCrefSyntax)(object)val; } IndexerMemberCrefSyntax indexerMemberCrefSyntax = new IndexerMemberCrefSyntax(SyntaxKind.IndexerMemberCref, thisKeyword, parameters, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)indexerMemberCrefSyntax, hash); } return indexerMemberCrefSyntax; } public OperatorMemberCrefSyntax OperatorMemberCref(SyntaxToken operatorKeyword, SyntaxToken? checkedKeyword, SyntaxToken operatorToken, CrefParameterListSyntax? parameters) { return new OperatorMemberCrefSyntax(SyntaxKind.OperatorMemberCref, operatorKeyword, checkedKeyword, operatorToken, parameters, context); } public ConversionOperatorMemberCrefSyntax ConversionOperatorMemberCref(SyntaxToken implicitOrExplicitKeyword, SyntaxToken operatorKeyword, SyntaxToken? checkedKeyword, TypeSyntax type, CrefParameterListSyntax? parameters) { return new ConversionOperatorMemberCrefSyntax(SyntaxKind.ConversionOperatorMemberCref, implicitOrExplicitKeyword, operatorKeyword, checkedKeyword, type, parameters, context); } public CrefParameterListSyntax CrefParameterList(SyntaxToken openParenToken, SeparatedSyntaxList parameters, SyntaxToken closeParenToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8603, (GreenNode)(object)openParenToken, parameters.Node, (GreenNode)(object)closeParenToken, context, out hash); if (val != null) { return (CrefParameterListSyntax)(object)val; } CrefParameterListSyntax crefParameterListSyntax = new CrefParameterListSyntax(SyntaxKind.CrefParameterList, openParenToken, parameters.Node, closeParenToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)crefParameterListSyntax, hash); } return crefParameterListSyntax; } public CrefBracketedParameterListSyntax CrefBracketedParameterList(SyntaxToken openBracketToken, SeparatedSyntaxList parameters, SyntaxToken closeBracketToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8604, (GreenNode)(object)openBracketToken, parameters.Node, (GreenNode)(object)closeBracketToken, context, out hash); if (val != null) { return (CrefBracketedParameterListSyntax)(object)val; } CrefBracketedParameterListSyntax crefBracketedParameterListSyntax = new CrefBracketedParameterListSyntax(SyntaxKind.CrefBracketedParameterList, openBracketToken, parameters.Node, closeBracketToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)crefBracketedParameterListSyntax, hash); } return crefBracketedParameterListSyntax; } public CrefParameterSyntax CrefParameter(SyntaxToken? refKindKeyword, SyntaxToken? readOnlyKeyword, TypeSyntax type) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8605, (GreenNode)(object)refKindKeyword, (GreenNode)(object)readOnlyKeyword, (GreenNode)(object)type, context, out hash); if (val != null) { return (CrefParameterSyntax)(object)val; } CrefParameterSyntax crefParameterSyntax = new CrefParameterSyntax(SyntaxKind.CrefParameter, refKindKeyword, readOnlyKeyword, type, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)crefParameterSyntax, hash); } return crefParameterSyntax; } public XmlElementSyntax XmlElement(XmlElementStartTagSyntax startTag, SyntaxList content, XmlElementEndTagSyntax endTag) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8574, (GreenNode)(object)startTag, content.Node, (GreenNode)(object)endTag, context, out hash); if (val != null) { return (XmlElementSyntax)(object)val; } XmlElementSyntax xmlElementSyntax = new XmlElementSyntax(SyntaxKind.XmlElement, startTag, content.Node, endTag, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)xmlElementSyntax, hash); } return xmlElementSyntax; } public XmlElementStartTagSyntax XmlElementStartTag(SyntaxToken lessThanToken, XmlNameSyntax name, SyntaxList attributes, SyntaxToken greaterThanToken) { return new XmlElementStartTagSyntax(SyntaxKind.XmlElementStartTag, lessThanToken, name, attributes.Node, greaterThanToken, context); } public XmlElementEndTagSyntax XmlElementEndTag(SyntaxToken lessThanSlashToken, XmlNameSyntax name, SyntaxToken greaterThanToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8576, (GreenNode)(object)lessThanSlashToken, (GreenNode)(object)name, (GreenNode)(object)greaterThanToken, context, out hash); if (val != null) { return (XmlElementEndTagSyntax)(object)val; } XmlElementEndTagSyntax xmlElementEndTagSyntax = new XmlElementEndTagSyntax(SyntaxKind.XmlElementEndTag, lessThanSlashToken, name, greaterThanToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)xmlElementEndTagSyntax, hash); } return xmlElementEndTagSyntax; } public XmlEmptyElementSyntax XmlEmptyElement(SyntaxToken lessThanToken, XmlNameSyntax name, SyntaxList attributes, SyntaxToken slashGreaterThanToken) { return new XmlEmptyElementSyntax(SyntaxKind.XmlEmptyElement, lessThanToken, name, attributes.Node, slashGreaterThanToken, context); } public XmlNameSyntax XmlName(XmlPrefixSyntax? prefix, SyntaxToken localName) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8581, (GreenNode)(object)prefix, (GreenNode)(object)localName, context, out hash); if (val != null) { return (XmlNameSyntax)(object)val; } XmlNameSyntax xmlNameSyntax = new XmlNameSyntax(SyntaxKind.XmlName, prefix, localName, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)xmlNameSyntax, hash); } return xmlNameSyntax; } public XmlPrefixSyntax XmlPrefix(SyntaxToken prefix, SyntaxToken colonToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8582, (GreenNode)(object)prefix, (GreenNode)(object)colonToken, context, out hash); if (val != null) { return (XmlPrefixSyntax)(object)val; } XmlPrefixSyntax xmlPrefixSyntax = new XmlPrefixSyntax(SyntaxKind.XmlPrefix, prefix, colonToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)xmlPrefixSyntax, hash); } return xmlPrefixSyntax; } public XmlTextAttributeSyntax XmlTextAttribute(XmlNameSyntax name, SyntaxToken equalsToken, SyntaxToken startQuoteToken, SyntaxList textTokens, SyntaxToken endQuoteToken) { return new XmlTextAttributeSyntax(SyntaxKind.XmlTextAttribute, name, equalsToken, startQuoteToken, textTokens.Node, endQuoteToken, context); } public XmlCrefAttributeSyntax XmlCrefAttribute(XmlNameSyntax name, SyntaxToken equalsToken, SyntaxToken startQuoteToken, CrefSyntax cref, SyntaxToken endQuoteToken) { return new XmlCrefAttributeSyntax(SyntaxKind.XmlCrefAttribute, name, equalsToken, startQuoteToken, cref, endQuoteToken, context); } public XmlNameAttributeSyntax XmlNameAttribute(XmlNameSyntax name, SyntaxToken equalsToken, SyntaxToken startQuoteToken, IdentifierNameSyntax identifier, SyntaxToken endQuoteToken) { return new XmlNameAttributeSyntax(SyntaxKind.XmlNameAttribute, name, equalsToken, startQuoteToken, identifier, endQuoteToken, context); } public XmlTextSyntax XmlText(SyntaxList textTokens) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8583, textTokens.Node, context, out hash); if (val != null) { return (XmlTextSyntax)(object)val; } XmlTextSyntax xmlTextSyntax = new XmlTextSyntax(SyntaxKind.XmlText, textTokens.Node, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)xmlTextSyntax, hash); } return xmlTextSyntax; } public XmlCDataSectionSyntax XmlCDataSection(SyntaxToken startCDataToken, SyntaxList textTokens, SyntaxToken endCDataToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8584, (GreenNode)(object)startCDataToken, textTokens.Node, (GreenNode)(object)endCDataToken, context, out hash); if (val != null) { return (XmlCDataSectionSyntax)(object)val; } XmlCDataSectionSyntax xmlCDataSectionSyntax = new XmlCDataSectionSyntax(SyntaxKind.XmlCDataSection, startCDataToken, textTokens.Node, endCDataToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)xmlCDataSectionSyntax, hash); } return xmlCDataSectionSyntax; } public XmlProcessingInstructionSyntax XmlProcessingInstruction(SyntaxToken startProcessingInstructionToken, XmlNameSyntax name, SyntaxList textTokens, SyntaxToken endProcessingInstructionToken) { return new XmlProcessingInstructionSyntax(SyntaxKind.XmlProcessingInstruction, startProcessingInstructionToken, name, textTokens.Node, endProcessingInstructionToken, context); } public XmlCommentSyntax XmlComment(SyntaxToken lessThanExclamationMinusMinusToken, SyntaxList textTokens, SyntaxToken minusMinusGreaterThanToken) { int hash; GreenNode val = CSharpSyntaxNodeCache.TryGetNode(8585, (GreenNode)(object)lessThanExclamationMinusMinusToken, textTokens.Node, (GreenNode)(object)minusMinusGreaterThanToken, context, out hash); if (val != null) { return (XmlCommentSyntax)(object)val; } XmlCommentSyntax xmlCommentSyntax = new XmlCommentSyntax(SyntaxKind.XmlComment, lessThanExclamationMinusMinusToken, textTokens.Node, minusMinusGreaterThanToken, context); if (hash >= 0) { SyntaxNodeCache.AddNode((GreenNode)(object)xmlCommentSyntax, hash); } return xmlCommentSyntax; } public IfDirectiveTriviaSyntax IfDirectiveTrivia(SyntaxToken hashToken, SyntaxToken ifKeyword, ExpressionSyntax condition, SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue) { return new IfDirectiveTriviaSyntax(SyntaxKind.IfDirectiveTrivia, hashToken, ifKeyword, condition, endOfDirectiveToken, isActive, branchTaken, conditionValue, context); } public ElifDirectiveTriviaSyntax ElifDirectiveTrivia(SyntaxToken hashToken, SyntaxToken elifKeyword, ExpressionSyntax condition, SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken, bool conditionValue) { return new ElifDirectiveTriviaSyntax(SyntaxKind.ElifDirectiveTrivia, hashToken, elifKeyword, condition, endOfDirectiveToken, isActive, branchTaken, conditionValue, context); } public ElseDirectiveTriviaSyntax ElseDirectiveTrivia(SyntaxToken hashToken, SyntaxToken elseKeyword, SyntaxToken endOfDirectiveToken, bool isActive, bool branchTaken) { return new ElseDirectiveTriviaSyntax(SyntaxKind.ElseDirectiveTrivia, hashToken, elseKeyword, endOfDirectiveToken, isActive, branchTaken, context); } public EndIfDirectiveTriviaSyntax EndIfDirectiveTrivia(SyntaxToken hashToken, SyntaxToken endIfKeyword, SyntaxToken endOfDirectiveToken, bool isActive) { return new EndIfDirectiveTriviaSyntax(SyntaxKind.EndIfDirectiveTrivia, hashToken, endIfKeyword, endOfDirectiveToken, isActive, context); } public RegionDirectiveTriviaSyntax RegionDirectiveTrivia(SyntaxToken hashToken, SyntaxToken regionKeyword, SyntaxToken endOfDirectiveToken, bool isActive) { return new RegionDirectiveTriviaSyntax(SyntaxKind.RegionDirectiveTrivia, hashToken, regionKeyword, endOfDirectiveToken, isActive, context); } public EndRegionDirectiveTriviaSyntax EndRegionDirectiveTrivia(SyntaxToken hashToken, SyntaxToken endRegionKeyword, SyntaxToken endOfDirectiveToken, bool isActive) { return new EndRegionDirectiveTriviaSyntax(SyntaxKind.EndRegionDirectiveTrivia, hashToken, endRegionKeyword, endOfDirectiveToken, isActive, context); } public ErrorDirectiveTriviaSyntax ErrorDirectiveTrivia(SyntaxToken hashToken, SyntaxToken errorKeyword, SyntaxToken endOfDirectiveToken, bool isActive) { return new ErrorDirectiveTriviaSyntax(SyntaxKind.ErrorDirectiveTrivia, hashToken, errorKeyword, endOfDirectiveToken, isActive, context); } public WarningDirectiveTriviaSyntax WarningDirectiveTrivia(SyntaxToken hashToken, SyntaxToken warningKeyword, SyntaxToken endOfDirectiveToken, bool isActive) { return new WarningDirectiveTriviaSyntax(SyntaxKind.WarningDirectiveTrivia, hashToken, warningKeyword, endOfDirectiveToken, isActive, context); } public BadDirectiveTriviaSyntax BadDirectiveTrivia(SyntaxToken hashToken, SyntaxToken identifier, SyntaxToken endOfDirectiveToken, bool isActive) { return new BadDirectiveTriviaSyntax(SyntaxKind.BadDirectiveTrivia, hashToken, identifier, endOfDirectiveToken, isActive, context); } public DefineDirectiveTriviaSyntax DefineDirectiveTrivia(SyntaxToken hashToken, SyntaxToken defineKeyword, SyntaxToken name, SyntaxToken endOfDirectiveToken, bool isActive) { return new DefineDirectiveTriviaSyntax(SyntaxKind.DefineDirectiveTrivia, hashToken, defineKeyword, name, endOfDirectiveToken, isActive, context); } public UndefDirectiveTriviaSyntax UndefDirectiveTrivia(SyntaxToken hashToken, SyntaxToken undefKeyword, SyntaxToken name, SyntaxToken endOfDirectiveToken, bool isActive) { return new UndefDirectiveTriviaSyntax(SyntaxKind.UndefDirectiveTrivia, hashToken, undefKeyword, name, endOfDirectiveToken, isActive, context); } public LineDirectiveTriviaSyntax LineDirectiveTrivia(SyntaxToken hashToken, SyntaxToken lineKeyword, SyntaxToken line, SyntaxToken? file, SyntaxToken endOfDirectiveToken, bool isActive) { return new LineDirectiveTriviaSyntax(SyntaxKind.LineDirectiveTrivia, hashToken, lineKeyword, line, file, endOfDirectiveToken, isActive, context); } public LineDirectivePositionSyntax LineDirectivePosition(SyntaxToken openParenToken, SyntaxToken line, SyntaxToken commaToken, SyntaxToken character, SyntaxToken closeParenToken) { return new LineDirectivePositionSyntax(SyntaxKind.LineDirectivePosition, openParenToken, line, commaToken, character, closeParenToken, context); } public LineSpanDirectiveTriviaSyntax LineSpanDirectiveTrivia(SyntaxToken hashToken, SyntaxToken lineKeyword, LineDirectivePositionSyntax start, SyntaxToken minusToken, LineDirectivePositionSyntax end, SyntaxToken? characterOffset, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive) { return new LineSpanDirectiveTriviaSyntax(SyntaxKind.LineSpanDirectiveTrivia, hashToken, lineKeyword, start, minusToken, end, characterOffset, file, endOfDirectiveToken, isActive, context); } public PragmaWarningDirectiveTriviaSyntax PragmaWarningDirectiveTrivia(SyntaxToken hashToken, SyntaxToken pragmaKeyword, SyntaxToken warningKeyword, SyntaxToken disableOrRestoreKeyword, SeparatedSyntaxList errorCodes, SyntaxToken endOfDirectiveToken, bool isActive) { return new PragmaWarningDirectiveTriviaSyntax(SyntaxKind.PragmaWarningDirectiveTrivia, hashToken, pragmaKeyword, warningKeyword, disableOrRestoreKeyword, errorCodes.Node, endOfDirectiveToken, isActive, context); } public PragmaChecksumDirectiveTriviaSyntax PragmaChecksumDirectiveTrivia(SyntaxToken hashToken, SyntaxToken pragmaKeyword, SyntaxToken checksumKeyword, SyntaxToken file, SyntaxToken guid, SyntaxToken bytes, SyntaxToken endOfDirectiveToken, bool isActive) { return new PragmaChecksumDirectiveTriviaSyntax(SyntaxKind.PragmaChecksumDirectiveTrivia, hashToken, pragmaKeyword, checksumKeyword, file, guid, bytes, endOfDirectiveToken, isActive, context); } public ReferenceDirectiveTriviaSyntax ReferenceDirectiveTrivia(SyntaxToken hashToken, SyntaxToken referenceKeyword, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive) { return new ReferenceDirectiveTriviaSyntax(SyntaxKind.ReferenceDirectiveTrivia, hashToken, referenceKeyword, file, endOfDirectiveToken, isActive, context); } public LoadDirectiveTriviaSyntax LoadDirectiveTrivia(SyntaxToken hashToken, SyntaxToken loadKeyword, SyntaxToken file, SyntaxToken endOfDirectiveToken, bool isActive) { return new LoadDirectiveTriviaSyntax(SyntaxKind.LoadDirectiveTrivia, hashToken, loadKeyword, file, endOfDirectiveToken, isActive, context); } public ShebangDirectiveTriviaSyntax ShebangDirectiveTrivia(SyntaxToken hashToken, SyntaxToken exclamationToken, SyntaxToken endOfDirectiveToken, bool isActive) { return new ShebangDirectiveTriviaSyntax(SyntaxKind.ShebangDirectiveTrivia, hashToken, exclamationToken, endOfDirectiveToken, isActive, context); } public NullableDirectiveTriviaSyntax NullableDirectiveTrivia(SyntaxToken hashToken, SyntaxToken nullableKeyword, SyntaxToken settingToken, SyntaxToken? targetToken, SyntaxToken endOfDirectiveToken, bool isActive) { return new NullableDirectiveTriviaSyntax(SyntaxKind.NullableDirectiveTrivia, hashToken, nullableKeyword, settingToken, targetToken, endOfDirectiveToken, isActive, context); } }