Do not lex .. as a single DotDotToken

src/Compilers/CSharp/Portable/Parser/Blender.Reader.cs

@@ -6,10 +6,7 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax
 {
@@ -307,6 +304,7 @@ internal static bool IsFabricatedToken(SyntaxKind kind)
                     case SyntaxKind.GreaterThanGreaterThanEqualsToken:
                     case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
                     case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
+                    case SyntaxKind.DotDotToken:
                         return true;
                     default:
                         return SyntaxFacts.IsContextualKeyword(kind);

src/Compilers/CSharp/Portable/Parser/Blender.cs

@@ -8,10 +8,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax
 {

src/Compilers/CSharp/Portable/Parser/LanguageParser_Patterns.cs

@@ -193,9 +193,12 @@ private PatternSyntax ParsePrimaryPattern(Precedence precedence, bool afterIs, b
             {
                 case SyntaxKind.OpenBracketToken:
                     return this.ParseListPattern(inSwitchArmPattern);
-                case SyntaxKind.DotDotToken:
-                    return _syntaxFactory.SlicePattern(EatToken(),
-                        IsPossibleSubpatternElement() ? ParsePattern(precedence, afterIs: false, inSwitchArmPattern) : null);
+                case SyntaxKind.DotToken when IsAtDotDotToken():
+                    return _syntaxFactory.SlicePattern(
+                        EatDotDotToken(),
+                        IsPossibleSubpatternElement()
+                            ? ParsePattern(precedence, afterIs: false, inSwitchArmPattern)
+                            : null);
                 case SyntaxKind.LessThanToken:
                 case SyntaxKind.LessThanEqualsToken:
                 case SyntaxKind.GreaterThanToken:

src/Compilers/CSharp/Portable/Parser/Lexer.cs

@@ -68,7 +68,7 @@ internal enum XmlDocCommentStyle
         Delimited = 1
     }
 
-    internal partial class Lexer : AbstractLexer
+    internal sealed partial class Lexer : AbstractLexer
     {
         private const int TriviaListInitialCapacity = 8;
 
@@ -459,26 +459,41 @@ private void ScanSyntaxToken(ref TokenInfo info)
                     break;
 
                 case '.':
-                    if (!this.ScanNumericLiteral(ref info))
+                    if (this.TextWindow.PeekChar(1) is >= '0' and <= '9')
                     {
-                        TextWindow.AdvanceChar();
-                        if (TextWindow.TryAdvance('.'))
+                        var atDotPosition = this.TextWindow.Position;
+                        if (atDotPosition >= 1 &&
+                            atDotPosition == this.TextWindow.LexemeStartPosition)
                         {
-                            if (TextWindow.PeekChar() == '.')
+                            // We have something like: .0
+                            //
+                            // This could be a fp number *except* the case where we have `..0` in that case, we want two
+                            // dots followed by an integer (which will be treated as a range expression).
+                            //
+                            // Move back one space to see what's before this dot and adjust accordingly.
+
+                            this.TextWindow.Reset(atDotPosition - 1);
+                            var priorCharacterIsDot = this.TextWindow.PeekChar() is '.';
+                            this.TextWindow.Reset(atDotPosition);
+
+                            if (priorCharacterIsDot)
                             {
-                                // Triple-dot: explicitly reject this, to allow triple-dot
-                                // to be added to the language without a breaking change.
-                                // (without this, 0...2 would parse as (0)..(.2), i.e. a range from 0 to 0.2)
-                                this.AddError(ErrorCode.ERR_TripleDotNotAllowed);
+                                // We have two dots in a row.  Treat the second dot as a dot, not the start of a number literal.
+                                TextWindow.AdvanceChar();
+                                info.Kind = SyntaxKind.DotToken;
+                                break;
                             }
 
-                            info.Kind = SyntaxKind.DotDotToken;
-                        }
-                        else
-                        {
-                            info.Kind = SyntaxKind.DotToken;
+                            // Fall through naturally and scan the number out as a floating point number.
                         }
                     }
+
+                    if (!this.ScanNumericLiteral(ref info))
+                    {
+                        TextWindow.AdvanceChar();
+                        info.Kind = SyntaxKind.DotToken;
+                    }
+
                     break;
 
                 case ',':

src/Compilers/CSharp/Portable/Parser/QuickScanner.cs

@@ -4,9 +4,6 @@
 
 using System;
 using System.Diagnostics;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Syntax.InternalSyntax
@@ -152,7 +149,7 @@ private enum CharFlags : byte
                 (byte)QuickScanState.FollowingCR,         // CR
                 (byte)QuickScanState.DoneAfterNext,       // LF
                 (byte)QuickScanState.Done,                // Letter
-                (byte)QuickScanState.Number,              // Digit
+                (byte)QuickScanState.Bad,                 // Dot followed by number.  Could be a fp `.0` or could be a range + num `..0`.  Can't tell here.
                 (byte)QuickScanState.Done,                // Punct
                 (byte)QuickScanState.Bad,                 // Dot (DotDot range token, exit so that we handle it in subsequent scanning code)
                 (byte)QuickScanState.Done,                // Compound

src/Compilers/CSharp/Portable/Parser/SyntaxParser.cs

@@ -317,7 +317,7 @@ protected SyntaxToken CurrentToken
         {
             get
             {
-                return _currentToken ?? (_currentToken = this.FetchCurrentToken());
+                return _currentToken ??= this.FetchCurrentToken();
             }
         }