Module csharp

Whether the source was extracted without a build command.

An access expression. Either a this access (ThisAccess), a base access (BaseAccess), a member access (MemberAccess), an assignable access (AssignableAccess), or a callable access (CallableAccess).

An access modifier: public, private, internal or protected.

An accessor. Either a getter (Getter), a setter (Setter), or event accessor (EventAccessor).

A call to an accessor. Either a property accessor call (PropertyCall), an indexer accessor call (IndexerCall), or an event accessor call (EventCall).

An add event accessor, for example add on line 4 in

An event addition, for example line 9 in

An addition operation, for example x + y.

A user-defined addition operator (+), for example

An event assignment. Either an event addition (AddEventExpr) or an event removal (RemoveEventExpr).

An address-of expression, for example &n on line 4 in

A user-defined and operator (&), for example

A binary and pattern. For example, < 1 and > 2.

An array type with additional type information.

A constructed type with additional type information.

A type with additional type information.

A class generated by the compiler from an anonymous object creation.

An anonymous function. Either a lambda expression (LambdaExpr) or an anonymous method expression (AnonymousMethodExpr).

An anonymous method expression, for example delegate (int x) { return x + 1; }.

An anonymous constructor call, for example new { First = x[0], Last = x[x.Length - 1] } on line 2 in

The __arglist type, modeling varargs invocation in C++.

An arithmetic operation. Either a unary arithmetic operation (UnaryArithmeticOperation) or a binary arithmetic operation (BinaryArithmeticOperation).

An access to an array, for example the access to args on line 3 in

An array creation, for example new int[,] { {0, 1}, {2, 3}, {4, 5} }.

An array initializer, for example { {0, 1}, {2, 3}, {4, 5} } in

An access to an array that reads the underlying value, for example the access to a on line 2 in

An array type, for example int[].

An access to an array that updates the underlying value, for example the access to a on line 2 in

An as expression, for example x as string.

A .NET assembly location.

An attribute with assembly kind, for example [...] on line 1 in csharp [assembly: MyAttribute(0)]

An addition assignment operation, for example x += y.

A bitwise-and assignment operation, for example x &= y.

An arithmetic assignment operation. Either an addition assignment operation (AssignAddExpr), a subtraction assignment operation (AssignSubExpr), a multiplication assignment operation (AssignMulExpr), a division assignment operation (AssignDivExpr), or a remainder assignment operation (AssignRemExpr).

A bitwise assignment operation. Either a bitwise-and assignment operation (AssignAndExpr), a bitwise-or assignment operation (AssignOrExpr), a bitwise exclusive-or assignment operation (AssignXorExpr), a left-shift assignment operation (AssignLeftShiftExpr), or a right-shift assignment operation (AssignRightShiftExpr), or an unsigned right-shift assignment operation (AssignUnsignedRightShiftExpr).

A null-coalescing assignment operation, for example x ??= y.

An division assignment operation, for example x /= y.

A simple assignment, for example x = 0.

A left-shift assignment operation, for example x <<= y.

An multiplication assignment operation, for example x *= y.

An assignment operation. Either an arithmetic assignment operation (AssignArithmeticOperation), a bitwise assignment operation (AssignBitwiseOperation), or an event assignment (AddOrRemoveEventExpr).

A bitwise-or assignment operation, for example x |= y.

A remainder assignment operation, for example x %= y.

A right-shift assignment operation, for example x >>= y.

A subtraction assignment operation, for example x -= y.

An unsigned right-shift assignment operation, for example x >>>= y.

A bitwise exclusive-or assignment operation, for example x ^= y.

An assignable, that is, an element that can be assigned to. Either a variable (Variable), a property (Property), an indexer (Indexer), or an event (Event).

An assignable access, that is, an access that is valid on the left-hand side of some assignment. Either an access to a variable (VariableAccess), an access to a property (PropertyAccess), an access to an element (ElementAccess), an access to an event (EventAccess), or a dynamic member access (DynamicMemberAccess).

An assignable definition.

An assignable that is also a member. Either a field (Field), a property (Property), an indexer (Indexer), or an event (Event).

An access to an assignable that is also a member. Either a field access (FieldAccess), a property access (PropertyAccess), an indexer access (IndexerAccess), or an event access (EventAccess).

An access to an assignable that reads the underlying value. Either a variable read (VariableRead), a property read (PropertyRead), an indexer read (IndexerRead), or an event read (EventRead).

An access to an assignable that updates the underlying value. Either a variable write (VariableWrite), a property write (PropertyWrite), an indexer write (IndexerWrite), or an event write (EventWrite).

An assignment. Either a local variable initialization (LocalVariableDeclAndInitExpr), a simple assignment (AssignExpr), or an assignment operation (AssignOperation).

An element that can have attributes. Either an assembly (Assembly), a field (Field), a parameter (Parameter), an operator (Operator), a method (Method), a constructor (Constructor), a destructor (Destructor), a callable accessor (CallableAccessor), a value or reference type (ValueOrRefType), a declaration with accessors (DeclarationWithAccessors), a local function (LocalFunction) or a lambda expression (LambdaExp).

An attribute, for example [...] on line 1 in

An await expression, for example await AsyncMethodThatReturnsTask().

A base access, for example base on line 2 in

A binary arithmetic operation. Either an addition operation (AddExpr), a subtraction operation (SubExpr), a multiplication operation (MulExpr), a division operation (DivExpr), or a remainder operation (RemExpr).

A binary bitwise operation. Either a bitwise-and operation (BitwiseAndExpr), a bitwise-or operation (BitwiseOrExpr), a bitwise exclusive-or operation (BitwiseXorExpr), a left-shift operation (LeftShiftExpr), a right-shift operation (RightShiftExpr), or an unsigned right-shift operation (UnsignedRightShiftExpr).

A binary logical operation. Either a logical ‘and’ (LogicalAndExpr), a logical ‘or’ (LogicalAndExpr), or a null-coalescing operation (NullCoalescingExpr).

A binary operation. Either a binary arithmetic operation (BinaryArithmeticOperation), a binary bitwise operation (BinaryBitwiseOperation), a comparison operation (ComparisonOperation), or a binary logical operation (BinaryLogicalOperation).

A user-defined binary operator.

A binary pattern. For example, 1 or 2.

A pattern that may bind a variable, for example string s in x is string s.

A bitwise-and operation, for example x & y.

A bitwise operation. Either a unary bitwise operation (UnaryBitwiseOperation) or a binary bitwise operation (BinaryBitwiseOperation).

A bitwise-or operation, for example x | y.

A bitwise exclusive-or operation, for example x ^ y.

A block statement, for example

A Boolean literal, for example true.

The Boolean type, bool.

A branching preprocessor directive, such as IfDirective, ElifDirective, or ElseDirective.

A break statement, for example line 4 in

The byte type.

An unmanaged C/C++-style calling convention where the call stack is cleaned by the caller.

A call. Either a method call (MethodCall), a constructor initializer call (ConstructorInitializer), a call to a user-defined operator (OperatorCall), a delegate call (DelegateCall), an accessor call (AccessorCall), a constructor call (ObjectCreation), or a local function call (LocalFunctionCall).

An element that can be called.

An access to a callable. Either a method access (MethodAccess) or a local function access (LocalFunctionAccess).

A signature representing a calling convention. Specifies how arguments in a given signature are passed from the caller to the callee.

A case expression or statement.

A case statement.

A cast. Either an as expression (AsExpr) or a cast expression (CastExpr).

A cast expression, for example (string) x.

A catch clause within a try statement.

A Unicode character literal, for example 'a'.

The Unicode character type, char.

A user-defined checked addition operator (+), for example

A user-defined checked decrement operator (--), for example

A user-defined checked division operator (/), for example

A user-defined checked explicit conversion operator, for example

A checked expression, for example checked(2147483647 + ten).

A user-defined checked increment operator (++), for example

A user-defined checked minus operator (-), for example

A user-defined checked multiplication operator (*), for example

A checked statement, for example

A user-defined checked subtraction operator (-), for example

A class, for example

A collection initializer, for example { {0, "a"}, {1, "b"} } in

A collection of adjacent comment lines, for example

A single line of comment.

A comparison operation. Either an equality operation (EqualityOperation) or a relational operation (RelationalOperation).

A bitwise complement operation, for example ~x.

A user-defined complement operator (~), for example

A preprocessor directive with a branching condition, such as IfDirective or ElifDirective.

A conditional expression, for example s != null ? s.Length : -1 on line 2 in

A constant case of a switch statement, for example case OpCode.Nop: on line 2 in

A constant pattern, for example false in x is (_, false).

A constructed (bound) class. (See the comments on ConstructedType for more information.)

A constructed (bound) delegate type. (See the comments on ConstructedType for more information.)

A constructed generic.

A C# constructed (bound) interface. (See the comments on ConstructedType for more information.)

A constructed generic local function, for example the target f<int> of the function call f(5) on line 4 in

A constructed (bound) method, for example the target M<int> of the call on line 5 in

A constructed (bound) struct. (See the comments on ConstructedType for more information.)

A constructed (bound) type. This is a generic type for which actual type arguments have been supplied, for example G<int> or the G<T> in class Other<T> { G<T> g; }. Constructed types can be divided further into those that are open (for example G1<T> or G2<T,T,U,int>), in the sense that one or more of their type arguments is a type parameter, versus those that are closed (for example G1<int> or G2<long,long,float,int>).

A constructor, for example public C() { } on line 2 in

A constructor initializer call, for example base() (line 6) and this(0) (line 8) in

A continue statement, for example line 4 in

A program element that can possess control flow. That is, either a statement or an expression.

A user-defined conversion operator, for example

A decimal literal, for example 5m.

The high-precision decimal type, decimal.

A declaration.

A declaration that may have accessors. Either an event (Event), a property (Property), or an indexer (Indexer).

A declaration that may have a get accessor and a set accessor. Either a property (Property) or an indexer (Indexer).

A decrement operation. Either a postfix decrement operation (PostDecrExpr) or a prefix decrement operation (PreDecrExpr).

A user-defined decrement operator (--), for example

An attribute with default kind, for example [...] on line 1 in csharp [MyAttribute(0)] int SomeMethod() { return 1; }

A managed calling convention with fixed-length argument list.

A default case of a switch statement, for example default: on line 3 in

A #line default directive.

A default expression, for example default or default(string).

A #define directive.

A preprocessor symbol inside an expression, such as DEBUG in line 2 csharp #define DEBUG #if (DEBUG == true) Console.WriteLine("Debug version"); #endif

A delegate call, for example x() on line 5 in

A delegate creation. Either an explicit delegate creation (ExplicitDelegateCreation) or an implicit delegate creation (ImplicitDelegateCreation).

A function pointer or delegate call.

A delegate type, for example

A destructor, for example ~C() { } on line 2 in

A discard expression, for example _ in

A discard pattern, for example _ in x is (_, false)

A division operation, for example x / y.

A user-defined division operator (/), for example

A do-while statement, for example

A double literal, for example 5D.

The double type.

An access where the qualifier is a dynamic expression. Either a dynamic member access (DynamicMemberAccess) or a dynamic element access (DynamicElementAccess).

A call to an accessor where the qualifier is a dynamic expression, for example d.X on line 20 and d[0] on line 25 in

An element access where the qualifier is a dynamic expression, for example d[0] on line 12 in

An access to a dynamic element that reads the underlying value, for example d[0] on line 12 in

An access to a dynamic element that updates the underlying value, for example d[0] on line 12 in

An expression involving one or more dynamic sub expressions. Either a dynamic constructor call (DynamicObjectCreation), a dynamic method call (DynamicMethodCall), a dynamic operator call (DynamicOperatorCall), a dynamic member access (DynamicMemberAccess), a dynamic accessor call (DynamicAccessorCall), or a dynamic element access (DynamicElementAccess).

A possible target of a dynamic member access (DynamicMemberAccess). Either a field (Field), a property (Property), or an event (Event).

A member access where the qualifier is a dynamic expression, for example d.X on line 24 in

An access to a dynamic member that reads the underlying value, for example d.X on line 16 in

An access to a dynamic member that updates the underlying value, for example d.X on line 16 in

A method call where the qualifier or one of the arguments is a dynamic expression, for example M(d) on line 8 in

A call to a user-defined mutator operator where the operand is a dynamic expression, for example d++ on line 20 in

A constructor call where one of the arguments is a dynamic expression, for example new A(d) on line 8 in

A call to a user-defined operator where one of the operands is a dynamic expression, for example this + d on line 12 in

The dynamic type.

An equals operation, for example x == y.

A user-defined equals operator (==), for example

A program element. Either a control flow element (ControlFlowElement), an attribute (Attribute), a declaration (Declaration), a modifier (Modifier), a namespace (Namespace), a namespace declaration (NamespaceDeclaration), a using directive (UsingDirective), or type parameter constraints (TypeParameterConstraints).

An access to an element. Either an access to an indexer (IndexerAccess), an access to an array (ArrayAccess), or a dynamic element access (DynamicElementAccess).

An element initializer, for example the implicit call to Add(0, "a") on line 2 in

An access to an element that reads the underlying value. Either an access to an indexer (IndexerRead), an access to an array (ArrayRead), or an access to a dynamic element (DynamicElementRead).

An access to an element that updates the underlying value. Either an access to an indexer (IndexerWrite), an access to an array (ArrayWrite), or an access to a dynamic element (DynamicElementWrite).

An #elif preprocessor directive.

An #else preprocessor directive.

An empty location.

An empty statement, for example line 2 in

An #endregion directive.

An #endif preprocessor directive.

An enum. For example

An enum member constant. For example, ReadOnly and Shared in

An equality operation. Either an equals operation (EQExpr) or a not-equals operation (NEExpr).

An #error directive.

An event, for example E on line 3 in

An access to an event, for example the accesses to Click on lines 7 and 8 in

An internal helper class to share logic between EventAccess and EventCall.

An event accessor, for example add on line 4 or remove on line 5 in

A call to an event accessor, for example the call to add_Click (defined on line 5) on line 12 in

An access to an event that reads the underlying value, for example the accesses to Click on lines 7 and 8 in

An access to an event that updates the underlying value, for example the access to Click on line 7 in

A class that derives from System.Exception, and may be thrown as an exception.

An explicit cast. For example, the explicit cast from object to string on line 2 in

A user-defined explicit conversion operator, for example

An explicit delegate creation, for example new D(M) on line 6 in

An expression. Either an access (Access), a call (Call), an object or collection initializer (ObjectOrCollectionInitializer), a delegate creation (DelegateCreation), an array initializer (ArrayInitializer), an array creation (ArrayCreation), an anonymous function (AnonymousFunctionExpr), a local variable declaration (LocalVariableDeclExpr), an operation (Operation), a parenthesized expression (ParenthesizedExpr), a checked expression (CheckedExpr), an unchecked expression (UncheckedExpr), an is expression (IsExpr), an as expression (AsExpr), a cast (CastExpr), a typeof expression (TypeofExpr), a default expression (DefaultValueExpr), an await expression (AwaitExpr), a nameof expression (NameOfExpr), an interpolated string (InterpolatedStringExpr), a qualifiable expression (QualifiableExpr), or a literal (Literal).

An expression statement, for example M1() on line 5

An extension method, for example

A call to an extension method, for example lines 5 and 6 in

A user-defined false operator (false), for example

An unmanaged calling convention where arguments are passed in registers when possible.

A field. For example, the fields x and y in

An access to a field, for example the access to F on line 5 in

An access to a field that reads the underlying value, for example the access to F on line 5 in

An access to a field that updates the underlying value, for example the access to F on line 5 in

A file.

A fixed statement, for example lines 3–5 in

A float literal, for example 5F.

The float type.

A floating point type.

A folder.

A for loop, for example

A foreach loop, for example

A function pointer call, for example fp(1) on line 3 in

A function pointer type, for example

A greater-than or equals operation, for example x >= y.

A user-defined greater than or equals operator (>=), for example

A greater-than or equals pattern, for example >= 10 in x is >= 10

A greater-than operation, for example x > y.

A user-defined greater than operator (>), for example

A greater-than pattern, for example > 10 in x is > 10.

A general catch clause that does not specify the exception being caught.

A generic declaration. Either an unbound generic (UnboundGeneric) or a constructed generic (ConstructedGeneric).

A generic attribute with assembly kind, for example [...] on line 1 in csharp [assembly: MyAttribute<string>(0)]

A generic attribute, for example [...] on line 1 in

A generic attribute with default kind, for example [...] on line 1 in csharp [MyAttribute<string>(0)] int SomeMethod() { return 1; }

A generic attribute with module kind, for example [...] on line 1 in csharp [module: MyAttribute<string>(0)]

A generic attribute with return kind, for example [...] on line 1 in csharp [return: MyAttribute<object>(0)] int SomeMethod() { return 1; }

A get accessor, for example get { return p; } in

The global namespace. This is the root of all namespaces.

A goto case statement that jumps to a switch case.

A goto default statement that jumps to the default case.

A goto statement that jumps to a labeled statement, for example line 4 in

A goto statement.

A #line hidden directive.

An #if preprocessor directive.

An if statement, for example

An implicit accessor or event accessor parameter corresponding to the special value parameter. For example, the value parameter of set_ReadOnly in

An implicit cast. For example, the implicit cast from string to object on line 3 in

A user-defined implicit conversion operator, for example

An implicit delegate creation, for example the access to M on line 6 in

An increment operation. Either a postfix increment operation (PostIncrExpr) or a prefix increment operation (PreIncrExpr).

A user-defined increment operator (++), for example

An index expression, for example ^1 meaning “1 from the end”.

An indexer, for example string this[int i] on line 2 in

An access to an indexer, for example the access to c on line 5 in

An internal helper class to share logic between IndexerAccess and IndexerCall.

A call to an indexer accessor, for example the call to get_Item (defined on line 3) on line 7 in

A Property which holds a type with an indexer.

An access to an indexer that reads the underlying value, for example the access to c on line 5 in

An access to an indexer that updates the underlying value, for example the access to c on line 5 in

An instance constructor (as opposed to a static constructor), for example public C() { } on line 2 in

An int literal, for example 0.

The int type.

An integer literal. Either an int literal (IntLiteral), a long literal (LongLiteral), a uint literal (UIntLiteral), or a ulong literal (ULongLiteral).

An integral type.

An interface, for example

An interpolated string, for example $"Hello, {name}!" on line 2 in

An is expression.

A statement that changes the control flow and jumps to another statement.

A less-than or equals operation, for example x <= y.

A user-defined less than or equals operator (<=), for example

A less-than or equals pattern, for example <= 10 in x is <= 10.

A less-than operation, for example x < y.

A user-defined lesser than operator (<), for example

A less-than pattern, for example < 10 in x is < 10.

A label statement, for example line 7 in

A labeled pattern in a property pattern, for example Length: 5 in { Length: 5 }.

A labeled statement.

A lambda expression, for example (int x) => x + 1.

An expression whose target may be late bound when using dynamic subexpressions. Either a method call (MethodCall), an operator call (OperatorCall), a constructor call (ObjectCreation), a dynamic member access (DynamicMemberAccess), or a dynamic element access (DynamicElementAccess).

A left-shift operation, for example x << y.

A user-defined left shift operator (<<), for example

A #line directive, such as #line default, #line hidden, or #line directive with line number.

A list pattern. For example [1, 2, int y] in x is [1, 2, int y].

A literal. Either a Boolean literal (BoolLiteral), a Unicode character literal (CharLiteral), an integer literal (IntegerLiteral), a floating point literal (RealLiteral), a string literal (StringLiteral), or a null literal (NullLiteral).

A local constant, modeled as a special kind of local variable. For example, the local constant maxTries in

A local constant declaration, for example const int i = 0.

A local constant declaration statement, for example line 2 in

A local function, defined within the scope of another callable. For example, Fac on lines 2–4 in

An access to a local function, for example the access to Filter on line 4 in

A call to a local function, for example the call Fac(n) on line 6 in

A statement defining a local function. For example, the statement on lines 2–4 in

A locally scoped variable. Either a local variable (LocalVariable) or a parameter (Parameter).

An access to a local scope variable. Either an access to a parameter (ParameterAccess) or an access to a local variable (LocalVariableAccess).

An access to a local scope variable that reads the underlying value. Either an access to a parameter (ParameterRead) or an access to a local variable (LocalVariableRead).

An access to a local scope variable that updates the underlying value. Either an access to a parameter (ParameterWrite) or an access to a local variable (LocalVariableWrite).

A local variable, declared within the scope of a callable. For example, the variables total and s in

An access to a local variable, for example the access to x on line 3 in

A local variable initialization, for example int x = 0.

A local variable declaration, for example var i = 0.

A local declaration statement, for example line 2 in

An access to a local variable that reads the underlying value, for example the access to x on line 3 in

An access to a local variable that updates the underlying value, for example the access to x on line 3 in

A location of a program element.

A lock statement, for example

A logical ‘and’, for example x != null && x.Length > 0.

A logical ‘not’, for example !String.IsNullOrEmpty(s).

A logical operation. Either a unary logical operation (UnaryLogicalOperation), a binary logical operation (BinaryLogicalOperation), or a ternary logical operation (TernaryLogicalOperation).

A logical ‘or’, for example x == null || x.Length == 0.

A long literal, for example -5L.

The long type.

A loop statement.

A declaration that is a member of a type.

A member access. Either an access to a field (FieldAccess), an access to a property (PropertyAccess), an access to an indexer (IndexerAccess), an access to an event (EventAccess), an access to a method (MethodAccess), an access to a type (TypeAccess), or a dynamic member access (DynamicMemberAccess).

A member constant, modeled a special kind of field. For example, the constant Separator in

An access to a member (field), for example the access to F on line 5 in

A member initializer, for example X = 0 on line 6 in

A method, for example

An access to a method, for example the access to Filter on line 5 in

A method call, for example a.M() on line 5 in

A user-defined minus operator (-), for example

A declaration that can have a modifier.

A modifier, for example static, virtual, public and so on.

An attribute with module kind, for example [...] on line 1 in csharp [module: MyAttribute(0)]

A multiplication operation, for example x * y.

A user-defined multiplication operator (*), for example

A line of comment in a multiline style, for example each of the lines in

A mutator operation. Either an increment operation (IncrementOperation) or a decrement operation (DecrementOperation).

A call to a user-defined mutator operator, for example a++ on line 7 in

A not-equals operation, for example x != y.

A user-defined not equals operator (!=), for example

A nameof expression, for example nameof(s) on line 3 in

A namespace, for example

An access to a namespace, for example System in nameof(System).

An explicit namespace declaration in a source file. For example:

A nested type, for example class B in

A method that is not constructed. That is, either a method that is not a generic method or an unbound generic method (UnboundGenericMethod).

A non-nested type, that is declared directly in a namespace.

A user-defined not operator (!), for example

A not pattern. For example, not 1.

A null-coalescing operation, for example s ?? "" on line 2 in

A null literal.

The null type. The type of the null literal.

A #nullable directive.

A nullable type, for example int?.

A numeric #line directive, such as #line 200 file.

A constructor call, for example new A() on line 3 in

An object initializer, for example { X = 0, Y = 1 } on line 6 in

Either an object initializer (ObjectInitializer) or a collection initializer (CollectionInitializer).

The object type, System.Object.

An operation. Either an assignment (Assignment), a unary operation (UnaryOperation), a binary operation (BinaryOperation), or a ternary operation (TernaryOperation).

A user-defined operator.

A call to a user-defined operator, for example this + other on line 7 in

A user-defined or operator (|), for example

A binary or pattern. For example, 1 or 2.

A declaration that can be overridden or implemented. That is, a method, a property, an indexer, an event, an accessor, or an operator.

A parameter of a parameterizable declaration (callable, delegate, or indexer). For example, p in

An access to a parameter, for example the access to p on line 2 in

An access to a parameter that reads the underlying value, for example the access to p on line 2 in

An access to a parameter that updates the underlying value, for example the access to p on line 2 in

A parameterizable declaration. Either a callable (Callable), a delegate type (DelegateType), or an indexer (Indexer).

A parenthesized expression, for example (2 + 3) in

A pattern expression, for example (_, false) in

An expression or statement that matches the value of an expression against a pattern. Either an is expression or a case expression/statement.

A user-defined plus operator (+), for example

A pointer indirection operation, for example *pn on line 7, pa->M() on line 13, and cp[1] on line 18 in

A pointer type, for example char*.

A positional pattern. For example, (int x, int y).

A postfix decrement operation, for example x--.

A postfix increment operation, for example x++.

A #pragma checksum directive.

A #pragma warning directive.

A prefix decrement operation, for example --x.

A prefix increment operation, for example ++x.

A preprocessor directive, such as PragmaWarningDirective, PragmaChecksumDirective, DefineDirective, UndefineDirective, WarningDirective, ErrorDirective, NullableDirective, LineDirective, RegionDirective, EndRegionDirective, BranchDirective, or EndifDirective.

A property, for example P on line 2 in

An access to a property, for example the access to P on line 5 in

An internal helper class to share logic between PropertyAccess and PropertyCall.

A call to a property accessor, for example the call to get_P on line 5 in

A property pattern. For example, { Length: 5 }.

An access to a property that reads the underlying value, for example the access to P on line 5 in

An access to a property that updates the underlying value, for example the access to P on line 5 in

An expression that may have a qualifier. Either a member access (MemberAccess), an element access (ElementAccess), a method call (MethodCall) or a property access (PropertyAccess), or an accessor call (AccessorCall).

A range expression, used to create a System.Range. For example csharp 1..3 1..^1 3.. .. ..5 ..^1

A floating point literal. Either a float literal (FloatLiteral), a double literal (DoubleLiteral), or a decimal literal (DecimalLiteral).

A record, for example

A clone method on a record.

A record struct, for example csharp record struct RS { ... }

A record like type. This can be either a class or a struct.

A recursive pattern expression, for example string { Length: 5 } s in x is string { Length: 5 } s.

A reference expression, for example ref a[i] on line 2 in

A reference type.

A #region directive.

A relational operation. Either a greater-than operation (GTExpr), a less-than operation (LTExpr), a greater-than or equals operation (GEExpr), or a less-than or equals operation (LEEexpr).

A relational pattern, for example >1 in x is >1.

A remainder operation, for example x % y.

A user-defined remainder operator (%), for example

A remove event accessor, for example remove on line 5 in

An event removal, for example line 9 in

An attribute with return kind, for example [...] on line 1 in csharp [return: MyAttribute(0)] int SomeMethod() { return 1; }

A return statement, for example line 2 in

A right-shift operation, for example x >> y.

A user-defined right shift operator (>>), for example

The signed byte type, sbyte.

A conditional statement.

A set accessor, for example set { p = value; } in

The short type.

A signed integral type.

A simple type. Simple types in C# are predefined struct types. Here, however, they are not modeled as such, and we reserve the notion of structs to user-defined structs.

A single-line comment, for example line 1 in

A sizeof expression, for example sizeof(int).

A slice pattern. For example .. in `x is [1, .., 2].

A source file.

A location in source code, comprising of a source file and a segment of text within the file.

A line span #line directive, such as #line (1, 1) - (3, 10) 5 file.

A catch clause that catches a specific exception.

A stackalloc array creation, for example stackalloc char[] { 'x', 'y' }.

A static constructor (as opposed to an instance constructor), for example static public C() { } on line 2 in

An unmanaged calling convention where call stack is cleaned up by the callee.

A statement.

A string literal. Either a string literal (StringLiteralUtf16), or a u8 literal (StringLiteralUtf8).

A string literal, for example "Hello, World!".

A u8 literal, for example "AUTH"u8

The string type, System.String.

A struct, for example

A subtraction operation, for example x - y.

A user-defined subtraction operator (-), for example

A nullable warning suppression expression, for example x! in csharp string GetName() { string? x = ...; return x!; }

A switch expression or statement.

An arm of a switch expression, for example (false, false) => true.

A switch expression, for example csharp (a,b) switch { (false, false) => true, _ => false };

A switch statement, for example

A ternary logical operation, that is, a ternary conditional expression (ConditionalExpr).

A ternary operation, that is, a ternary conditional operation (ConditionalExpr).

A this access, for example this on line 5 in

An unmanaged C++-style calling convention for calling instance member functions with a fixed argument list.

A throw element. Either a throw expression (ThrowExpr) or a throw statement (ThrowStmt).

A throw expression, for example throw new ArgumentException("i") in return i != 0 ? 1 / i : throw new ArgumentException("i");

A throw statement, for example line 3 in

A property with a trivial getter and setter. For example, properties P1 and P2 are trivial, while P3 is not, in

An access to a trivial property - a property with a default getter and setter. For example, the access to P on line 5 in

A user-defined true operator (true), for example

A try statement, for example

An expression representing a tuple, for example (1, 2) on line 2 or (var x, var y) on line 5 in

A type representing a tuple. For example, (int, bool, string).

A type.

An access to a type, for example the access to C on line 3 in

A type access pattern, for example string in x is string.

A type container. Either a namespace (Namespace) or a type (Type).

A type mention, that is, any mention of a type in a source code file. For example, int is mentioned in int M() { return 1; }.

A type parameter, for example T in List<T>.

A set of type parameter constraints.

A type pattern, for example string in x is string, string s in x is string s, or string _ in x is string _.

A typeof expression, for example typeof(string).

A uint literal, for example 5U.

The unsigned int type, uint.

A ulong literal, for example 5UL.

The unsigned long type, ulong.

The unsigned short type, ushort.

A unary arithmetic operation. Either a unary minus operation (UnaryMinusExpr), a unary plus operation (UnaryPlusExpr), or a mutator operation (MutatorOperation).

A unary bitwise operation, that is, a bitwise complement operation (ComplementExpr).

A unary logical operation, that is, a logical ‘not’ (LogicalNotExpr).

A unary minus operation, for example -x.

A unary operation. Either a unary arithmetic operation (UnaryArithmeticOperation), a unary bitwise operation (UnaryBitwiseOperation), a sizeof operation (SizeofExpr), a pointer indirection operation (PointerIndirectionExpr), an address-of operation (AddressOfExpr), or a unary logical operation (UnaryLogicalOperation).

A user-defined unary operator - an operator taking one operand.

A unary pattern. For example, not 1.

A unary plus operation, for example +x.

A generic declaration with type parameters.

An unbound generic class, for example

An unbound generic delegate type. (See the comments on UnboundGenericType for more information.)

An unbound generic interface, for example

An unbound generic method. This is a generic method whose signature involves formal type parameters, For example M<T> on line 2 in

An unbound generic struct. (See the comments on UnboundGenericType for more information.)

An unbound generic type. This is a generic type with type parameters (for example List<T>) or elided type parameters (for example List<>).

An unbound generic local function, for example f on line 3 in

An unchecked expression, for example unchecked(ConstantMax + 10).

An unchecked statement, for example

An #undef directive.

A type that could not be resolved. This could happen if an indirect reference is not available at compilation time.

An unmanaged calling convention that indicates that the specifics are encoded as modopts.

An unsafe statement, for example

An unsigned integral type.

An unsigned right-shift operation, for example x >>> y.

A user-defined unsigned right shift operator (>>>), for example

A using block statement, for example

A using declaration statement, for example

A using directive. Either a namespace using directive (UsingNamespaceDirective) or a type using directive (UsingStaticDirective).

A namespace using directive, for example using System.

A type using directive, for example using static System.Console.

A using block or declaration. Either a using declaration (UsingDeclStmt) or a using block (UsingBlockStmt).

A value or reference type.

A value type.

A managed calling convention for passing extra arguments.

A variable. Either a variable with local scope (LocalScopeVariable) or a field (Field).

An access to a variable. Either an access to a local scope variable (LocalScopeVariableAccess) or an access to a field (FieldAccess).

A variable declaration pattern, for example string s in x is string s.

An access to a variable that reads the underlying value. Either an access to a local scope variable (LocalScopeVariableRead) or an access to a field (FieldRead).

An access to a variable that updates the underlying value. Either an access to a local scope variable (LocalScopeVariableWrite) or an access to a field (FieldWrite).

An assembly version, for example 4.0.0.0 or 4.5.

An access to a virtual event - an event that is virtual or defined in an interface. For example, the accesses to Click on lines 7 and 8 in

An access to a virtual indexer - an indexer that is virtual or defined in an interface. For example, the access to c on line 5 in

An access to a virtual method - a method that is virtual or defined in an interface. For example, the access to Filter on line 5 in

A virtual method call, for example a.M() on line 5 in

An access to a virtual property - a property that is virtual or defined in an interface. For example, the access to P on line 5 in

A member where the virtual modifier is valid. That is, a method, a property, an indexer, an event, or an operator.

The void type.

A #warning directive.

A while statement, for example

A with expression called on a record.

An attribute that occurs inside an XML element.

A sequence of characters that occurs between opening and closing tags of an XML element, excluding other elements.

A comment in an XML file.

A line of XML documentation comment, for example each of the lines in

An XML document type definition (DTD).

An XML element in an XML file.

An XML file.

An XML element that has a location.

A namespace used in an XML file.

An XmlParent is either an XmlElement or an XmlFile, both of which can contain other elements.

A user-defined xor operator (^), for example

A yield break statement, for example line 6 in

A yield return statement, for example line 4 in

A yield statement.

Provides different types of AssignableDefinitions.

INTERNAL: Do not use.

Provides classes representing the control flow graph within callables.

Provides classes for working with static single assignment (SSA) form.

DEPRECATED: Alias for AssignLeftShipExpr.

DEPRECATED: Alias for AssignRightShiftExpr.

A file or folder.

DEPRECATED: Alias for LeftShiftExpr.

DEPRECATED: Alias for LeftShiftOperator.

DEPRECATED: Alias for RightShiftExpr.

DEPRECATED: Alias for RightShiftOperator.

DEPRECATED: Alias for XmlAttribute

DEPRECATED: Alias for XmlCharacters

DEPRECATED: Alias for XmlComment

DEPRECATED: Alias for XmlDtd

DEPRECATED: Alias for XmlElement

DEPRECATED: Alias for XmlFile

DEPRECATED: Alias for XmlLocatable

DEPRECATED: Alias for XmlNamespace

DEPRECATED: Alias for XmlParent