Provides checks for the consistency of the data model and database.
An access that does not have exactly one target.
An array with an invalid
An array with an invalid
A branch without a target.
A catch handler that doesn’t have a caught exception type.
A consistency violation on a control flow node.
A consistency violation in the database or data model.
A constructed method that does not match its unbound method.
A dead instruction, not reachable from any entry point. These should not exist, however it turns out that the Mono compiler sometimes emits them.
An instruction that is not reachable from any entry point.
A violation in a
A declaration with multiple labels.
A declaration without a label.
A check that is deliberately disabled.
An expression that does not have exactly one type. Note that calls with no return have type
An expression that have an unexpected push count.
An instruction whose false successor is not a successor.
The type of a kind must be consistent between a constructed generic and its unbound generic.
The location of a constructed method should be equal to the location of its unbound generic.
A CFG node that does not have exactly 1
A CFG node that does not have exactly one
The location of a constructed generic type should be the same as the location of its unbound generic type.
A consistency violation in a specific instruction.
A branch instruction that does not have exactly 2 successors.
An instruction that has a push count of 0, yet is still used as an operand
An override that is invalid because the overridden method is not in a base class.
A pointer type that does not have a pointee type.
A return instruction that does not have a stack size of 0 after it.
A CFG node that does not have exactly one stack size. Disabled because inconsistent stack sizes have been observed.
A throw instruction that does not have a stack size of 0 after it.
A type should have at most one kind, except for missing referenced types where the interface/class is unknown.
A member with an invalid name.
A consistency violation in a method.
A call that does not have exactly one
A C# declaration which is expected to have a corresponding CIL declaration, but for some reason does not.
A violation marking an entity that should be present but is not.
An instruction that has not been assigned a specific QL class.
An instruction that is missing an operand. It means that there is no instruction which pushes a value onto the stack for this instruction to pop.
A CFG node that does not have a stack size.
A literal that does not have exactly one
A branch instruction that does not have a false successor.
A branch instruction that does not have a true successor.
An instruction that has a true/false successor but is not a branch.
Properties that have no accessors.
A field access where the field is “static” but the instruction is “instance”.
An instruction whose true successor is not a successor.
A type that has both type arguments and type parameters.
A type that has multiple entities with the same qualified name in
A constructed type that does not match its unbound generic type.
A consistency violation in a type.
An unconditional branch instruction that has more than one successor.