/// <summary>
/// Return a collection of bound constraint clauses indexed by type parameter
/// ordinal. All constraint clauses are bound, even if there are multiple constraints
/// for the same type parameter, or constraints for unrecognized type parameters.
/// Extra constraints are not included in the returned collection however.
/// </summary>
internal ImmutableArray <TypeParameterConstraintClause> BindTypeParameterConstraintClauses(
Symbol containingSymbol,
ImmutableArray <TypeParameterSymbol> typeParameters,
SyntaxList <TypeParameterConstraintClauseSyntax> clauses,
DiagnosticBag diagnostics)
{
Debug.Assert(this.Flags.Includes(BinderFlags.GenericConstraintsClause));
Debug.Assert((object)containingSymbol != null);
Debug.Assert((containingSymbol.Kind == SymbolKind.NamedType) || (containingSymbol.Kind == SymbolKind.Method));
Debug.Assert(typeParameters.Length > 0);
Debug.Assert(clauses.Count > 0);
int n = typeParameters.Length;
// Create a map from type parameter name to ordinal.
// No need to report duplicate names since duplicates
// are reported when the type parameters are bound.
var names = new Dictionary <string, int>(n);
foreach (var typeParameter in typeParameters)
{
var name = typeParameter.Name;
if (!names.ContainsKey(name))
{
names.Add(name, names.Count);
}
}
// An array of constraint clauses, one for each type parameter, indexed by ordinal.
var results = new TypeParameterConstraintClause[n];
// Bind each clause and add to the results.
foreach (var clause in clauses)
{
var name = clause.Name.Identifier.ValueText;
int ordinal;
if (names.TryGetValue(name, out ordinal))
{
Debug.Assert(ordinal >= 0);
Debug.Assert(ordinal < n);
var constraintClause = this.BindTypeParameterConstraints(name, clause.Constraints, diagnostics);
if (results[ordinal] == null)
{
results[ordinal] = constraintClause;
}
else
{
// "A constraint clause has already been specified for type parameter '{0}'. ..."
diagnostics.Add(ErrorCode.ERR_DuplicateConstraintClause, clause.Name.Location, name);
}
}
else
{
// Unrecognized type parameter. Don't bother binding the constraints
// (the ": I<U>" in "where U : I<U>") since that will lead to additional
// errors ("type or namespace 'U' could not be found") if the type
// parameter is referenced in the constraints.
// "'{1}' does not define type parameter '{0}'"
diagnostics.Add(ErrorCode.ERR_TyVarNotFoundInConstraint, clause.Name.Location, name, containingSymbol.ConstructedFrom());
}
}
return(results.AsImmutableOrNull());
}
/// <summary>
/// Bind and return a single type parameter constraint clause.
/// </summary>
private TypeParameterConstraintClause BindTypeParameterConstraints(
string name, TypeParameterConstraintClauseSyntax constraintClauseSyntax, DiagnosticBag diagnostics)
{
var constraints = TypeParameterConstraintKind.None;
var constraintTypes = ArrayBuilder <TypeSymbolWithAnnotations> .GetInstance();
var syntaxBuilder = ArrayBuilder <TypeConstraintSyntax> .GetInstance();
SeparatedSyntaxList <TypeParameterConstraintSyntax> constraintsSyntax = constraintClauseSyntax.Constraints;
Debug.Assert(!InExecutableBinder); // Cannot eagerly report diagnostics handled by LazyMissingNonNullTypesContextDiagnosticInfo
for (int i = 0, n = constraintsSyntax.Count; i < n; i++)
{
var syntax = constraintsSyntax[i];
switch (syntax.Kind())
{
case SyntaxKind.ClassConstraint:
if (i != 0)
{
diagnostics.Add(ErrorCode.ERR_RefValBoundMustBeFirst, syntax.GetFirstToken().GetLocation());
}
var constraintSyntax = (ClassOrStructConstraintSyntax)syntax;
SyntaxToken questionToken = constraintSyntax.QuestionToken;
if (questionToken.IsKind(SyntaxKind.QuestionToken))
{
constraints |= TypeParameterConstraintKind.NullableReferenceType;
DiagnosticInfo info = LazyMissingNonNullTypesContextDiagnosticInfo.ReportNullableReferenceTypesIfNeeded(Compilation, IsNullableEnabled(questionToken));
if (!(info is null))
{
diagnostics.Add(info, questionToken.GetLocation());
}
}
else if (IsNullableEnabled(constraintSyntax.ClassOrStructKeyword))
{
constraints |= TypeParameterConstraintKind.NotNullableReferenceType;
}
else
{
constraints |= TypeParameterConstraintKind.ReferenceType;
}
continue;
case SyntaxKind.ConstConstraint:
if (i != 0)
{
// TODO: add a specific error message for constraint
diagnostics.Add(ErrorCode.ERR_RefValBoundMustBeFirst, syntax.GetFirstToken().GetLocation());
}
var constConstraintSyntax = (ConstConstraintSyntax)syntax;
// For pointer types, don't report this error. It is already reported during binding typeSyntax below.
switch (constConstraintSyntax.Type.Kind())
{
case SyntaxKind.PredefinedType:
constraints |= TypeParameterConstraintKind.Const;
var type = BindTypeOrUnmanagedKeyword(constConstraintSyntax.Type, diagnostics, out var isUnmanaged);
constraintTypes.Add(type);
syntaxBuilder.Add(constConstraintSyntax);
break;
default:
// TODO: Add error message that only predefined type are supported for now
diagnostics.Add(ErrorCode.ERR_BadConstraintType, constConstraintSyntax.Type.GetLocation());
break;
}
break;
case SyntaxKind.StructConstraint:
if (i != 0)
{
diagnostics.Add(ErrorCode.ERR_RefValBoundMustBeFirst, syntax.GetFirstToken().GetLocation());
}
constraints |= TypeParameterConstraintKind.ValueType;
continue;
case SyntaxKind.ConstructorConstraint:
if ((constraints & TypeParameterConstraintKind.ValueType) != 0)
{
diagnostics.Add(ErrorCode.ERR_NewBoundWithVal, syntax.GetFirstToken().GetLocation());
}
if ((constraints & TypeParameterConstraintKind.Unmanaged) != 0)
{
diagnostics.Add(ErrorCode.ERR_NewBoundWithUnmanaged, syntax.GetFirstToken().GetLocation());
}
if (i != n - 1)
{
diagnostics.Add(ErrorCode.ERR_NewBoundMustBeLast, syntax.GetFirstToken().GetLocation());
}
constraints |= TypeParameterConstraintKind.Constructor;
continue;
case SyntaxKind.ExtendsTypeConstraint:
case SyntaxKind.ImplementsTypeConstraint:
{
var typeConstraintSyntax = (TypeConstraintSyntax)syntax;
var typeSyntax = typeConstraintSyntax.Type;
var typeSyntaxKind = typeSyntax.Kind();
// For pointer types, don't report this error. It is already reported during binding typeSyntax below.
switch (typeSyntaxKind)
{
case SyntaxKind.PredefinedType:
case SyntaxKind.PointerType:
case SyntaxKind.NullableType:
break;
default:
if (!SyntaxFacts.IsName(typeSyntax.Kind()))
{
diagnostics.Add(ErrorCode.ERR_BadConstraintType, typeSyntax.GetLocation());
}
break;
}
var type = BindTypeOrUnmanagedKeyword(typeSyntax, diagnostics, out var isUnmanaged);
if (isUnmanaged)
{
if (constraints != 0 || constraintTypes.Any())
{
diagnostics.Add(ErrorCode.ERR_UnmanagedConstraintMustBeFirst, typeSyntax.GetLocation());
continue;
}
// This should produce diagnostics if the types are missing
GetWellKnownType(WellKnownType.core_runtime_UnmanagedType, diagnostics, typeSyntax);
constraints |= TypeParameterConstraintKind.Unmanaged;
continue;
}
// TODO: add error if extends is not class or implements is not an interface
constraintTypes.Add(type);
syntaxBuilder.Add(typeConstraintSyntax);
}
continue;
default:
throw ExceptionUtilities.UnexpectedValue(syntax.Kind());
}
}
return(TypeParameterConstraintClause.Create(constraints, constraintTypes.ToImmutableAndFree(), syntaxBuilder.ToImmutableAndFree()));
}
/// <summary>
/// Bind and return a single type parameter constraint clause.
/// </summary>
private TypeParameterConstraintClause BindTypeParameterConstraints(TypeParameterSyntax typeParameterSyntax, TypeParameterConstraintClauseSyntax constraintClauseSyntax, DiagnosticBag diagnostics)
{
var constraints = TypeParameterConstraintKind.None;
var constraintTypes = ArrayBuilder <TypeWithAnnotations> .GetInstance();
var syntaxBuilder = ArrayBuilder <TypeConstraintSyntax> .GetInstance();
SeparatedSyntaxList <TypeParameterConstraintSyntax> constraintsSyntax = constraintClauseSyntax.Constraints;
Debug.Assert(!InExecutableBinder); // Cannot eagerly report diagnostics handled by LazyMissingNonNullTypesContextDiagnosticInfo
bool hasTypeLikeConstraint = false;
for (int i = 0, n = constraintsSyntax.Count; i < n; i++)
{
var syntax = constraintsSyntax[i];
switch (syntax.Kind())
{
case SyntaxKind.ClassConstraint:
hasTypeLikeConstraint = true;
if (i != 0)
{
diagnostics.Add(ErrorCode.ERR_RefValBoundMustBeFirst, syntax.GetFirstToken().GetLocation());
}
var constraintSyntax = (ClassOrStructConstraintSyntax)syntax;
SyntaxToken questionToken = constraintSyntax.QuestionToken;
if (questionToken.IsKind(SyntaxKind.QuestionToken))
{
constraints |= TypeParameterConstraintKind.NullableReferenceType;
LazyMissingNonNullTypesContextDiagnosticInfo.ReportNullableReferenceTypesIfNeeded(IsNullableEnabled(questionToken), questionToken.GetLocation(), diagnostics);
}
else if (IsNullableEnabled(constraintSyntax.ClassOrStructKeyword))
{
constraints |= TypeParameterConstraintKind.NotNullableReferenceType;
}
else
{
constraints |= TypeParameterConstraintKind.ReferenceType;
}
continue;
case SyntaxKind.StructConstraint:
hasTypeLikeConstraint = true;
if (i != 0)
{
diagnostics.Add(ErrorCode.ERR_RefValBoundMustBeFirst, syntax.GetFirstToken().GetLocation());
}
constraints |= TypeParameterConstraintKind.ValueType;
continue;
case SyntaxKind.ConstructorConstraint:
if ((constraints & TypeParameterConstraintKind.ValueType) != 0)
{
diagnostics.Add(ErrorCode.ERR_NewBoundWithVal, syntax.GetFirstToken().GetLocation());
}
if ((constraints & TypeParameterConstraintKind.Unmanaged) != 0)
{
diagnostics.Add(ErrorCode.ERR_NewBoundWithUnmanaged, syntax.GetFirstToken().GetLocation());
}
if (i != n - 1)
{
diagnostics.Add(ErrorCode.ERR_NewBoundMustBeLast, syntax.GetFirstToken().GetLocation());
}
constraints |= TypeParameterConstraintKind.Constructor;
continue;
case SyntaxKind.TypeConstraint:
{
hasTypeLikeConstraint = true;
var typeConstraintSyntax = (TypeConstraintSyntax)syntax;
var typeSyntax = typeConstraintSyntax.Type;
var typeSyntaxKind = typeSyntax.Kind();
// For pointer types, don't report this error. It is already reported during binding typeSyntax below.
switch (typeSyntaxKind)
{
case SyntaxKind.PredefinedType:
case SyntaxKind.PointerType:
case SyntaxKind.NullableType:
break;
default:
if (!SyntaxFacts.IsName(typeSyntax.Kind()))
{
diagnostics.Add(ErrorCode.ERR_BadConstraintType, typeSyntax.GetLocation());
}
break;
}
var type = BindTypeOrUnmanagedKeyword(typeSyntax, diagnostics, out var isUnmanaged);
if (isUnmanaged)
{
if (constraints != 0 || constraintTypes.Any())
{
diagnostics.Add(ErrorCode.ERR_UnmanagedConstraintMustBeFirst, typeSyntax.GetLocation());
continue;
}
// This should produce diagnostics if the types are missing
GetWellKnownType(WellKnownType.System_Runtime_InteropServices_UnmanagedType, diagnostics, typeSyntax);
GetSpecialType(SpecialType.System_ValueType, diagnostics, typeSyntax);
constraints |= TypeParameterConstraintKind.Unmanaged;
continue;
}
constraintTypes.Add(type);
syntaxBuilder.Add(typeConstraintSyntax);
}
continue;
default:
throw ExceptionUtilities.UnexpectedValue(syntax.Kind());
}
}
if (!hasTypeLikeConstraint && !IsNullableEnabled(typeParameterSyntax.Identifier))
{
constraints |= TypeParameterConstraintKind.ObliviousNullabilityIfReferenceType;
}
return(TypeParameterConstraintClause.Create(constraints, constraintTypes.ToImmutableAndFree(), syntaxBuilder.ToImmutableAndFree()));
}
internal ImmutableArray <TypeParameterConstraintClause> BindTypeParameterConstraintClauses(
Symbol containingSymbol,
ImmutableArray <TypeParameterSymbol> typeParameters,
TypeParameterListSyntax typeParameterList,
SyntaxList <TypeParameterConstraintClauseSyntax> clauses,
ref IReadOnlyDictionary <TypeParameterSymbol, bool> isValueTypeOverride,
DiagnosticBag diagnostics,
bool isForOverride = false)
{
Debug.Assert(this.Flags.Includes(BinderFlags.GenericConstraintsClause));
RoslynDebug.Assert((object)containingSymbol != null);
Debug.Assert((containingSymbol.Kind == SymbolKind.NamedType) || (containingSymbol.Kind == SymbolKind.Method));
Debug.Assert(typeParameters.Length > 0);
Debug.Assert(clauses.Count > 0);
int n = typeParameters.Length;
// Create a map from type parameter name to ordinal.
// No need to report duplicate names since duplicates
// are reported when the type parameters are bound.
var names = new Dictionary <string, int>(n, StringOrdinalComparer.Instance);
foreach (var typeParameter in typeParameters)
{
var name = typeParameter.Name;
if (!names.ContainsKey(name))
{
names.Add(name, names.Count);
}
}
// An array of constraint clauses, one for each type parameter, indexed by ordinal.
var results = ArrayBuilder <TypeParameterConstraintClause?> .GetInstance(n, fillWithValue : null);
var syntaxNodes = ArrayBuilder <ArrayBuilder <TypeConstraintSyntax>?> .GetInstance(n, fillWithValue : null);
// Bind each clause and add to the results.
foreach (var clause in clauses)
{
var name = clause.Name.Identifier.ValueText;
RoslynDebug.Assert(name is object);
int ordinal;
if (names.TryGetValue(name, out ordinal))
{
Debug.Assert(ordinal >= 0);
Debug.Assert(ordinal < n);
(TypeParameterConstraintClause constraintClause, ArrayBuilder <TypeConstraintSyntax>?typeConstraintNodes) = this.BindTypeParameterConstraints(typeParameterList.Parameters[ordinal], clause, isForOverride, diagnostics);
if (results[ordinal] == null)
{
results[ordinal] = constraintClause;
syntaxNodes[ordinal] = typeConstraintNodes;
}
else
{
// "A constraint clause has already been specified for type parameter '{0}'. ..."
diagnostics.Add(ErrorCode.ERR_DuplicateConstraintClause, clause.Name.Location, name);
typeConstraintNodes?.Free();
}
}
else
{
// Unrecognized type parameter. Don't bother binding the constraints
// (the ": I<U>" in "where U : I<U>") since that will lead to additional
// errors ("type or namespace 'U' could not be found") if the type
// parameter is referenced in the constraints.
// "'{1}' does not define type parameter '{0}'"
diagnostics.Add(ErrorCode.ERR_TyVarNotFoundInConstraint, clause.Name.Location, name, containingSymbol.ConstructedFrom());
}
}
// Add default values for type parameters without constraint clauses.
for (int i = 0; i < n; i++)
{
if (results[i] == null)
{
results[i] = GetDefaultTypeParameterConstraintClause(typeParameterList.Parameters[i], isForOverride);
}
}
TypeParameterConstraintClause.AdjustConstraintTypes(containingSymbol, typeParameters, results, ref isValueTypeOverride);
RemoveInvalidConstraints(typeParameters, results !, syntaxNodes, diagnostics);
foreach (var typeConstraintsSyntaxes in syntaxNodes)
{
typeConstraintsSyntaxes?.Free();
}
syntaxNodes.Free();
return(results.ToImmutableAndFree() !);
}
private (TypeParameterConstraintClause, ArrayBuilder <TypeConstraintSyntax>?) BindTypeParameterConstraints(TypeParameterSyntax typeParameterSyntax, TypeParameterConstraintClauseSyntax constraintClauseSyntax, bool isForOverride, DiagnosticBag diagnostics)
{
var constraints = TypeParameterConstraintKind.None;
ArrayBuilder <TypeWithAnnotations>? constraintTypes = null;
ArrayBuilder <TypeConstraintSyntax>?syntaxBuilder = null;
SeparatedSyntaxList <TypeParameterConstraintSyntax> constraintsSyntax = constraintClauseSyntax.Constraints;
Debug.Assert(!InExecutableBinder); // Cannot eagerly report diagnostics handled by LazyMissingNonNullTypesContextDiagnosticInfo
bool hasTypeLikeConstraint = false;
bool reportedOverrideWithConstraints = false;
for (int i = 0, n = constraintsSyntax.Count; i < n; i++)
{
var syntax = constraintsSyntax[i];
switch (syntax.Kind())
{
case SyntaxKind.ClassConstraint:
hasTypeLikeConstraint = true;
if (i != 0)
{
diagnostics.Add(ErrorCode.ERR_RefValBoundMustBeFirst, syntax.GetFirstToken().GetLocation());
if (isForOverride && (constraints & (TypeParameterConstraintKind.ValueType | TypeParameterConstraintKind.ReferenceType)) != 0)
{
continue;
}
}
var constraintSyntax = (ClassOrStructConstraintSyntax)syntax;
SyntaxToken questionToken = constraintSyntax.QuestionToken;
if (questionToken.IsKind(SyntaxKind.QuestionToken))
{
constraints |= TypeParameterConstraintKind.NullableReferenceType;
if (isForOverride)
{
reportOverrideWithConstraints(ref reportedOverrideWithConstraints, syntax, diagnostics);
}
else
{
LazyMissingNonNullTypesContextDiagnosticInfo.ReportNullableReferenceTypesIfNeeded(AreNullableAnnotationsEnabled(questionToken), questionToken.GetLocation(), diagnostics);
}
}
else if (isForOverride || AreNullableAnnotationsEnabled(constraintSyntax.ClassOrStructKeyword))
{
constraints |= TypeParameterConstraintKind.NotNullableReferenceType;
}
else
{
constraints |= TypeParameterConstraintKind.ReferenceType;
}
continue;
case SyntaxKind.StructConstraint:
hasTypeLikeConstraint = true;
if (i != 0)
{
diagnostics.Add(ErrorCode.ERR_RefValBoundMustBeFirst, syntax.GetFirstToken().GetLocation());
if (isForOverride && (constraints & (TypeParameterConstraintKind.ValueType | TypeParameterConstraintKind.ReferenceType)) != 0)
{
continue;
}
}
constraints |= TypeParameterConstraintKind.ValueType;
continue;
case SyntaxKind.ConstructorConstraint:
if (isForOverride)
{
reportOverrideWithConstraints(ref reportedOverrideWithConstraints, syntax, diagnostics);
continue;
}
if ((constraints & TypeParameterConstraintKind.ValueType) != 0)
{
diagnostics.Add(ErrorCode.ERR_NewBoundWithVal, syntax.GetFirstToken().GetLocation());
}
if ((constraints & TypeParameterConstraintKind.Unmanaged) != 0)
{
diagnostics.Add(ErrorCode.ERR_NewBoundWithUnmanaged, syntax.GetFirstToken().GetLocation());
}
if (i != n - 1)
{
diagnostics.Add(ErrorCode.ERR_NewBoundMustBeLast, syntax.GetFirstToken().GetLocation());
}
constraints |= TypeParameterConstraintKind.Constructor;
continue;
case SyntaxKind.TypeConstraint:
if (isForOverride)
{
reportOverrideWithConstraints(ref reportedOverrideWithConstraints, syntax, diagnostics);
}
else
{
hasTypeLikeConstraint = true;
if (constraintTypes == null)
{
constraintTypes = ArrayBuilder <TypeWithAnnotations> .GetInstance();
syntaxBuilder = ArrayBuilder <TypeConstraintSyntax> .GetInstance();
}
var typeConstraintSyntax = (TypeConstraintSyntax)syntax;
var typeSyntax = typeConstraintSyntax.Type;
var type = BindTypeOrConstraintKeyword(typeSyntax, diagnostics, out ConstraintContextualKeyword keyword);
switch (keyword)
{
case ConstraintContextualKeyword.Unmanaged:
if (i != 0)
{
diagnostics.Add(ErrorCode.ERR_UnmanagedConstraintMustBeFirst, typeSyntax.GetLocation());
continue;
}
// This should produce diagnostics if the types are missing
GetWellKnownType(WellKnownType.System_Runtime_InteropServices_UnmanagedType, diagnostics, typeSyntax);
GetSpecialType(SpecialType.System_ValueType, diagnostics, typeSyntax);
constraints |= TypeParameterConstraintKind.Unmanaged;
continue;
case ConstraintContextualKeyword.NotNull:
if (i != 0)
{
diagnostics.Add(ErrorCode.ERR_NotNullConstraintMustBeFirst, typeSyntax.GetLocation());
}
constraints |= TypeParameterConstraintKind.NotNull;
continue;
case ConstraintContextualKeyword.None:
break;
default:
throw ExceptionUtilities.UnexpectedValue(keyword);
}
constraintTypes.Add(type);
syntaxBuilder !.Add(typeConstraintSyntax);
}
continue;
default:
throw ExceptionUtilities.UnexpectedValue(syntax.Kind());
}
}
if (!isForOverride && !hasTypeLikeConstraint && !AreNullableAnnotationsEnabled(typeParameterSyntax.Identifier))
{
constraints |= TypeParameterConstraintKind.ObliviousNullabilityIfReferenceType;
}
Debug.Assert(!isForOverride ||
(constraints & (TypeParameterConstraintKind.ReferenceType | TypeParameterConstraintKind.ValueType)) != (TypeParameterConstraintKind.ReferenceType | TypeParameterConstraintKind.ValueType));
return(TypeParameterConstraintClause.Create(constraints, constraintTypes?.ToImmutableAndFree() ?? ImmutableArray <TypeWithAnnotations> .Empty), syntaxBuilder);
public static Doc Print(SyntaxNode syntaxNode)
{
if (syntaxNode == null)
{
return(Doc.Null);
}
// TODO 0 kill? runtime repo has files that will fail on deep recursion
if (depth > 200)
{
throw new InTooDeepException();
}
depth++;
try
{
switch (syntaxNode)
{
case AliasQualifiedNameSyntax aliasQualifiedNameSyntax:
return(AliasQualifiedName.Print(aliasQualifiedNameSyntax));
case AnonymousMethodExpressionSyntax anonymousMethodExpressionSyntax:
return(AnonymousMethodExpression.Print(anonymousMethodExpressionSyntax));
case AnonymousObjectCreationExpressionSyntax anonymousObjectCreationExpressionSyntax:
return(AnonymousObjectCreationExpression.Print(
anonymousObjectCreationExpressionSyntax
));
case AnonymousObjectMemberDeclaratorSyntax anonymousObjectMemberDeclaratorSyntax:
return(AnonymousObjectMemberDeclarator.Print(
anonymousObjectMemberDeclaratorSyntax
));
case ArgumentListSyntax argumentListSyntax:
return(ArgumentList.Print(argumentListSyntax));
case ArgumentSyntax argumentSyntax:
return(Argument.Print(argumentSyntax));
case ArrayCreationExpressionSyntax arrayCreationExpressionSyntax:
return(ArrayCreationExpression.Print(arrayCreationExpressionSyntax));
case ArrayRankSpecifierSyntax arrayRankSpecifierSyntax:
return(ArrayRankSpecifier.Print(arrayRankSpecifierSyntax));
case ArrayTypeSyntax arrayTypeSyntax:
return(ArrayType.Print(arrayTypeSyntax));
case ArrowExpressionClauseSyntax arrowExpressionClauseSyntax:
return(ArrowExpressionClause.Print(arrowExpressionClauseSyntax));
case AssignmentExpressionSyntax assignmentExpressionSyntax:
return(AssignmentExpression.Print(assignmentExpressionSyntax));
case AttributeListSyntax attributeListSyntax:
return(AttributeList.Print(attributeListSyntax));
case AwaitExpressionSyntax awaitExpressionSyntax:
return(AwaitExpression.Print(awaitExpressionSyntax));
case BaseExpressionSyntax baseExpressionSyntax:
return(BaseExpression.Print(baseExpressionSyntax));
case BaseFieldDeclarationSyntax baseFieldDeclarationSyntax:
return(BaseFieldDeclaration.Print(baseFieldDeclarationSyntax));
case BaseListSyntax baseListSyntax:
return(BaseList.Print(baseListSyntax));
case BaseMethodDeclarationSyntax baseMethodDeclarationSyntax:
return(BaseMethodDeclaration.Print(baseMethodDeclarationSyntax));
case BasePropertyDeclarationSyntax basePropertyDeclarationSyntax:
return(BasePropertyDeclaration.Print(basePropertyDeclarationSyntax));
case BaseTypeDeclarationSyntax baseTypeDeclarationSyntax:
return(BaseTypeDeclaration.Print(baseTypeDeclarationSyntax));
case BinaryExpressionSyntax binaryExpressionSyntax:
return(BinaryExpression.Print(binaryExpressionSyntax));
case BinaryPatternSyntax binaryPatternSyntax:
return(BinaryPattern.Print(binaryPatternSyntax));
case BlockSyntax blockSyntax:
return(Block.Print(blockSyntax));
case BracketedArgumentListSyntax bracketedArgumentListSyntax:
return(BracketedArgumentList.Print(bracketedArgumentListSyntax));
case BracketedParameterListSyntax bracketedParameterListSyntax:
return(BracketedParameterList.Print(bracketedParameterListSyntax));
case BreakStatementSyntax breakStatementSyntax:
return(BreakStatement.Print(breakStatementSyntax));
case CasePatternSwitchLabelSyntax casePatternSwitchLabelSyntax:
return(CasePatternSwitchLabel.Print(casePatternSwitchLabelSyntax));
case CaseSwitchLabelSyntax caseSwitchLabelSyntax:
return(CaseSwitchLabel.Print(caseSwitchLabelSyntax));
case CastExpressionSyntax castExpressionSyntax:
return(CastExpression.Print(castExpressionSyntax));
case CatchClauseSyntax catchClauseSyntax:
return(CatchClause.Print(catchClauseSyntax));
case CheckedExpressionSyntax checkedExpressionSyntax:
return(CheckedExpression.Print(checkedExpressionSyntax));
case CheckedStatementSyntax checkedStatementSyntax:
return(CheckedStatement.Print(checkedStatementSyntax));
case ClassOrStructConstraintSyntax classOrStructConstraintSyntax:
return(ClassOrStructConstraint.Print(classOrStructConstraintSyntax));
case CompilationUnitSyntax compilationUnitSyntax:
return(CompilationUnit.Print(compilationUnitSyntax));
case ConditionalAccessExpressionSyntax conditionalAccessExpressionSyntax:
return(ConditionalAccessExpression.Print(conditionalAccessExpressionSyntax));
case ConditionalExpressionSyntax conditionalExpressionSyntax:
return(ConditionalExpression.Print(conditionalExpressionSyntax));
case ConstantPatternSyntax constantPatternSyntax:
return(ConstantPattern.Print(constantPatternSyntax));
case ConstructorConstraintSyntax constructorConstraintSyntax:
return(ConstructorConstraint.Print(constructorConstraintSyntax));
case ConstructorInitializerSyntax constructorInitializerSyntax:
return(ConstructorInitializer.Print(constructorInitializerSyntax));
case ContinueStatementSyntax continueStatementSyntax:
return(ContinueStatement.Print(continueStatementSyntax));
case DeclarationExpressionSyntax declarationExpressionSyntax:
return(DeclarationExpression.Print(declarationExpressionSyntax));
case DeclarationPatternSyntax declarationPatternSyntax:
return(DeclarationPattern.Print(declarationPatternSyntax));
case DefaultConstraintSyntax defaultConstraintSyntax:
return(DefaultConstraint.Print(defaultConstraintSyntax));
case DefaultExpressionSyntax defaultExpressionSyntax:
return(DefaultExpression.Print(defaultExpressionSyntax));
case DefaultSwitchLabelSyntax defaultSwitchLabelSyntax:
return(DefaultSwitchLabel.Print(defaultSwitchLabelSyntax));
case DelegateDeclarationSyntax delegateDeclarationSyntax:
return(DelegateDeclaration.Print(delegateDeclarationSyntax));
case DiscardDesignationSyntax discardDesignationSyntax:
return(DiscardDesignation.Print(discardDesignationSyntax));
case DiscardPatternSyntax discardPatternSyntax:
return(DiscardPattern.Print(discardPatternSyntax));
case DoStatementSyntax doStatementSyntax:
return(DoStatement.Print(doStatementSyntax));
case ElementAccessExpressionSyntax elementAccessExpressionSyntax:
return(ElementAccessExpression.Print(elementAccessExpressionSyntax));
case ElementBindingExpressionSyntax elementBindingExpressionSyntax:
return(ElementBindingExpression.Print(elementBindingExpressionSyntax));
case ElseClauseSyntax elseClauseSyntax:
return(ElseClause.Print(elseClauseSyntax));
case EmptyStatementSyntax emptyStatementSyntax:
return(EmptyStatement.Print(emptyStatementSyntax));
case EnumMemberDeclarationSyntax enumMemberDeclarationSyntax:
return(EnumMemberDeclaration.Print(enumMemberDeclarationSyntax));
case EqualsValueClauseSyntax equalsValueClauseSyntax:
return(EqualsValueClause.Print(equalsValueClauseSyntax));
case ExpressionStatementSyntax expressionStatementSyntax:
return(ExpressionStatement.Print(expressionStatementSyntax));
case ExternAliasDirectiveSyntax externAliasDirectiveSyntax:
return(ExternAliasDirective.Print(externAliasDirectiveSyntax));
case FinallyClauseSyntax finallyClauseSyntax:
return(FinallyClause.Print(finallyClauseSyntax));
case FixedStatementSyntax fixedStatementSyntax:
return(FixedStatement.Print(fixedStatementSyntax));
case ForEachStatementSyntax forEachStatementSyntax:
return(ForEachStatement.Print(forEachStatementSyntax));
case ForEachVariableStatementSyntax forEachVariableStatementSyntax:
return(ForEachVariableStatement.Print(forEachVariableStatementSyntax));
case ForStatementSyntax forStatementSyntax:
return(ForStatement.Print(forStatementSyntax));
case FromClauseSyntax fromClauseSyntax:
return(FromClause.Print(fromClauseSyntax));
case FunctionPointerTypeSyntax functionPointerTypeSyntax:
return(FunctionPointerType.Print(functionPointerTypeSyntax));
case GenericNameSyntax genericNameSyntax:
return(GenericName.Print(genericNameSyntax));
case GlobalStatementSyntax globalStatementSyntax:
return(GlobalStatement.Print(globalStatementSyntax));
case GotoStatementSyntax gotoStatementSyntax:
return(GotoStatement.Print(gotoStatementSyntax));
case GroupClauseSyntax groupClauseSyntax:
return(GroupClause.Print(groupClauseSyntax));
case IdentifierNameSyntax identifierNameSyntax:
return(IdentifierName.Print(identifierNameSyntax));
case IfStatementSyntax ifStatementSyntax:
return(IfStatement.Print(ifStatementSyntax));
case ImplicitArrayCreationExpressionSyntax implicitArrayCreationExpressionSyntax:
return(ImplicitArrayCreationExpression.Print(
implicitArrayCreationExpressionSyntax
));
case ImplicitElementAccessSyntax implicitElementAccessSyntax:
return(ImplicitElementAccess.Print(implicitElementAccessSyntax));
case ImplicitObjectCreationExpressionSyntax implicitObjectCreationExpressionSyntax:
return(ImplicitObjectCreationExpression.Print(
implicitObjectCreationExpressionSyntax
));
case ImplicitStackAllocArrayCreationExpressionSyntax implicitStackAllocArrayCreationExpressionSyntax:
return(ImplicitStackAllocArrayCreationExpression.Print(
implicitStackAllocArrayCreationExpressionSyntax
));
case IncompleteMemberSyntax incompleteMemberSyntax:
return(IncompleteMember.Print(incompleteMemberSyntax));
case InitializerExpressionSyntax initializerExpressionSyntax:
return(InitializerExpression.Print(initializerExpressionSyntax));
case InterpolatedStringExpressionSyntax interpolatedStringExpressionSyntax:
return(InterpolatedStringExpression.Print(
interpolatedStringExpressionSyntax
));
case InterpolatedStringTextSyntax interpolatedStringTextSyntax:
return(InterpolatedStringText.Print(interpolatedStringTextSyntax));
case InterpolationSyntax interpolationSyntax:
return(Interpolation.Print(interpolationSyntax));
case InvocationExpressionSyntax invocationExpressionSyntax:
return(InvocationExpression.Print(invocationExpressionSyntax));
case IsPatternExpressionSyntax isPatternExpressionSyntax:
return(IsPatternExpression.Print(isPatternExpressionSyntax));
case JoinClauseSyntax joinClauseSyntax:
return(JoinClause.Print(joinClauseSyntax));
case LabeledStatementSyntax labeledStatementSyntax:
return(LabeledStatement.Print(labeledStatementSyntax));
case LetClauseSyntax letClauseSyntax:
return(LetClause.Print(letClauseSyntax));
case LiteralExpressionSyntax literalExpressionSyntax:
return(LiteralExpression.Print(literalExpressionSyntax));
case LocalDeclarationStatementSyntax localDeclarationStatementSyntax:
return(LocalDeclarationStatement.Print(localDeclarationStatementSyntax));
case LocalFunctionStatementSyntax localFunctionStatementSyntax:
return(LocalFunctionStatement.Print(localFunctionStatementSyntax));
case LockStatementSyntax lockStatementSyntax:
return(LockStatement.Print(lockStatementSyntax));
case MakeRefExpressionSyntax makeRefExpressionSyntax:
return(MakeRefExpression.Print(makeRefExpressionSyntax));
case MemberAccessExpressionSyntax memberAccessExpressionSyntax:
return(MemberAccessExpression.Print(memberAccessExpressionSyntax));
case MemberBindingExpressionSyntax memberBindingExpressionSyntax:
return(MemberBindingExpression.Print(memberBindingExpressionSyntax));
case NameColonSyntax nameColonSyntax:
return(NameColon.Print(nameColonSyntax));
case NameEqualsSyntax nameEqualsSyntax:
return(NameEquals.Print(nameEqualsSyntax));
case NamespaceDeclarationSyntax namespaceDeclarationSyntax:
return(NamespaceDeclaration.Print(namespaceDeclarationSyntax));
case NullableTypeSyntax nullableTypeSyntax:
return(NullableType.Print(nullableTypeSyntax));
case ObjectCreationExpressionSyntax objectCreationExpressionSyntax:
return(ObjectCreationExpression.Print(objectCreationExpressionSyntax));
case OmittedArraySizeExpressionSyntax omittedArraySizeExpressionSyntax:
return(OmittedArraySizeExpression.Print(omittedArraySizeExpressionSyntax));
case OmittedTypeArgumentSyntax omittedTypeArgumentSyntax:
return(OmittedTypeArgument.Print(omittedTypeArgumentSyntax));
case OrderByClauseSyntax orderByClauseSyntax:
return(OrderByClause.Print(orderByClauseSyntax));
case ParameterListSyntax parameterListSyntax:
return(ParameterList.Print(parameterListSyntax));
case ParameterSyntax parameterSyntax:
return(Parameter.Print(parameterSyntax));
case ParenthesizedExpressionSyntax parenthesizedExpressionSyntax:
return(ParenthesizedExpression.Print(parenthesizedExpressionSyntax));
case ParenthesizedLambdaExpressionSyntax parenthesizedLambdaExpressionSyntax:
return(ParenthesizedLambdaExpression.Print(
parenthesizedLambdaExpressionSyntax
));
case ParenthesizedPatternSyntax parenthesizedPatternSyntax:
return(ParenthesizedPattern.Print(parenthesizedPatternSyntax));
case ParenthesizedVariableDesignationSyntax parenthesizedVariableDesignationSyntax:
return(ParenthesizedVariableDesignation.Print(
parenthesizedVariableDesignationSyntax
));
case PointerTypeSyntax pointerTypeSyntax:
return(PointerType.Print(pointerTypeSyntax));
case PostfixUnaryExpressionSyntax postfixUnaryExpressionSyntax:
return(PostfixUnaryExpression.Print(postfixUnaryExpressionSyntax));
case PredefinedTypeSyntax predefinedTypeSyntax:
return(PredefinedType.Print(predefinedTypeSyntax));
case PrefixUnaryExpressionSyntax prefixUnaryExpressionSyntax:
return(PrefixUnaryExpression.Print(prefixUnaryExpressionSyntax));
case PrimaryConstructorBaseTypeSyntax primaryConstructorBaseTypeSyntax:
return(PrimaryConstructorBaseType.Print(primaryConstructorBaseTypeSyntax));
case QualifiedNameSyntax qualifiedNameSyntax:
return(QualifiedName.Print(qualifiedNameSyntax));
case QueryBodySyntax queryBodySyntax:
return(QueryBody.Print(queryBodySyntax));
case QueryContinuationSyntax queryContinuationSyntax:
return(QueryContinuation.Print(queryContinuationSyntax));
case QueryExpressionSyntax queryExpressionSyntax:
return(QueryExpression.Print(queryExpressionSyntax));
case RangeExpressionSyntax rangeExpressionSyntax:
return(RangeExpression.Print(rangeExpressionSyntax));
case RecursivePatternSyntax recursivePatternSyntax:
return(RecursivePattern.Print(recursivePatternSyntax));
case RefExpressionSyntax refExpressionSyntax:
return(RefExpression.Print(refExpressionSyntax));
case RefTypeExpressionSyntax refTypeExpressionSyntax:
return(RefTypeExpression.Print(refTypeExpressionSyntax));
case RefTypeSyntax refTypeSyntax:
return(RefType.Print(refTypeSyntax));
case RefValueExpressionSyntax refValueExpressionSyntax:
return(RefValueExpression.Print(refValueExpressionSyntax));
case RelationalPatternSyntax relationalPatternSyntax:
return(RelationalPattern.Print(relationalPatternSyntax));
case ReturnStatementSyntax returnStatementSyntax:
return(ReturnStatement.Print(returnStatementSyntax));
case SelectClauseSyntax selectClauseSyntax:
return(SelectClause.Print(selectClauseSyntax));
case SimpleBaseTypeSyntax simpleBaseTypeSyntax:
return(SimpleBaseType.Print(simpleBaseTypeSyntax));
case SimpleLambdaExpressionSyntax simpleLambdaExpressionSyntax:
return(SimpleLambdaExpression.Print(simpleLambdaExpressionSyntax));
case SingleVariableDesignationSyntax singleVariableDesignationSyntax:
return(SingleVariableDesignation.Print(singleVariableDesignationSyntax));
case SizeOfExpressionSyntax sizeOfExpressionSyntax:
return(SizeOfExpression.Print(sizeOfExpressionSyntax));
case StackAllocArrayCreationExpressionSyntax stackAllocArrayCreationExpressionSyntax:
return(StackAllocArrayCreationExpression.Print(
stackAllocArrayCreationExpressionSyntax
));
case SwitchExpressionSyntax switchExpressionSyntax:
return(SwitchExpression.Print(switchExpressionSyntax));
case SwitchSectionSyntax switchSectionSyntax:
return(SwitchSection.Print(switchSectionSyntax));
case SwitchStatementSyntax switchStatementSyntax:
return(SwitchStatement.Print(switchStatementSyntax));
case ThisExpressionSyntax thisExpressionSyntax:
return(ThisExpression.Print(thisExpressionSyntax));
case ThrowExpressionSyntax throwExpressionSyntax:
return(ThrowExpression.Print(throwExpressionSyntax));
case ThrowStatementSyntax throwStatementSyntax:
return(ThrowStatement.Print(throwStatementSyntax));
case TryStatementSyntax tryStatementSyntax:
return(TryStatement.Print(tryStatementSyntax));
case TupleElementSyntax tupleElementSyntax:
return(TupleElement.Print(tupleElementSyntax));
case TupleExpressionSyntax tupleExpressionSyntax:
return(TupleExpression.Print(tupleExpressionSyntax));
case TupleTypeSyntax tupleTypeSyntax:
return(TupleType.Print(tupleTypeSyntax));
case TypeArgumentListSyntax typeArgumentListSyntax:
return(TypeArgumentList.Print(typeArgumentListSyntax));
case TypeConstraintSyntax typeConstraintSyntax:
return(TypeConstraint.Print(typeConstraintSyntax));
case TypeOfExpressionSyntax typeOfExpressionSyntax:
return(TypeOfExpression.Print(typeOfExpressionSyntax));
case TypeParameterConstraintClauseSyntax typeParameterConstraintClauseSyntax:
return(TypeParameterConstraintClause.Print(
typeParameterConstraintClauseSyntax
));
case TypeParameterListSyntax typeParameterListSyntax:
return(TypeParameterList.Print(typeParameterListSyntax));
case TypeParameterSyntax typeParameterSyntax:
return(TypeParameter.Print(typeParameterSyntax));
case TypePatternSyntax typePatternSyntax:
return(TypePattern.Print(typePatternSyntax));
case UnaryPatternSyntax unaryPatternSyntax:
return(UnaryPattern.Print(unaryPatternSyntax));
case UnsafeStatementSyntax unsafeStatementSyntax:
return(UnsafeStatement.Print(unsafeStatementSyntax));
case UsingDirectiveSyntax usingDirectiveSyntax:
return(UsingDirective.Print(usingDirectiveSyntax));
case UsingStatementSyntax usingStatementSyntax:
return(UsingStatement.Print(usingStatementSyntax));
case VariableDeclarationSyntax variableDeclarationSyntax:
return(VariableDeclaration.Print(variableDeclarationSyntax));
case VariableDeclaratorSyntax variableDeclaratorSyntax:
return(VariableDeclarator.Print(variableDeclaratorSyntax));
case VarPatternSyntax varPatternSyntax:
return(VarPattern.Print(varPatternSyntax));
case WhenClauseSyntax whenClauseSyntax:
return(WhenClause.Print(whenClauseSyntax));
case WhereClauseSyntax whereClauseSyntax:
return(WhereClause.Print(whereClauseSyntax));
case WhileStatementSyntax whileStatementSyntax:
return(WhileStatement.Print(whileStatementSyntax));
case WithExpressionSyntax withExpressionSyntax:
return(WithExpression.Print(withExpressionSyntax));
case YieldStatementSyntax yieldStatementSyntax:
return(YieldStatement.Print(yieldStatementSyntax));
default:
throw new Exception("Can't handle " + syntaxNode.GetType().Name);
}
}
finally
{
depth--;
}
}
