Compiler resolves to wrong overloaded constructor or method

[Philippe Bertrand]

Is this a bug in the C# compiler or CLR runtime?

enum MyEnum { ZERO = 0, ONE = 1, TWO = 2 }
class Foo {
public Foo(string,obje ct) { ... }
public Foo(string,MyEn um) { ... }
}

Foo f = new Foo("", 0); // Uses Foo(string,MyEn um) constructor instead of
Foo(string,obje ct)
Foo f = new Foo("", 0.0); // Uses Foo(string,MyEn um) constructor instead
of Foo(string,obje ct)
Foo f = new Foo("", (int)0); // Uses Foo(string,MyEn um) constructor
instead of Foo(string,obje ct)
BUT
Foo f = new Foo("", 1 ); // Uses Foo(string,obje ct)
Foo f = new Foo("", (object)(int)0 ); // Uses Foo(string,obje ct) with
object type Int32
Foo f = new Foo("", (double)0.0 ); // Uses Foo(string,obje ct)

Actual case was from a ADO.NET Data Provider's PrvParameter constructors!
Same issue came up resolving the various overloads of
PrvParameterCol lection.Add!

Anybody else seen this?
Philippe

[Bob Grommes]

Philippe,

Haven't seen it.

How do you know it's using the Foo(string,MyEn um) constructor when you do a
new Foo("",0)? Are you seeing this when you single-step through the code?
If not, you should single-step with the debugger to make sure what you think
is executing is really executing. If you single-step and *still* see this
behavior, then I would rule out a bug in the debug display (it's happened in
the past, in unpatched CLR 1.0) by putting DebugWriteLine( ) statements into
the constructors and making sure they really DO execute as the debugger
shows.

--Bob

"Philippe Bertrand" <my*****@ianywh ere.com> wrote in message
news:10******** *****@corp.supe rnews.com...

Is this a bug in the C# compiler or CLR runtime?

enum MyEnum { ZERO = 0, ONE = 1, TWO = 2 }
class Foo {
public Foo(string,obje ct) { ... }
public Foo(string,MyEn um) { ... }
}

Foo f = new Foo("", 0); // Uses Foo(string,MyEn um) constructor instead of Foo(string,obje ct)
Foo f = new Foo("", 0.0); // Uses Foo(string,MyEn um) constructor instead of Foo(string,obje ct)
Foo f = new Foo("", (int)0); // Uses Foo(string,MyEn um) constructor
instead of Foo(string,obje ct)
BUT
Foo f = new Foo("", 1 ); // Uses Foo(string,obje ct)
Foo f = new Foo("", (object)(int)0 ); // Uses Foo(string,obje ct) with
object type Int32
Foo f = new Foo("", (double)0.0 ); // Uses Foo(string,obje ct)

Actual case was from a ADO.NET Data Provider's PrvParameter constructors!
Same issue came up resolving the various overloads of
PrvParameterCol lection.Add!

Anybody else seen this?
Philippe

[Mike Schilling]

"Philippe Bertrand" <my*****@ianywh ere.com> wrote in message
news:10******** *****@corp.supe rnews.com...

Is this a bug in the C# compiler or CLR runtime?

enum MyEnum { ZERO = 0, ONE = 1, TWO = 2 }
class Foo {
public Foo(string,obje ct) { ... }
public Foo(string,MyEn um) { ... }
}

Foo f = new Foo("", 0); // Uses Foo(string,MyEn um) constructor instead of Foo(string,obje ct)
Foo f = new Foo("", 0.0); // Uses Foo(string,MyEn um) constructor instead of Foo(string,obje ct)
Foo f = new Foo("", (int)0); // Uses Foo(string,MyEn um) constructor
instead of Foo(string,obje ct)
BUT
Foo f = new Foo("", 1 ); // Uses Foo(string,obje ct)
Foo f = new Foo("", (object)(int)0 ); // Uses Foo(string,obje ct) with
object type Int32
Foo f = new Foo("", (double)0.0 ); // Uses Foo(string,obje ct)

I reproduced it. Very odd, especially the difference in behavior between
0.0 and (double)0.0, since 0.0 is already a double.

[Robert Jordan]

hi philippe,

see 7.4.2.2 of the C# language specification.

Foo f = new Foo("", 0); // Uses Foo(string,MyEn um) constructor instead of
Foo(string,obje ct)
there exists an implicit convertion between int and MyEnum.
see 6.1.3 of the C# lang specification.
Foo f = new Foo("", 0.0); // Uses Foo(string,MyEn um) constructor instead
of Foo(string,obje ct)
there exists an implicit convertion between double and int
and MyEnum. see 6.1.3.
Foo f = new Foo("", (int)0); // Uses Foo(string,MyEn um) constructor
instead of Foo(string,obje ct)
there exists an implicit convertion between int and MyEnum.
see 6.1.3.
BUT
Foo f = new Foo("", 1 ); // Uses Foo(string,obje ct)
6.1.3 doesn't apply here.
Foo f = new Foo("", (object)(int)0 ); // Uses Foo(string,obje ct) with
object type Int32
the cast forces Foo(string,obje ct).
Foo f = new Foo("", (double)0.0 ); // Uses Foo(string,obje ct)

the cast disables the implicit int promotion.
since no Foo(string,doub le) exists, the next bext
overloaded method is taken.

bye
rob

[Alex Sedow]

Robert,

Can you give correct links to C# spec? (I mean ECMA-334, 2nd ed. (december
2002)).

Alex.

see 7.4.2.2 of the C# language specification.

there exists an implicit convertion between int and MyEnum.
see 6.1.3 of the C# lang specification.

[Philippe Bertrand]

But that is ridiculous!

You are saying to users that for all but these two special constants, the
language behaves on way but for these two magic constants you have to
explicitly cast.

Being in the spec doesn't make it a good idea!

"Robert Jordan" <ro*****@gmx.ne t> wrote in message
news:cg******** *****@news.t-online.com...

hi philippe,

see 7.4.2.2 of the C# language specification.

Foo f = new Foo("", 0); // Uses Foo(string,MyEn um) constructor instead of Foo(string,obje ct)
there exists an implicit convertion between int and MyEnum.
see 6.1.3 of the C# lang specification.

Foo f = new Foo("", 0.0); // Uses Foo(string,MyEn um) constructor instead of Foo(string,obje ct)

there exists an implicit convertion between double and int
and MyEnum. see 6.1.3.

Foo f = new Foo("", (int)0); // Uses Foo(string,MyEn um) constructor
instead of Foo(string,obje ct)

there exists an implicit convertion between int and MyEnum.
see 6.1.3.

BUT
Foo f = new Foo("", 1 ); // Uses Foo(string,obje ct)

6.1.3 doesn't apply here.

Why would there be an implicit conversion between int and MyEnum for the
value 0 but not the value 1?

Note:
int i = 0;
Foo f = new Foo("", i ); // Uses Foo(stirng,obje ct)

This section 6.1.3 seems an extremely bizzard exception!

Foo f = new Foo("", (object)(int)0 ); // Uses Foo(string,obje ct) with
object type Int32

the cast forces Foo(string,obje ct).

Foo f = new Foo("", (double)0.0 ); // Uses Foo(string,obje ct)

the cast disables the implicit int promotion.
since no Foo(string,doub le) exists, the next bext
overloaded method is taken.

Why would the implicit conversion be disabled when casting (double)0.0 but
not when casting (int)0 ?

Philippe

[Philippe Bertrand]

Yes, I'm certain (resulting object state different and stepped through
code). See my reply to Robert Jordan for cause of this magic behaviour.

Philippe

[Robert Jordan]

Hi Alex,

Robert,

Can you give correct links to C# spec? (I mean ECMA-334, 2nd ed. (december
2002)).

13.1.3 Implicit enumeration conversions
(6.1.3 MSDN spec)

"An implicit enumeration conversion permits the decimal-integer-literal
0 to be converted to any enum-type"
14.4.2.1 Applicable function member
(7.4.2.2 MSDN spec)

Rob

[Alex Sedow]

Thank you!

Alex.

[Robert Jordan]

Hi Philippe,

You are saying to users that for all but these two special constants, the
language behaves on way but for these two magic constants you have to
explicitly cast.
There is no magic. The language designers wanted to avoid
constructs like "(SomeEnum) 0", because enums may be
[Flags]-able, and thus they may be "0" w/out having
a literal with the value "0".

Consider this:

if ((val & SomeEnum.Foo) == 0) {
}

W/out this rule, the bool expression has to
be written like:

if ((val & SomeEnum.Foo) == (SomeEnum)0) {
}

This is ugly!

Being in the spec doesn't make it a good idea!

Reading the specs is a good idea, too ;-)

Bye
Rob