JetBrains.Decompiler.Core

The type of the value.

The element type corresponding to .

When is an enum, this holds value of the underlying type.

True for null-conditional access ("?." and "?[]")

Compiler-generated backing field for field-like event

can be null, e.g. for abstract methods

Method or local function name

Compiler-generated backing field for auto-implemented property

Includes attributes, modifiers, types, and names.

Includes names only.

Includes the only name (no parenthesis).

Number of own (non hidden) parameters for local function or null for ordinary methods / lambdas

last (Parameters.Count - OwnParametersCount) parameters for local function are compiler generated

Local variable scope within method

MetadataVariable = other.MetadataVariable, InstructionsRange = other.InstructionsRange, if other.MetadataVariable not null (other.Type should be the same as Type)

true for a virtual call (callvirt), false for a non-virtual one (call).

Method or local function name

Last own parameter of array type is treated as "params" even if it does not have an [ParamArray] attribute (i.e. metadataParameter.IsParamArray is false).

This can happen if a compiler-generated method (lambda or local function) is used to create an anonymous delegate for which the Invoke method has the last parameter with attribute [ParamArray]

Real type for which static abstract/virtual interface member (method, operator, conversion, property, event) is called

null => discard

Finds first instruction from tree (from method in which root node instruction is located (if defined))

Gets parent instruction if parent exists, node.InstructionReference otherwise

Nulling node.InstructionReference which is equal to specified instruction for all subtree nodes

Local variable index for exception (or -1)

stloc.x / pop instruction or null

Normal read usage, like in Console.WriteLine(foo);

Write usage, like in foo = 1; or M(out foo);

Read-write usage, like in foo++; or M(ref foo);

s

Finds jump instruction (br, br.s, leave, leave.s) from eliminated empty jump block (intermediate block between branch and target blocks, before elimination: BranchBlock -> EliminatedEmptyJumpBlock -> TargetBlock)

last instruction from branch block

Finds jump instruction (br, br.s, leave, leave.s) from eliminated empty jump block (intermediate block between switch and case blocks, before elimination: SwitchBlock -> EliminatedEmptyJumpBlock -> CaseBlock)

last instruction from switch block (with switch opcode)

Gets first meaningful instruction starting from instruction with offset startInstructionOffset if it is jump instruction (br, br.s, leave, leave.s), null otherwise

Gets count of instructions from which control can be transferred to targetInstruction Slow!!!

Gets exception variable and instructionReference for it (or for CatchClause)

local variable index in myMethodBody.LocalVariables or -1

An empty (null) suggestion.

If is null then there is a conflict and no name of the given should be suggested.

Suggestion kind. If it is then no actual suggestion is made.

Name is in the plural form

true, if body has been rendered; false, if onlyRenderAsExpressionBodied is true, but method can not be rendered as expression-bodied true, if body has been rendered (even if an exception is thrown); false, if onlyRenderAsExpressionBodied is true, but method can not be rendered as expression-bodied

Used to omit redundant braces during pretty-printing. Names borrowed from 7.3.1.

Checks whether character is identifier-start-character in accordance with "Identifiers" (9.4.2) of C# standard

Checks whether character is identifier-part-character in accordance with "Identifiers" (9.4.2) of C# standard

Checks whether string is valid identifier in accordance with "Identifiers" (9.4.2) of C# standard

Checks whether character is letter-character in accordance with "Identifiers" (9.4.2) of C# standard

Checks whether character is combining-character in accordance with "Identifiers" (9.4.2) of C# standard

Checks whether character is decimal-digit-character in accordance with "Identifiers" (9.4.2) of C# standard

Checks whether character is connecting-character in accordance with "Identifiers" (9.4.2) of C# standard

Checks whether character is formatting-character in accordance with "Identifiers" (9.4.2) of C# standard

If is true, then annotation for type (only, not for its generic arguments) is not rendered and nullable context is not switched true, if body has been rendered; false, if onlyRenderAsExpressionBodied is true, but method can not be rendered as expression-bodied IL code in comment can be rendered even if method body was not rendered

Ensures that the setter/adder/remover parameter has the correct (for C#) name "value" (because in VB is allowed to use any other names)

(T)((UT)$1 >> $2) -> $1 >>> $2 when $1 has type T, T is int or long (UT is uint or ulong respectively)

$1 + c -> $1 - (-c) c + $1 -> $1 - (-c) for a negative constant c

0 - $1 -> -$1

*$array.Address($index[1], ..., $index[n]) -> $array[$index[1], ..., $index[n]]

RuntimeHelpers.InitializeArray((Array) new type[dimensions] /*arrayCreation*/, fieldReference) -> new type[dimensions]{literal initializer}

Case 1: handleVariable = fieldReference // handleAssignmentStatement RuntimeHelpers.InitializeArray((Array) arrayVariable, handleVariable) // initStatement or Case 2 (handleVariable was inlined) // handleAssignmentStatement is absent RuntimeHelpers.InitializeArray((Array) arrayVariable, fieldReference) // initStatement

data from fieldReference (field initial value)

new type[dimensions] // arrayCreation ... handleVariable = fieldReference // handleAssignmentStatement RuntimeHelpers.InitializeArray((Array) arrayVariable, handleVariable) // initStatement -> new type[dimensions]{literal initializer}

Inside constructor and before base..ctor/this..ctor call (for instance constructor)

($arrayCopy = $instance)[$indexCopy1 = $index[1], ..., $indexCopy[n] = $index[n]] = ($lhsType) ($arrayCopy[$indexCopy1, ..., $indexCopy[n]] $op $rhs) -> $array[$index[1], ..., $index[n]] $op= $rhs

This pattern is only used by unsafe code for incrementing or decrementing pointers.

($arrayCopy = $array)[$indexCopy1 = $index[1], ..., $indexCopy[n] = $index[n]] = ($temp = $arrayCopy[$indexCopy1, ..., $indexCopy[n]]) $op 1; -> $temp = $array[$index[1], ..., $index[n]] $op;

This pattern is only used by unsafe code for incrementing or decrementing pointers.

($arrayCopy = $array)[$indexCopy1 = $index[1], ..., $indexCopy[n] = $index[n]] = $arrayCopy[$indexCopy1, ..., $indexCopy[n]] $op 1 -> $op $array[$index[1], ..., $index[n]]

This pattern is only used by unsafe code for incrementing or decrementing pointers.

$targetCopy = $target; $temp2 = ($lhsType) ($temp1 = ($tempType) ($equivalentType) (($evaluationType) $targetCopy.$member $op $rhs)) $targetCopy.$member = ($lhsType) $temp1; -> $temp2 = ($lhsType) ($target.$member $op= $rhs) Typecasts involving $equivalentType, $lhsType, $evaluationType and $tempType are optional.

Case 1: $targetCopy = $target; $temp = ($tempType) (($equivalentType) (($evaluationType$) $targetCopy.$member op $rhs)) $targetCopy.$member = ($lhsType) $temp; or Case 2 ($temp was inlined): $targetCopy = $target; $targetCopy.$member = ($tempType) (($equivalentType) (($evaluationType$) $targetCopy.$member op $rhs)) -> $target.$member op= $rhs Typecasts involving $equivalentType, $evaluationType and $tempType are optional.

Case 1: $targetCopy = $target; $temp2 = ($tempType) ($equivalentType) (($evaluationType) ($temp1 = $targetCopy.$member) + 1) $targetCopy.$member = ($lhsType) $temp2; or Case 2 ($temp2 was inlined): $targetCopy = $target; $targetCopy.$member = ($tempType) ($equivalentType) (($evaluationType) ($temp1 = $targetCopy.$member) + 1) -> $temp1 = ($lhsType) ($target.$member++) Typecasts involving $equivalentType, $lhsType, $evaluationType and $tempType are optional.

($targetCopy = $target)[$indexCopy1 = $index[1], ..., $indexCopy[n] = $index[n]] = ($lhsType) (($evaluationType) $targetCopy[$indexCopy1, ..., $indexCopy[n]] op $rhs) -> $target[$index[1], ..., $index[n]] op= $rhs Typecasts involving $lhsType and $evaluationType are optional.

($targetCopy = $target)[$indexCopy1 = $index[1], ..., $indexCopy[n] = $index[n]] = ($lhsType) (($evaluationType) ($temp = $targetCopy[$indexCopy1, ..., $indexCopy[n]]) $op 1) -> $temp = $target[$index[1], ..., $index[n]]++ where $op is either or . Typecasts involving $lhsType and $evaluationType are optional.

$temp1 = $refParam; $local = Deref($refParam); $temp2 = ($temp2Type) ($equivalentType) (($evaluationType) $local + 1); // or $temp2 = op_Increment($local) Deref($temp1) = ($refParamType) $temp2; -> $local = ($refParamType) Deref($refParam)++; Typecasts involving $equivalentType, $refParamType, $evaluationType and $temp2Type are optional.

$temp1 = $refParam; $local = ($equivalentType) (($evaluationType) Deref($refParam) + 1); // or $local = op_Increment(Deref($refParam)) $temp2 = ($temp2Type) $local; Deref($temp1) = ($refParamType) $temp2; -> $local = ($refParamType) ++Deref($refParam); Typecasts involving $equivalentType, $refParamType, $evaluationType and $temp2Type are optional.

$lhs = ($lhsType) (($evaluationType) $lhs op $rhs) -> $lhs op= $rhs where $lhs is one of the following: a parameter; a local variable; a field; a property. a Deref(parameter); an indexer with simple target and local variables as indices; Typecast involving $lhsType and $evaluationType are optional.

Case 1: $lhsTemp = ($tempType) $argument; $rhsTemp = ($tempType) 1; $argument = ($lhsType) (($evaluationType) $lhsTemp + ($evaluationType) $rhsTemp); or Case 2 ($rhsTemp was inlined): $lhsTemp = ($tempType) $argument; $argument = ($lhsType) (($evaluationType) $lhsTemp + ($evaluationType) 1); -> or Case 2': $lhsTemp = ($tempType) $argument; $argument = ($lhsType) $lhsTemp + ($lhsType) 1); -> $argument++; if there are only 2 usages of $lhsTemp or $lhsTemp = ($tempType) ($argument++); where $argument is one of the following: a parameter; a local variable; a field; a property. a Deref(parameter); an indexer with simple target and local variables as indices;

$expr += 1 -> ++$expr $expr -= 1 -> --$expr

$local = ($lhsType) (($evaluationType) $argument + ($evaluationType) 1); $argument = ($lhsType) $local -> ++$argument; if there are only 2 usages of $local or $local = ($lhsType) (++$argument); where $argument is one of the following: a parameter; a local variable; a field; a property. a Deref(parameter); an indexer with simple target and local variables as indices;

yield break; for async iterator

(box bool) ($1 ? 1 : 0) -> (box bool)$1 (box bool) ($1 ? 0 : 1) -> (box bool)!$1 where $1 is typed as bool

!(a || b) -> !a && !b !(a && b) -> !a || !b !(a < b) -> a >= b !(a <= b) -> a > b !(a > b) -> a <= b !(a >= b) -> a < b !(a == b) -> a != b !(a != b) -> a == b

a || false -> a false || a -> a a && true -> a true && a -> a

$1 ? true : false -> $1 $1 ? false : true -> !$1 where $1 is typed as bool

(int) $1 -> $1 ? 1 : 0 where $1 is typed as bool

(bool) 1 -> true (bool) 0 -> false (bool) $1 -> $1 != 0 where $1 is typed as integer

(int) $1 == 1 -> $1 (and vice versa) (int) $1 == 0 -> !$1 (and vice versa) (int) $1 != 0 -> $1 (and vice versa) (int) $1 != 1 -> !$1 (and vice versa) (uint) $1 == 1U -> $1 (and vice versa) (uint) $1 == 0U -> !$1 (and vice versa) (uint) $1 != 0U -> $1 (and vice versa) (uint) $1 != 1U -> !$1 (and vice versa) (uint) $1 > 0U -> $1 (and vice versa) where $1 is typed as bool

A == A -> true A != A -> false A == B -> false A != B -> true where A and B are int literals and A != B

__unbox($arg, $type) -> ($type) $arg

arrayElementLoad: $arrayCopy[$indexCopy1, ..., $indexCopyN] arrayElementStore: ($arrayCopy = $array)[$indexCopy1 = $index1, ..., $indexCopyN = $indexN]

$arrayCopy = $array; $indexCopy1 = $index1; ... $indexCopyN = $indexN; ... [arrayElementStore = (case 1)] ... arrayElementLoad ...; [arrayElementStore = (case 2)] ...; arrayElementLoad, arrayElementStore: $arrayCopy[$indexCopy1, ..., $indexCopyN]

If loadExpression matches 1) $targetCopyVariable.Field 2) $targetCopyVariable.Property 3) *$targetCopyVariable then lhsExpression becomes 1) $target.Field 2) $target.Property 3) $target

case 1 if (condition) return a; else return b; -> return condition ? a : b;

if (condition) { ... return/throw/break/continue } else { statements } -> if (condition) { ... return/throw/break/continue } statements

case 1: if (target == null) [return (type) null]; [else] [return] target.XXX.YYY; // or target[index].YYY; .YYY is optional or case 1': if (target != null) [return] target.XXX.YYY; // or target[index].YYY; .YYY is optional [else] [return (type) null]; -> [return] target?.XXX.YYY; // or targetVariable?[index].YYY case 2: if (!target.HasValue) // target expression has Nullable type [return (type) null]; [else] [return] target.GetValueOrDefault().XXX.YYY; // or target.GetValueOrDefault()[index].YYY; .YYY is optional or case 2': if (target.HasValue) // target expression has Nullable type [return] target.GetValueOrDefault().XXX.YYY; // or target.GetValueOrDefault()[index].YYY; .YYY is optional [else] [return (type) null]; * (nullable result value): new Nullable() instead of (type) null new Nullable(target.XXX.YYY) instead of target.XXX.YYY new Nullable(target.GetValueOrDefault().XXX.YYY) instead of target.GetValueOrDefault().XXX.YYY -> [return] target?.XXX.YYY; // or target?[index].YYY

case 1: if (targetVariable != null) result = targetVariable; else result = elseExpression; -> result = targetVariable ?? elseExpression; case 2: if (targetVariable.HasValue) // targetVariable has Nullable type result = [(type)[box]] targetVariable.GetValueOrDefault(); else result = elseExpression; or case 2': if (targetVariable.HasValue) // targetVariable and result have Nullable type result = targetVariable else result = elseExpression; -> result = [(type)]targetVariable ?? elseExpression; // cast if targetVariable.Value.Type != type case 3: if (target != null) resultVariable = target.XXX.YYY; // or target[index].YYY; .YYY is optional else resultVariable = (type) null; or case 3': if (target != null) resultVariable = new Nullable(target.XXX.YYY); // or new Nullable(target[index].YYY); .YYY is optional else resultVariable = new Nullable() ; -> resultVariable = target?.XXX.YYY; // or targetVariable?[index].YYY case 4: if (target.HasValue) // target expression has Nullable type resultVariable = target.GetValueOrDefault().XXX.YYY; // or target.GetValueOrDefault()[index].YYY; .YYY is optional else resultVariable = (type) null; or case 4': if (target.HasValue) // target expression has Nullable type resultVariable = new Nullable(target.GetValueOrDefault().XXX.YYY); // or new Nullable(target.GetValueOrDefault()[index].YYY); .YYY is optional else resultVariable = new Nullable(); -> resultVariable = target?.XXX.YYY; // or target?[index].YYY case 5: if (condition) result = thenExpression; else result = elseExpression; -> result = condition ? thenExpression : elseExpression;

$1 ? true : $2 -> $1 || $2 $1 ? false : $2 -> !$1 && $2

($1) ($2 ? $3 : $4) -> $2 ? ($1) $3 : ($1) $4

$1 ? $2 : false -> $1 && $2 $1 ? $2 : true -> !$1 || $2

($B ? 1U : $E) > 0U -> $B || ($E > 0U) (and vice versa) ($B ? $E : 0U) > 0U -> $B && ($E > 0U) (and vice versa) ($B ? $E : 1U) > 0U -> !$B || ($E > 0U) (and vice versa) ($B ? 0U : $E) > 0U -> !$B && ($E > 0U) (and vice versa)

binaryOperation -> [!]condition operationType (expression > 0U)

var frameVariable = new <>c__DisplayClassX(); ... { var frameCopyVariable = frameVariable; () ... ...frameCopyVariable...(read usage[s]) ... [frameCopyVariable = (<>c__DisplayClassX) null;] }+ // no write usages of frameCopyVariable except 'frameCopyVariable = frameVariable' and 'frameCopyVariable = (<>c__DisplayClassX) null' -> var frameVariable = new <>c__DisplayClassX(); ... ...frameVariable...(read usage[s])

Block $branch: ... $local = $cachedDelegate if ($local == null) then goto $then else goto $else Block $then: case 1) $cachedDelegate = ($temp = new $delegateType($bodyMethod)); case 2) $temp = ($cachedDelegate = new $delegateType($bodyMethod)); $local = $temp Goto $else Block $else: [...$local...]* ... -> Block $branch: ... Goto $else Block $else: ...($delegateType) delegate $body... (or $local = new $delegateType($bodyMethod) ... [...$local...]*) ... The final usage is optional.

Set an order of closure extraction: closure of frameVariable should be extracted after myDependencies[frameVariable] closures

local = frameVariable.CachedDelegateField if (local == null) { temp2 = temp1 = delegateCreation(frameVariable, method) frameVariable.CachedDelegateField = temp1 local = temp2 } ...local...(* usage)

* usage of local

frameVariable.CacheField ?? (frameVariable.CacheField = delegateCreation) or closureVariable ?? (closureVariable = delegateCreation)

(Delegate) $lhs $op (Delegate) $rhs -> $lhs $op $rhs where op is either or .

$targetCopy = $target; $methodPointer = _methodptr($method); $result = new $delegateType((object) $targetCopy, $methodPointer); -> $result = new $delegateType($target.$method);

($delegateType) Delegate.Combine((Delegate) $lhs, $(Delegate) $rhs) -> $lhs + $rhs

Somewhere: $cachedDelegate = ($delegateType) null; Block $branch: ... if $cachedDelegate == null then goto $then else goto $else Block $then: $cachedDelegate = new $delegateType(this.$bodyMethod); Goto $else Block $else: ...$cachedDelegate$... ... -> Block $branch: ... Goto $else Block $else: ...($delegateType) delegate $body... ... The final usage is optional.

$targetVariable = $target; ... $methodPointer = _methodptr($method); $result = new $delegateType((object) $targetVariable, $methodPointer); -> $targetVariable = $target; ... $result = new $delegateType($targetVariable.$method);

Block $branch: ... if ($cachedDelegate == null) then goto $then else goto $else Block $then: $cachedDelegate = new $delegateType($bodyMethod); return [$cachedDelegate]; Block $else: return [$cachedDelegate]; -> Block $branch: ... Goto $else Block $else: case 1: return ($delegateType) delegate $body case 2: $delegateType local = ($delegateType) delegate $body; return;

Block $branch: ... $local = $cachedDelegate if ($local == null) then goto $then else goto $else Block $then: $cachedDelegate = ($temp = new $delegateType($bodyMethod)); return [$temp]; Block $else: return [$local]; -> Block $branch: ... Goto $else Block $else: case 1: return ($delegateType) delegate $body case 2: $delegateType local = ($delegateType) delegate $body; return;

Block $branch: ... if ($cachedDelegate == null) then goto $then else goto $else Block $then: $cachedDelegate = new $delegateType($bodyMethod); Goto $else Block $else: ...$cachedDelegate... ... -> Block $branch: ... Goto $else Block $else: ...($delegateType) delegate $body... ... The final usage is optional.

$targetCopy = $target; $methodPointer = __vmethodptr($targetCopy, $method); $result = new $delegateType((object) $targetCopy, $methodPointer); -> $result = new $delegateType($target.$method);

Tokens of local functions (owner == myMethod) that are used in localFunction (not declared!; recursive calls of localFunction are excluded)

Finds all local variables usages in local function, returns most outer scope where these variables are visible

Determines whether expression matches with "$cachedDelegateField == null"

Determines whether expression matches with "new $delegateType($bodyMethod)"

declaring type of delegate method

Determines whether statement matches with "$cachedDelegateField = new $delegateType($bodyMethod);"

declaring type of cachedDelegateField and delegate method

Determines whether statement matches with case 1 "$cachedDelegate = ($temp = new $delegateType($bodyMethod));" or case 2 "$temp = ($cachedDelegate = new $delegateType($bodyMethod));"

declaring type of cachedDelegateField and delegate method

($evaluationType) $lhs $op ($evaluationType) $rhs -> ($binaryOperationType) (($enumType) $lhs $op ($enumType) $rhs) where $op is one of &, |, ^, +, -, ==, !=, >, >=, <, <=. In certain cases type casts may be different.

~ ($evaluationType) $arg -> ($evaluationType) (~$arg)

try { try $1 } finally $2 -> try $1 finally $2 provided that the inner try statement has no finally or fault block.

catch (object $1) -> catch if $1 is not used

Case 1: Exception typedException = (Exception) obj; // typedExceptionInitialization, castToExceptionStatement if (typedException == null) // ifStatement throw obj/*exceptionObject*/; ExceptionDispatchInfo.Capture(typedException).Throw(); // callStatement or Case 2: if (!(obj is Exception typedException)) // typedExceptionInitialization, ifStatement (castToExceptionStatement is null) throw obj/*exceptionObject*/; ExceptionDispatchInfo.Capture(typedException).Throw(); // callStatement

if (exceptionObjectVariable != null) // ifStatement { typedException = exceptionObjectVariable as Exception; if (typedException == null) throw exceptionObjectVariable; ExceptionDispatchInfo.Capture(typedException).Throw(); } or if (exceptionObjectVariable != null) // ifStatement { if (!(exceptionObjectVariable is Exception typedException)) throw exceptionObjectVariable; ExceptionDispatchInfo.Capture(typedException).Throw(); }

method is System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw

method is System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture

case 1 (one catch with await): int catchIndex = 0; try {...} catch (...) { ... catchIndex = index; } if (catchIndex == 1) <catch body with await> => try {...} catch (...) {<catch body with await>} or case 2 (multiple catches with await): int catchIndex = 0; try {...} catch (...) { ... catchIndex = index1; } catch (...) { ... catchIndex = index2; } ... switch (catchIndex) { case index1: <catch body with await 1> case index2: <catch body with await 2> ... } => try {...} catch (...) { } catch (...) { <catch body with await 2> } ...

if temporary exception variable is used in <catch body with await> it will be replaced with exception variable Ordinal catch blocks can be present Special case 1: catch with filter Special case 2: Exception typedException = (Exception) obj; if (typedException == null) throw obj; ExceptionDispatchInfo.Capture(typedException).Throw(); => throw; Special case 3: try {...} with only one catch with await is the last statement in original method (return value is Task, not Task<T>) - 'if' is inverted in decompiled method Special case 4: try {...} is single statement inside other try with only finally block

leftVariable = (type) rightVariable; // assignment

Exception typedException = (Exception) obj; if (typedException == null) throw obj/*exceptionObject*/; ExceptionDispatchInfo.Capture(typedException).Throw(); => throw;

object exceptionObject = (object) null; int temp = 0; try {...} catch (object ex) { exceptionObject = ex; } <finally body with await> object tempExceptionObject = exceptionObject; if (tempExceptionObject != null) { Exception typedException = tempExceptionObject as Exception; if (typedException == null) throw tempExceptionObject; ExceptionDispatchInfo.Capture(typedException).Throw(); } exceptionObject = (object) null; => try {...} finally { <finally body with await> }

Can be combined with inner try-catch: if body of try contains single statement - try with several catch blocks and without finally block

Method(...) { throw new Ex(); // throw statement } => Method(...) { throw new Ex(); // throw expression }

Case 1: var temp = $expression; if (temp == null) throw new Ex(); a) return temp; b) $x = temp; c) SimpleExpression(..., temp, ...); => a) return $expression ?? throw new Ex(); b) $x = $expression ?? throw new Ex(); c) SimpleExpression(..., $expression ?? throw new Ex(), ...); Case 1', 1'', 1''': if (!temp.HasValue) throw new Ex(); ... temp ... // case 1' or ... temp.GetValueOrDefault() ... // case 1'' or ... new tempVariableNullableType(temp.GetValueOrDefault()) // case 1''' Case 2: if ($condition) throw new Ex(); a) return $expression; b) $x = $expression; => a) return !$condition ? $expression : throw new Ex(); b) $x = !$condition ? $expression : throw new Ex(); NB: $condition and $expression (or $x) should have at least one common reference to local variable / parameter / field / property (should have "correlation")

if (...) // negate = false nextStatement; else throw; or if (...) // negate = false nextStatement; // terminating statement throw; or if (...) // negate = true throw; [else] nextStatement;

__box(default ($1), $1) == null ? System.Activator.CreateInstance<$1>() : default($1) -> new $1() where $1 is a type argument having .

if (__box(default ($1), $1) != null) return default($1); else return System.Activator.CreateInstance<$1>(); -> return new $1(); where $1 is a type argument having .

System.Activator.CreateInstance<$1>() -> new $1() where $1 is a type argument having .

case 1: call M(..., new T[]{expr1, ..., exprN}) => call M(..., expr1, ..., exprN) case 2: call M(..., new T[0]) => call M(...) case 3: call M(..., System.Array.Empty<T>()) => call M(...) where M(..., params T[] args) {...}

return false; or resultVariable = false; -> yield break;

this.$currentField = $result; this.$state = $successorState; return true; or resultVariable = true; -> yield return $result;

local variable for this.<>1__state

expression: stateVariable != stateValue1 && ... && stateVariable != stateValueN -> stateValues = stateValues + {stateValue1, ..., stateValueN}

(uint)(stateVariable - startStateValue) > k can be used instead of sequence stateVariable != startStateValue && stateVariable != (startStateValue + 1) && ... && (stateVariable != startStateValue + k)

true - double, false - float

value -> (Numerator/Denominator) * constant -> (Numerator * constant) / Denominator

value -> (Numerator/Denominator) / constant -> Numerator / (Denominator * constant)

Let $local be a local with the only reference. Remove $local = $constExpr;. $local = $call -> $call $local = $call ? 1 : 0 -> $call

case1: local = arrayCreation ... temp1 = expression1 ... tempN = expressionN temp = expression "main expression" local[temp1, ..., tempN] = temp ... or case 2: local = arrayCreation ... temp1 = expression1 ... tempN = expressionN local[temp1, ..., tempN] = expression ... -> local = arrayCreation ... local[expression1, ..., expressionN] = expression ... where expression1, ..., expressionN, expression do not change state

local = objectCreation ... temp1 = expression1 ... tempN = expressionN local.Add(temp1, ..., tempN) ... -> local = objectCreation ... local.Add(expression1, ..., expressionN) ... where expression1, ..., expressionN do not change state

local = objectCreation ... temp = expression local.Member = temp ... -> local = objectCreation ... local.Member = expression ... where expression does not change state

... tempLocalVariable = this ...tempLocalVariable[.TypeMember]... -> ... ...this[.TypeMember]...

... tempLocalVariable = expression ...tempLocalVariable... -> ... ...expression...

'copy = this;': if copy has only member access other usages => replace with 'this'

Checks whether expression can change state (local variables, fields etc.)

case 1: Monitor.Enter((object) ($copy = $expr)); try { $body } $MonitorExitBlock or case 2: $copy = $expr; Monitor.Enter((object) $copy); try { $body } $MonitorExitBlock where $MonitorExitBlock: finally { Monitor.Exit((object) $copy); } [$copy = (ExprType) null] -> lock ($expr) $body

case 1: $flag = false; try { Monitor.Enter((object) ($copy = $expr), ref $flag); $body } $MonitorExitBlock or case 2: $copy = $expr $flag = false; try { Monitor.Enter((object) ($copy), ref $flag); $body } $MonitorExitBlock or case 3: $flag = false; try { $copy = $expr; Monitor.Enter((object) $copy, ref $flag); $body } $MonitorExitBlock where $MonitorExitBlock: finally { if ($flag) { Monitor.Exit((object) $copy); } } [$copy = (ExprType) null] -> lock ($expr) $body

Monitor.Enter((object) null); try $body finally { Monitor.Exit((object) null); } -> lock (null) $body

var $flag = false; try { Monitor.Enter((object) null, &$flag); $body } finally { if ($flag) { Monitor.Exit((object) null); } } -> lock (null) $body

using ($lockExpression.EnterScope()) $body -> lock ($lockExpression) $body $lockExpression has System.Threading.Lock type

The transformation should be applied after ExtractNotNullableUsingTransformation

Case 1: $1 enumerator = collection.GetAsyncEnumerator([new CancellationToken()]) try // try/finally is optional { while (true) { if (await enumerator.MoveNextAsync()) { ... enumerator.Current ... } else break; } } finally { [if (enumerator != null)] await enumerator.DisposeAsync(); } [enumerator = ($1) null; or enumerator = new CollectionType.EnumeratorType();] or Case 2: see Case 1 except: while (await enumerator.MoveNextAsync()) { ... enumerator.Current ... } -> await foreach(item in collection) { ... item ... }

$1 enumerator = collection.GetEnumerator() try { while (enumerator.MoveNext()) { ... enumerator.Current ... } } finally { enumerator.Dispose() } [enumerator = new CollectionType.EnumeratorType()] - if CollectionType.EnumeratorType is struct (clearing field of compiler generated class) or $0 temp = collection $1 enumerator = $temp.GetEnumerator() temp = ($0) null; try { while (enumerator.MoveNext()) { ... enumerator.Current ... } } finally { if (enumerator != null) (IDisposable enumerator).Dispose() } enumerator = ($1) null; ($1 implements IDisposable) or $1 enumerator = collection.GetEnumerator() while (enumerator.MoveNext()) { ... enumerator.Current ... } [enumerator = ($1) null;] -> foreach($2 item in collection) { ... item ... }

Returns innerExpression if expression is (UnresolvedStructType) @innerExpression, where Type of innerExpression is UnresolvedStructType

if (disposable != null) ([(IDisposable)] disposable).Dispose();

$1 list = $2; for (int index = 0; index < list.Length; ++index) $3 -> foreach ($4 item in list) $3 Here $4 is the element type of list, $3 contains the only read usage of index, namely of the form list[index]. The latter usage is replaced by item.

#branchBlock: ... variable = leftArgument if ([box]variable == null) then goto(#nullBlock) else goto(#notNullBlock) #nullBlock: variable = rightArgument goto(#notNullBlock) #notNullBlock: ... -> #branchBlock: ... variable = leftArgument ?? rightArgument goto(#notNullBlock) #notNullBlock: ...

#branchBlock: if (case 1: [box]variable == null or case 2, 2': !variable.HasValue) then goto(#nullBlock) else goto(#notNullBlock) #nullBlock: return [(returnType)] rightArgument; #notNullBlock: return [(returnType)] case 1, 2': variable or case 2: variable.GetValueOrDefault() -> return [(returnType)] variable ?? [(returnType)] rightArgument

$1 as $2 == null -> !($1 is $2) $1 as $2 != null -> $1 is $2

{ this..ctor($arg); $body } -> : this($args) { $body } { $field-initializers base..ctor($args); $body } -> : base($args) { $body } Empty base() call is eliminated. Also instance field initializers are extracted. For struct: { * (StructType*) & ref * this = new StructType(); $body } -> : this() { $body } { * this = new StructType($args); $body } -> : this($args) { $body }

Not null for indexer

var local = [(type)] ([(baseType)]expression).<Clone>$(); ([(baseType)] local).Property1 = ValueExpression1; / ([(baseType)] local).Field1 = ValueExpression1; ... ([(baseType)] local).PropertyN = ValueExpressionN; / ([(baseType)] local).FieldN = ValueExpressionN; -> var local = expression with {Property1 / Field1 = ValueExpression1, ..., PropertyN / FieldN = ValueExpressionN };

Type.GetTypeFromHandle(__reftypetoken ($1)) -> __reftype ($1)

{ $field-initializers $body } -> { $body }

var local = expression; local.Property1 = ValueExpression1; / local.Field1 = ValueExpression1; ... local.PropertyN = ValueExpressionN; / local.FieldN = ValueExpressionN; where expression has struct type -> var local = expression with {Property1 / Field1 = ValueExpression1, ..., PropertyN / FieldN = ValueExpressionN };

Type.GetTypeFromHandle(__typeref ($1)) -> typeof ($1)

this.Member = parameter

base..ctor(...)

$1 <= null -> $1 == null $1 > null -> $1 != null

try { $body } finally { base.Finalize(); } -> $body

Case 1: object.Equals((object)[(ValueType/Enum)] $literal, $expression) or Case 2: $expression is Type && (Type) $expression == $literal) or Case 2': $expression is Type && unbox($expression, Type) == $literal) where Type - $literal type, $expression - local variable reference or parameter reference or Case 3: object.Equals((object)[box(Type)] $literal, $expression) or Case 4: $expression is Type t && t == $literal -> $expression is [(Type)]$literal "(Type)" - if Type != $literal.Type in case 3 or Case 5: case Type t when t == $literal , no other usages of t -> case $literal

if (box(ex) is T) { local = unbox(box(ex) as T, T) ... } => if (ex is T local) { ... }

Case 1: if (ex is T) { local = unbox(ex, T) ... } => if (ex is T local) { ... } Case 2: if (ex is T) { ...unbox(ex, T)... } => if (ex is T temp) { ...temp... }

Case 1: [(object)] (castLocal = argument as T) op null Case 1': ... castLocal = argument as T; if (castLocal op null) ... Case 2: (box) (castLocal = (unbox) (((box) argument) as T)) op null Case 2': castLocal = (unbox) (((box) argument) as T) if (((box) castLocal) op null) ... Case 3: (T)([(box)](tempLocal = argument) as T) == null ... [castLocal =] [(T)] (unbox(T)) (object) tempLocal ... or Case 3': (T)([(box)](tempLocal = argument) as T) == null ... [castLocal =] [(T)] (unbox(T)) (boxed(OrigT)) (box(OrigT)) (OrigT) tempLocal ... -> [!] (argument is T castLocal)

castLocal = [(unbox)] (([(box)] argument) as T) if (([(box)] castLocal) op null) ... => [!] (argument is T castLocal)

nullComparisonNode: x op null => [!] argument is targetType castLocal

nullComparisonNode: x op null x: ... tempLocal (1) = argument ... ... [t =] initializer ... initializer: ... tempLocal (2) ... => [!] argument is targetType t ... [t] ...

[(T)] (unbox(T)) (object) tempLocal (2) or [(T)] (unbox(T)) (boxed(OrigT)) (box(OrigT)) (OrigT) tempLocal (2)

Compiler-generated record members existence

Second chance (<Clone>$, PrintMembers and .ctor (only copy constructor) can be private compiler-generated => filtered in ClassDecompiler.IsRegularMethod => not found in GetRecordMembersFromDecompiledMethods)

^@ $1 -> $1

Make implicit each deref of the form ^$1 where $1 is a parameter/variable/member call having or a this reference in a value type. Replace all other references $1 to such variables with @^$1 where deref is implicit.

Remove empty block statement.

Remove empty statement.

{ $1 } -> $1

string.Concat($1, ..., $n) -> $1 + ... + $n or string.Concat(<literal1>, $expression1, ..., $expressionN, <literalM>) -> $"<literal1>{$expression1} ... {$expressionN}<literalM>"

string.Concat($1, ..., $n) -> $1 + ... + $n or string.Concat(<literal1>, $expression1, ..., $expressionN, <literalM>) -> $"<literal1>{$expression1} ... {$expressionN}<literalM>"

DefaultInterpolatedStringHandler interpolatedStringHandler = new DefaultInterpolatedStringHandler(...); (interpolatedStringHandler.AppendFormatted(expressionI[,alignment][,format]); or interpolatedStringHandler.AppendLiteral(StringLiteralI);)* ...interpolatedStringHandler.ToStringAndClear()...; => $"({expressionI[,alignment][:format]} or StringLiteralI)*"

DefaultInterpolatedStringHandler interpolatedStringHandler = new DefaultInterpolatedStringHandler(...); (interpolatedStringHandler.AppendFormatted(expressionI[,alignment][,format]); or interpolatedStringHandler.AppendLiteral(StringLiteralI);)* ...interpolatedStringHandler.ToStringAndClear()...; => $"({expressionI[,alignment][:format]} or StringLiteralI)*"

switch ($expr ? 1 : 0) { case 1: $true-block; case 0: $false-block; } -> switch ($expr) { case true: $true-block; case false: $false-block; } where $expr is typed as bool

expression is [(expectedTpe1)[(expectedType2)]]innerExpression

value in [lowerBound, upperBound]

[rangeStart, rangeStart+rangeLength] in [lowerBound, upperBound]

Eliminate empty case if no default clause is present. Put default clause after the switch statement if all switch cases are terminating. switch ($expr) { $cases default: $default-handler } -> switch ($expr) { $cases } $default-handler Eliminate empty default clause. switch ($expr) { $cases default: ; } -> switch ($expr) { $cases }

s == value or s.Equals(value) or s.Length == 0 (=> value is string.Empty)or s == null (=> value is null) (maybe != => negation)

expression is stringExpression.Length

Deconstruct invocations, variable of tuple type assignments: target.Deconstruct(out expr1, ..., out exprN), where Deconstruct can be instance or extension method, exprX can be local variable, field or parameter, or tupleVariable = target, where target has tuple type, or itemVariableX.Deconstruct(out nestedExpr1, ..., out nestedExprN), or nestedTupleVariableX = parentTupleVariable.ItemX Conversions (if needed): exprX = (TypeX) itemVariableX, or exprX = (TypeX) tupleVariableX.ItemX Assignments: exprX = itemVariableX, or exprX = tupleVariableX.ItemX -> (item1Expr, item2Expr, ..., itemNExpr) = target, itemXExpr may be nested tuple expression (nestedXItem1Expr, ..., nestedXItemMExpr)

Checks whether tupleComponentAccess is tupleVariable.ItemX.ItemY...ItemZ, (indices = (X, Y, ..., Z), types = (type of tupleVariable.ItemX, type of tupleVariable.ItemY, ..., type of tupleVariable.ItemZ))

indices from 1

new ValueTuple<T1, ..., TN>(arg1, ..., argN) where N <= 7 -> (arg1, ..., argN) or new ValueTuple<T1, ...T7, ValueTuple<...>>(arg1, ..., arg7, (restArg1, ..., restArgM)) -> (arg1, ..., arg7, restArg1, ..., restArgM)

does not change the state of this object, when returns false

Deconstruction-declaration can appear only on the left side (as left argument) of the assignment statement

Deconstruction-declaration can contain only [specified, if variables != null] local variable references, discards, or other deconstruction-declarations as tuple components

expression of tuple type tuple component index starting from 1

target.ItemN => N target.Rest....Rest.ItemN, [Rest M times] => N + 7 * M expr.Rest => 0

(ReadOnlySpan<T>) stackalloc T[length] // where (ReadOnlySpan<T>) - implicit conversion from Span<T>, // stackalloc with implicit conversion to Span<T> -> stackalloc T[length] // stackalloc with implicit conversion to ReadOnlySpan<T>

($1) $2 == ($1) $3 -> $2 == $3 ($1) $2 != ($1) $3 -> $2 != $3

when the following conditions are met: the types of $2 and $3 are same and numeric the basic types of $1, $2, and $3 are the same

($1) $2 == $3 -> $2 == $3 ($1) $2 != $3 -> $2 != $3

when the following conditions are met: the types of $2 and $3 are same and numeric the basic types of $1, $2, and $3 are the same

Check whether the method is explicitly implemented in targetType (or in base types)

($1) $2 -> $2 where $2 is typed as $1

(($UnsignedIntegralType) $expr) > 0 (of ($UnsignedIntegralType)) -> $expr != 0 or (($UnsignedIntegralType) $expr) <= 0 (of ($UnsignedIntegralType)) -> $expr == 0 typeof($expr) is signed integral

(($type) $expr) $op $literal or $literal $op (($type) $expr) where $op is comparison operation (unchecked), typeof($expr) is integral or char, $type is integral (with different constraints for relational and equality $op), $type == typeof($literal) -> $expr $op $newLiteral or $newLiteral $op $expr where $newLiteral = (typeof($expression)) $literal

($refType&) $argument -> &*(($refType*) $argument) where $argument has pointer type

($type) @$expr -> ($type) &$expr if $type is a pointer or a numeric type.

[$length = $totalLengthLiteral or $lengthVar; // where $totalLengthLiteral = $elementCount * $elementSize; elementSize = 1 in case $lengthVar] $lengthTemp = (IntPtr) (UIntPtr) (uint) $length; $arrayTemp = __untypedstackalloc($lengthTemp); case 1.1: - case 1.2: $tempFieldPointer = @<PrivateImplementationDetails>.XXX $lengthInBytesTemp = $totalLengthLiteral __memcpy([(IntPtr)] $arrayTemp, $tempFieldPointer, $lengthInBytesTemp); // cpblk IL instruction case 1.3: $initValueTemp = $initValue $lengthInBytesTemp = $totalLengthLiteral __memset([(IntPtr)] $arrayTemp, $initValueTemp, $lengthInBytesTemp); // initblk IL instruction case 2.1: [$array = ($arrayType) $arrayTemp;/ $array = ($arrayType)(IntPtr) $arrayTemp;] case 2.2: $spanLengthTemp = $elementCountLiteral or $lengthVar; // $elementCountLiteral = $elementCount $span = new Span<$elementType>((void*) $arrayTemp, $spanLengthTemp); -> (2.1)$array / (2.2)Span<$elementType> $span = stackalloc $arrayType[$elementCount or $lengthVar or $length] (1.1) - / (1.2, 1.3) {literal initializer};

try { __pinned $type $variable = $initializer; $restOfTry } finally { __unpin($variable); $restOfFinally } -> fixed ($type $variable = $initializer) { try $restOfTry finally $restOfFinally } __pinned $type $variable = $initializer; $body __unpin($variable); $otherUnpins -> fixed ($type $variable = $initializer) { $body $otherUnpins } __pinned $type $variable = $initializer; $bodyWithoutUnpin -> fixed ($type $variable = $initializer) { $bodyWithoutUnpin }

[$length = $lengthVar] $lengthTemp = (IntPtr) (UIntPtr) (uint) $length; $elementSizeTemp = $size; $totalSizeTemp = checked ($lengthTemp * $elementSizeTemp); $arrayTemp = __untypedstackalloc($totalSizeTemp); case 1: [$array = ($arrayType) $arrayTemp;] case 2: $spanLengthTemp = $lengthVar; $span = new Span<$elementType>((void*) $arrayTemp, $spanLengthTemp); -> case 1: $array = stackalloc $arrayType[$length] case 2: Span<$elementType> $span = stackalloc $arrayType[$length];

($pointerType) 0 -> ($pointerType) null

$arrayCopy = $array; $indexCopy1 = $index1; ... $indexCopyN = $indexN; ... $arrayCopy[$indexCopy1, ..., $indexCopyN] = [$lhsType] ($arrayCopy[$indexCopy1, ..., $indexCopyN] $op $rhs) ... where $lhsType is pointer type -> ... $array[$index1, ..., $indexN] $op= $rhs ...

$arrayCopy = $array; $indexCopy1 = $index1; ... $indexCopyN = $indexN; $temp = $arrayCopy[$indexCopy1, ..., $indexCopyN]; $arrayCopy[$indexCopy1, ..., $indexCopyN] = $temp $op 1; [...$temp...] where array element has pointer type -> $temp = $array[$index1, ..., $indexN] $op; [...$temp...]

$arrayCopy = $array; $indexCopy1 = $index1; ... $indexCopyN = $indexN; $temp = $arrayCopy[$indexCopy1, ..., $indexCopyN] $op 1; $arrayCopy[$indexCopy1, ..., $indexCopyN] = $temp; [...$temp...] where array element has pointer type -> $temp = $op $array[$index1, ..., $indexN]; [...$temp...]

*($pointer + $index) -> $pointer[$index]

(*$target).$field -> $target->$field

(*$target).$method($args) -> $target->$method($args)

($evaluationType) $lhs $op ($evaluationType)$ rhs -> $lhs $op $rhs where $op is ==, !=, <, <=, >, >=, $lhs and $rhs are pointers, and $evaluationType is either a pointer, a reference, or .

(*$target).$property -> $target->$property

(IntPtr) $lhs $op $delta -> (IntPtr) (($properUnderlyingType*) $lhs $op $rhs) where $lhs is a pointer or reference type with a given $underlyingType and $op is either + or -. Let $size be the static size of $underlyingType (if known). The following cases are possible for $delta: $delta is an or literal divisible by $size. In this case $rhs is (IntPtr) ($delta / $size) (which will be treated by later) and $properUnderlyingType is $underlyingType. $delta is an literal not divisible by $size. In this case $rhs is $delta and $properUnderlyingType is byte. $delta is (IntPtr) $recordCount * sizeof($properUnderlyingType). In this case $rhs is $recordCount and $properUnderlyingType is derived from the above. $delta is (IntPtr) sizeof($properUnderlyingType). In this case $rhs is 1 and $properUnderlyingType is derived from the above. $size of $underlyingType is known statically and $delta is (IntPtr) $recordCount * $size. In this case $rhs is $recordCount and $properUnderlyingType is $underlyingType. $size of $underlyingType is 1 and $delta is (IntPtr) $recordCount. In this case $rhs is $recordCount and $properUnderlyingType is $underlyingType.

((IntPtr) $lhs - (IntPtr) $rhs) / $size -> (IntPtr) (($elementType*) $lhs - ($elementType*) $rhs)) $elementType is selected based on the types of $lhs, $rhs and $size

Case 1: $temp = $initializer; -> __pinned $underlyingType* $newVariable = &*$initializer; where $initializer has a reference type. Case 2: $temp = ($array = $initializer) == null || $array.Length == 0 ? ($pinnedType) IntPtr.Zero : ($pinnedType) @$array[0]; ... usages of $temp ... $temp = ($pinnedType) IntPtr.Zero where $temp variable is pinned where $initializer has an array type. or Case 2' $temp = ($array = $initializer) == null || $array.Length == 0 ? ($pinnedType) null : ($pinnedType) &$array[0]; ... usages of $temp ... $array = ($arrayType) null where $array variable is pinned where $initializer has an array type. -> __pinned $underlyingType* $newPinned = $initializer; Each reference to $temp is replaced by ($pinnedType*) $newPinned. $temp = ($pinnedType) 0; or $array = ($arrayType) null; -> __unpin($newPinned);

$temp is inlined (Case 2', ): case 2'* ... ($array = $initializer) == null || $array.Length == 0 ? ($pinnedType) null : ($pinnedType) &$array[0] ...; array = (arrayType) null; or case 2'** $array = $tempArray = $initializer; ... $tempArray == null || $array.Length == 0 ? ($pinnedType) null : ($pinnedType) &$array[0] ...; array = (arrayType) null;

$array = stackalloc T[N]; *$array = $init0; $array[1] = $init1; $array[2] = $init2; ... $array[N-1] = $initN1; [$someExpr = $array; or ... new Span<T>((void*) $array, N) ...;] -> $array = stackalloc T[$length] { $init0, $init1, $init2, ..., $initN1 }; // or $someExpr = stackalloc T[$length] { $init0, $init1, $init2, ..., $initN1 }; // or ... stackalloc T[$length] { $init0, $init1, $init2, ..., $initN1 }...; with implicit cast to Span<T>

$lengthTemp = (IntPtr) (UIntPtr) (uint) $length; and there are 2 references to $lengthTemp variable

$arrayTemp = __untypedstackalloc($lengthTemp);

$spanLengthTemp = $spanLengthExpression; $span = new Span<$elementType>((void*) $arrayTemp, $spanLengthTemp);

$lengthTemp2 = $realLengthExpression; // lengthTemp2AssignmentStatement $lengthTemp = (IntPtr) (UIntPtr) (uint) $lengthTemp2;

arrayTempUsageStatement: ... ($arrayType) $arrayTemp ... isArrayAssignment: arrayTempUsageStatement is $array = ($arrayType) $arrayTemp;

if isArrayAssignment: arrayTempUsage is replaced with stackalloc if !isArrayAssignment: arrayTempUsage is replaced with temp variable and temp = stackalloc ...; is added before arrayTempUsageStatement

Case 1: $pinned = $initializer; $charPointer = (IntPtr) $pinned; //or $charPointer = (char*) $pinned; if ($charPointer != IntPtr.Zero) //or (IntPtr) $charPointer != IntPtr.Zero { $offset = System.Runtime.CompilerServices.RuntimeHelpers.OffsetToStringData; $charPointer += (IntPtr) $offset; // or without cast } or Case 2: the same code but with inlined $offset variable -> __pinned char* $newPinned = $initializer; $pinned = (string) null; -> __unpin($newPinned); Each reference to $charPointer is replaced by ($charPointerType) $newPinned.

Case 1 temp = @local; ^temp = default(T); where T - generic argument with struct constraint -> local = default(T); temp = @local; or Case 2 temp = @local; *((localType*) temp) = new localType(...); where localType is struct -> local = new localType(...); temp = @local;

rearrange address and creation

*$pointer -> $pointer[0] where $pointer is either a fixed or stackalloc array.

$temp = (IntPtr) $expression; ... read usages of $temp variable ... -> $newTemp = $expression; all read usages of $temp are replaced with (IntPtr) $newTemp

Preparation for

*AddressOf($target) -> $target

($type[1]) ... ($type[n]) ($pointer1 - $pointer2) -> ($type[1]) ($pointer1 - $pointer2) where $type[i] is either IntPtr, UIntPtr, long, or ulong.

*((StructType*)parameter) -> ^parameter where parameter has StructType& type (..., ref StructType parameter, ...)

pinnedArrayVariable[0] if thenTypeCastArgument is (type) null, else is &pinnedArrayVariable[0]; null otherwise arrayVariable[0] if thenTypeCastArgument is (type) IntPtr.Zero, else is @arrayVariable[0]; null otherwise

($arrayCopy = $array)[$indexCopy1 = $index[1], ..., $indexCopy[n] = $index[n]] = $op($temp = $arrayCopy[$indexCopy1, ..., $indexCopy[n]]); -> $temp = $array[$index[1], ..., $index[n]] $op;

($arrayCopy = $array)[$indexCopy1 = $index[1], ..., $indexCopy[n] = $index[n]] = $op($arrayCopy[$indexCopy1, ..., $indexCopy[n]]) -> $op $array[$index[1], ..., $index[n]]

$targetCopy = $target; $temp1 = ($temp2 = $op($targetCopy.$member)) $targetCopy.$member = $temp2; -> $temp1 = $op $target.$member

$targetCopy = $target; $temp = $op($targetCopy.$member) $targetCopy.$member = $temp; -> $op $target.$member

$targetCopy = $target; $temp2 = ($temp1 = ($targetCopy.$member $op $rhs)) $targetCopy.$member = $temp1; -> $temp2 = ($target.$member $op= $rhs)

$targetCopy = $target; $temp = ($targetCopy.$member op $rhs)) $targetCopy.$member = $temp; -> $target.$member op= $rhs

$targetCopy = $target; $temp2 = $op($temp1 = $targetCopy.$member)) $targetCopy.$member = $temp2; -> $temp1 = $target.$member $op

($targetCopy = $target)[$indexCopy1 = $index[1], ..., $indexCopy[n] = $index[n]] = $op($targetCopy[$indexCopy[1], ..., $indexCopy[n]]) -> $op $taret[$index[1], ..., $index[n]]

($targetCopy = $target)[$indexCopy1 = $index[1], ..., $indexCopy[n] = $index[n]] = $targetCopy[$indexCopy1, ..., $indexCopy[n]] $op $rhs -> $target[$index[1], ..., $index[n]] $op= $rhs

($targetCopy = $target)[$indexCopy1 = $index[1], ..., $indexCopy[n] = $index[n]] = $op($temp = $targetCopy[$indexCopy1, ..., $indexCopy[n]]); -> $temp = $target[$index[1], ..., $index[n]] $op;

$lhs = $lhs $op $rhs -> $lhs $op= $rhs

$temp = $argument; $argument = $op($temp); -> $argument++; if there are only 2 usages of $temp or $temp = ($argument++); where $op is either op_Increment or op_Decrement and $argument is one of the following: a parameter; a local variable; a field; a property. a Deref(parameter); an indexer with simple target and local variables as indices;

$argument = $op($argument) -> $op $argument where $op is either op_Increment or op_Decrement and $argument is one of the following: a parameter; a local variable; a field; a property. a Deref(parameter);

$temp = $op($argument); $argument = $temp; -> ++$argument; if there are only 2 usages of $temp or $temp = ++$argument; where $op is either op_Increment or op_Decrement and $argument is one of the following: a parameter; a local variable; a field; a property. a Deref(parameter); an indexer with simple target and local variables as indices;

Conditional or: Block $branch: ... $result = $lhs; If op_True($result) then goto $done else goto $evaluate Block $evaluate: $rhsTemp = $rhs; $result |= $rhsTemp; Control flow behavior: goto $done -> Block $branch: ... $result = $lhs || $rhs; Control flow behavior: goto $done Conditional and: Block $branch: ... $result = $lhs; If op_False($result) then goto $done else goto $evaluate Block $evaluate: $rhsTemp = $rhs; $result &= $rhsTemp; Control flow behavior: goto $done -> Block $branch: ... $result = $lhs && $rhs; Control flow behavior: goto $done $rhsTemp variable can be inlined

Conditional or: Block $branch: ... $local = $lhs; If op_True($local) then goto $thenBlock else goto $elseBlock Block $thenBlock: $result = $local; Control flow behavior: goto $done Block $elseBlock: $result = $local | $rhs; Control flow behavior: goto $done -> Block $branch: ... $result = $lhs || $rhs; Control flow behavior: goto $done Conditional and: Block $branch: ... $local = $lhs; If op_False($local) then goto $thenBlock else goto $elseBlock Block $thenBlock: $result = $local; Control flow behavior: goto $done Block $elseBlock: $result = $local & $rhs; Control flow behavior: goto $done -> Block $branch: ... $result = $lhs && $rhs; Control flow behavior: goto $done

!op_False($1) -> $1 in a context where a boolean-expression is expected (see 7.20). op_False($1) -> $1 ? false : true in all contexts.

op_True($1) -> $1 in a context where a boolean-expression is expected (see 7.20). op_True($1) -> $1 ? true : false in all contexts.

$copy = $disposable; try { $body } finally { [if ($copy != null)] await $copy.DisposeAsync(); } [$copy = ($type) null;] // where $type is IAsyncDisposable or type of $copy variable -> await using (var $copy = $disposable) $body

$copy = $disposable; try { $body } finally { ((IDisposable) __box($copy, $type)).Dispose(); or $copy.Dispose(); // if $copy variable has a ref struct type } -> using (var $copy = $disposable) $body Boxing is optional.

((IDisposable) __box($target, $type)).Dispose();

$target.Dispose(); $target variable has a ref struct type

$copy = $disposable; try { $body } finally { if ($copy != null) ((IDisposable) $copy).Dispose(); } [$copy = ($type) null;] // where $type is IDisposable or type of $copy variable or $temp = $disposable; $copy = $temp; $temp = (IDisposable) null; try { $body } finally { if ($copy != null) ((IDisposable) $copy).Dispose(); } [$copy = ($type) null;] // where $type is IDisposable or type of $copy variable -> using (var $copy = $disposable) $body

Dump control flow graph to dot / gv graph format

https://en.wikipedia.org/wiki/DOT_(graph_description_language) https://graphviz.org/doc/info/lang.html

nullComparison is "argument op null"; if op is == or <= then negation is false; if op is != or > then negation is true

new $delegateType((object) $target, $methodPointer)

new $delegateType((object) $targetVariable, $methodPointerVariable)

Zero-based index of context parameter with type contextParameterType if this parameter is found, or -1 if it is not

true, if one of the context parameters of local function has type contextParameterType

In reverse order: a variable with more inner (specific) scope goes before variable with more outer (general) scope

Finds existing closure context for local function

Checks whether type has a member with name and signature as that of referenceMember

variable = [(type)] null;

variable = [(type)] null;

Requires simplified rational

Find rational approximation to given real number David Eppstein / UC Irvine / 8 Aug 1993. With corrections from Arno Formella, May 2008. Based on the theory of continued fractions. if x = a1 + 1/(a2 + 1/(a3 + 1/(a4 + ...))) then best approximation is found by truncating this series (with some adjustments in the last term). Note the fraction can be recovered as the first column of the matrix ( a1 1 ) ( a2 1 ) ( a3 1 ) ( 1 0 ) ( 1 0 ) ( 1 0 ) Instead of keeping the sequence of continued fraction terms, we just keep the last partial product of these matrices.

Returns standard value type (int, byte, double, decimal, etc.) size in bytes, underlying enum type size in bytes or 0