Error in scanning "1.0e-99999999999999999999999"; should convert to zero

[gafter]

The literal 1.0e-99999999999999999999999 should scan as the value 0.0, but it acts as if it is an overflow (compile-time error).

[leppie]

The following seems to be able to fix it:

try
{
  int exponentMagnitude = int.Parse(source.Substring(firstExponent, lastExponent - firstExponent));
  if (exponentSign == '-')
  {
    exponent -= exponentMagnitude;
  }
  else
  {
    exponent += exponentMagnitude;
  }
}
catch (OverflowException)
{
  exponent = exponentSign == '-' ? int.MinValue : int.MaxValue;
}

Not to keen on exceptional code though.

Update: Why not, let's make a PR :D

[gafter]

@leppie what happens if your exponent adjustment overflows? Can we use TryParse to avoid the exceptional code?

[leppie]

@gafter: I assign, I dont modify :) It is working correctly for me in IronScheme.

TryParse will give you no indication if the exponent is a valid integer but too big or small. Again, for me in IronScheme, this is not a problem, but I dont know how the C# lexer works. Given the above referenced issue, it does not sound very strict :D

[gafter]

@leppie Given that the substring that would be passed to TryParse does not contain a sign, any failure indicates an overflow (not underflow).

I'm worried about your code

exponent += exponentMagnitude

This could "overflow" and "wrap around", turning what should come out as an infinity into a zero.

[leppie]

That is the original code. https://github.com/dotnet/roslyn/blob/master/src/Compilers/Core/Portable/RealParser.cs#L368

But I see what you mean though, another issue really.

Seeing these are exceptional cases, I feel exceptions should be OK. Wrapping that in checked should do the trick.

I'll submit a PR for both issues soon.

[leppie]

Updated:

try
{
  int exponentMagnitude = int.Parse(source.Substring(firstExponent, lastExponent - firstExponent));
  checked
  {
    if (exponentSign == '-')
    {
      exponent -= exponentMagnitude;
    }
    else
    {
      exponent += exponentMagnitude;
    }
  }
}
catch (OverflowException)
{
  exponent = exponentSign == '-' ? int.MinValue : int.MaxValue;
}

This is still not 100% correct, but one would have to have more than a 2 billion digit number before the separator. Will probably run into more problems before that could be hit :)

[leppie]

I am not sure I agree with CS0594: Floating-point constant is outside the range of type 'double'. This should be a warning at best.

Tested with 1.0e99999999999999999999999

My PR does not cater for this limitation.

[gafter]

@leppie An exception is not OK. These are not exceptional cases. As a rule, handling all kinds of correct and incorrect source code is the job of a compiler in the normal case. It is a normal use of a compiler to feed it an incorrect program and expect it to give appropriate diagnostics.

The C# language specification requires an error (not a warning) here:

If the magnitude of the specified literal is too large to be represented in the indicated type, a compile-time error occurs. [Note: In particular, a real-literal will never produce a floating-point infinity. A non-zero real-literal may, however, be rounded to zero. end note]

[leppie]

On the old compiler: 1.0e-99999999999999999999999 does however error too. Should the behavior be the same? If so, I'll just pull the PR, I dont know enough of the surrounds to cater for that.

But you use an exception for the same @

roslyn/src/Compilers/Core/Portable/RealParser.cs

Line 41 in 6cf046f

catch (System.FormatException)

😕