ILSpy

9708 Commits

54 Branches

94 Tags

91 MiB

Tree: ad08d21884

Commit Graph

Author	SHA1	Message	Date
Christoph Wille	fe9f6db3ee	Emit C# 7.1 default literals where the context supplies the type Shortening default(T) is the same problem as removing the redundant cast around a lambda whose delegate type the context already fixes, so it uses the same mechanism: ConvertTo makes the explicit type implicit when the conversion is an identity conversion and the caller allows an implicit one. The literal keeps the type it was shortened from, so any later conversion to a different type - or any context that requires an explicit type, such as an overload resolution recheck falling back to CastArguments - can spell default(T) out again. That keeps the value intact where the bare literal would change it, e.g. "object o = default(SomeStruct)", which boxes a non-null struct while "default" would be null. Because the shortened literal resolves to DefaultLiteralResolveResult, CallBuilder's existing overload resolution recheck sees a real default literal and rejects ambiguous calls on its own; no separate bookkeeping about which arguments may stay untyped is needed. Only the contexts that supply no target type at all restore the explicit form: an awaited expression, and arguments of operator methods, which later become operator or cast syntax rather than calls. Assisted-by: Claude:claude-opus-5[1m]:Claude Code	4 weeks ago
Siegfried Pammer	d7bbf17e2e	Add pretty test for C# 13 ref struct interfaces / allows ref struct Covers ref structs implementing interfaces (implicit, explicit, and default-interface-method reimplementation, which CS9245 forces on every ref struct implementer), the allows ref struct anti-constraint on methods, classes, interfaces, delegates, local functions, iterators, async methods, and capturing local functions, constraint combinations (interface, IDisposable with using, unmanaged, struct, new()), interface members invoked through a constrained T (instance, static abstract factory, and default interface methods, which are callable through T because implementers must always override them), scoped/ref/ in/out parameters of T, and call sites instantiating with Span/ ReadOnlySpan type arguments. The test is green in all four Roslyn 4.14/latest debug/opt configs: the decompiler already round-trips the gpAcceptByRefLike flag into "allows ref struct" clauses and re-emits ref struct interface implementations correctly. One cosmetic quirk is pinned as-is: calls whose type arguments are ref structs are printed with explicit type arguments and a declaring-type qualifier even within the declaring class, because type-argument inference validation does not accept ref struct type arguments; the output remains compilable and semantically identical. Assisted-by: Claude:claude-fable-5:Claude Code	2 months ago

Author

SHA1

Message

Date

Christoph Wille

fe9f6db3ee

Emit C# 7.1 default literals where the context supplies the type

Shortening default(T) is the same problem as removing the redundant cast
around a lambda whose delegate type the context already fixes, so it uses
the same mechanism: ConvertTo makes the explicit type implicit when the
conversion is an identity conversion and the caller allows an implicit
one. The literal keeps the type it was shortened from, so any later
conversion to a different type - or any context that requires an explicit
type, such as an overload resolution recheck falling back to CastArguments
- can spell default(T) out again. That keeps the value intact where the
bare literal would change it, e.g. "object o = default(SomeStruct)", which
boxes a non-null struct while "default" would be null.

Because the shortened literal resolves to DefaultLiteralResolveResult,
CallBuilder's existing overload resolution recheck sees a real default
literal and rejects ambiguous calls on its own; no separate bookkeeping
about which arguments may stay untyped is needed. Only the contexts that
supply no target type at all restore the explicit form: an awaited
expression, and arguments of operator methods, which later become operator
or cast syntax rather than calls.

Assisted-by: Claude:claude-opus-5[1m]:Claude Code

4 weeks ago

Siegfried Pammer

d7bbf17e2e

Add pretty test for C# 13 ref struct interfaces / allows ref struct

Covers ref structs implementing interfaces (implicit, explicit, and
default-interface-method reimplementation, which CS9245 forces on every
ref struct implementer), the allows ref struct anti-constraint on
methods, classes, interfaces, delegates, local functions, iterators,
async methods, and capturing local functions, constraint combinations
(interface, IDisposable with using, unmanaged, struct, new()),
interface members invoked through a constrained T (instance, static
abstract factory, and default interface methods, which are callable
through T because implementers must always override them), scoped/ref/
in/out parameters of T, and call sites instantiating with Span/
ReadOnlySpan type arguments.

The test is green in all four Roslyn 4.14/latest debug/opt configs: the
decompiler already round-trips the gpAcceptByRefLike flag into
"allows ref struct" clauses and re-emits ref struct interface
implementations correctly. One cosmetic quirk is pinned as-is: calls
whose type arguments are ref structs are printed with explicit type
arguments and a declaring-type qualifier even within the declaring
class, because type-argument inference validation does not accept ref
struct type arguments; the output remains compilable and semantically
identical.

Assisted-by: Claude:claude-fable-5:Claude Code

2 months ago

2 Commits (ad08d21884fc080b6580b2acbe088ee688d21cbd)