cil | DVCS backed issue tracking system

This is specified in Section II.12.2 of ECMA-335.

Relevant snippets of the spec follows:

Where there are multiple implementations for a given interface method due to differences in type parameters, the declaration order of the interfaces on the class determines which method is invoked.
...
The inheritance/implements tree for a type T is the n-ary tree formed as follows:

• The root of the tree is T
  ...
• If T has one or more explicit interfaces, I_x, then the inheritance/implements tree for each I_x is a child of the root node, in order.

The type declaration order of the interfaces and super classes of a type T is the postorder depth-first traversal of the inheritance/implements tree of type T with any second and subsequent duplicates of any type omitted. Occurrences of the same interface with different type parameters are not considered duplicates

So we've defined the type declaration order as the order in which these interfaces appear in the class declaration.

When an interface method is invoked, the VES shall use the following algorithm to determine the appropriate method to call:

• Beginning with the runtime class of the instance through which the interface method is invoked, using its interface table as constructed above, and substituting generic arguments, if any, specified on the invoking class:
  1. For each method in the list associated with the interface method, if there exists a method whose generic type arguments match exactly for this instantiation (or there are no generic type parameters), then call the first method
  2. Otherwise, if there exists a method in the list whose generic type parameters have the correct variance relationship, then call the first such method in the list

This is saying that if there's no exact match, then take the first method in the type declaration order whose type parameters have the correct variance relationship.

Your example appears as Case 6 in the section "II.12.2.1 Interface Implementation Examples", where the type S4 implements both IVarImpl (which means implementing IVar) and IVar, and the example shows that calling the method IVar::P(C) on an instance of S4 results in the method S1::P(!0:A) (that is, void P(A)) being called.

Try:

Thanks to Kirk Woll's tip, I was able to spot my error.

OpCodes.Stsfld not OpCodes.Stfld.

(facepalm)

Since you are new to Vue.js I recommend you reading about props-down and events-up pattern which describes flow of data between Vue components.

1. Props-down part is describing data flow PARENT -> CHILD, meaning child components should receive data from parent components via props.
2. Events-up part is describing data flow CHILD -> PARENT, meaning child components should send data to parent components by emitting events.

To get back to your concrete situation, you need to emit an event from Datatable.vue component which you will handle in Main.vue:

In your Datatable.vue you should add this:

Make the pdb "pdbonly" to "portable" in Visual Studio.

As mentioned in issue https://github.com/dotnet/runtime/issues/11354, it is not currently possible to use function pointers in reflection stack (typeof(delegate* ...) always returns IntPtr currently), so there is no way to make Reflection.Emit work reliably in this case.

Looks like code reuse artifact. Roslyn probably uses same code to handle local functions and lambdas, but injects method definitions in different classes.

In case of lambda it injects lambda body to generated closure (DisplayClass) class and it should be internal to be referenced from calling function.

The MasterModel class should implement the INotifyPropertyChanged event and raise the PropertyChanged event for the data-bound property when you call SetName:

The short version is that the intermediate representation of double/float in the CLI is intentionally unspecified. As such the compiler will always emit an explicit cast from double to double (or float to float) in case it would change the meaning of an expression.

It doesn't change the meaning in this case, but the compiler doesn't know that. (The JIT does though and will optimize it away.)

If you want all the gnitty gritty background details...

The ECMA-335 references below specifically come from the version with Microsoft-Specific implementation notes, which can be downloaded from here. (Note that since we're talking about IL I will be speaking from the perspective of the .NET Runtime's virtual machine, not from any particular processor architecture.)

The justification for why Roslyn emits this seemingly unnecessary instruction can be found in CodeGenerator.EmitIdentityConversion:

An explicit identity conversion from double to double or float to float on non-constants must stay as a conversion. An implicit identity conversion can be optimized away. Why? Because (double)d1 + d2 has different semantics than d1 + d2. The former rounds off to 64 bit precision; the latter is permitted to use higher precision math if d1 is enregistered.

(Emphasis and formatting mine.)

The important thing to note here is the "permitted to use higher precision math". To understand why this is we need to understand how the runtime represents different types at a low level. The virtual machine used by the .NET Runtime is stack-based, all intermediate values go onto what is called the evaluation stack. (Not to be confused with the processor's call stack, which may or may not be used for things on the evaluation stack at runtime.)

Partition I §12.3.2.1 The Evaluation Stack (pg 88) describes the evaluation stack, and lists what can be represented on the stack:

While the CLI, in general, supports the full set of types described in §12.1, the CLI treats the evaluation stack in a special way. While some JIT compilers might track the types on the stack in more detail, the CLI only requires that values be one of:

• int64, an 8-byte signed integer
• int32, a 4-byte signed integer
• native int, a signed integer of either 4 or 8 bytes, whichever is more convenient for the target architecture
• F, a floating point value (float32, float64, or other representation supported by the underlying hardware)
• &, a managed pointer
• O, an object reference
• *, a “transient pointer,” which can be used only within the body of a single method, that points to a value known to be in unmanaged memory (see the CIL Instruction Set specification for more details. * types are generated internally within the CLI; they are not created by the user).
• A user-defined value type

Of note is the only floating point type being the F type, which you'll notice is intentionally vague and does not represent a specific precision. (This is done to provide flexibility for runtime implementations since they have to run on many different processors, which may or may not prefer a specific level of precision for floating point operations.)

If we dig around a little further, this is also mentioned in Partition I §12.1.3 Handling of floating-point data types (pg 79):

Storage locations for floating-point numbers (statics, array elements, and fields of classes) are of fixed size. The supported storage sizes are float32 and float64. Everywhere else (on the evaluation stack, as arguments, as return types, and as local variables) floating-point numbers are represented using an internal floating-point type.

For the final piece of the puzzle, we need to understand the exact definition of conv.r8, which is defined in Partiion III §3.27 conv. - data conversion (pg 68):

conv.r8: Convert to float64, pushing F on stack.

and finally, the specifics of converting F to F are defined in Partition III §1.5 Table 8: Conversion Operations (pg 20): (Paraphrased)

If input (from the evaluation stack) is F and convert-to is "All float types": Change precision³

³Converts from the current precision available on the evaluation stack to the precision specified by the instruction. If the stack has more precision than the output size the conversion is performed using the IEC 60559:1989 “round-to-nearest” mode to compute the low order bit of the result.

So in this context you should read conv.r8 as "Convert from unspecified floating-point format to double" rather than "Convert from double to double". (Although in this case, we can be pretty sure that F on the evaluation stack is already double precision since it's from a double argument.)

So in summary:

• The .NET Runtime has a float64 type, but only for storage purposes.
• For evaluation purposes (and passing arguments), a precision-unspecified F type is must be used instead.
• This means that sometimes an "unnecessary" explicit cast to double is actually changing the precision of an expression.
• The C# compiler doesn't know whether or not it will matter so it always emits the conversion from F to float64. (However the JIT does, and in this case will optimize away the cast at runtime.)