Emit Warning for Byte String Chars > 127 but < 256

>= 256 (more than 1 byte) are already an error

```fsharp
let _ = "ä"B
//      ^^^^
//      This byte array literal contains 1 non-ASCII characters. All characters should be < 128y.
//      Note: In future F# versions this Warning might be promoted to Error!
```

Note: Issue with trigraph and > 255:
```fsharp
let _ = "\973"B
//       ^^^^
//       Warning: '\973' is not a valid character literal.
//                Note: Currently the value is wrapped around byte range to '\169' [...]
//
//      ^^^^^^^
//      Warning: This byte array literal contains 1 non-ASCII characters.
```
->
Two warnings for same trigraph:
* Warning for trigraph `\973` > 255. Detected while parsing trigraph. Don't know yet if String or Byte String.
  * warning spans just trigraph
* Warning for wrapped value `\169` > 127. Detected while checking Byte String for correct values. Don't have any infos about value (range & notation) any more.
  * warning spans full byte string

-> Each Warning is emitted in a different parsing steps.
-> No easy way to reduce to just one warning.

However: Both warnings are correct and warn about a different issues (albeit in same value)

And: should get automatically reduced once out-of-trigraph-range gets promoted to error

**Enhancement**: Count number of invalid chars (2-bytes, >128) in byte array

```fsharp
let _ = "ΩäΩüΩ"B
```
* prev:
  `This byte array literal contains characters that do not encode as a single byte`
* now:
  `This byte array literal contains 3 characters that do not encode as a single byte`
  &&
  `This byte array literal contains 2 non-ASCII characters. All characters should be < 128y.`

Note: When checking valid bytes in Byte String, there's no direct mapping to range and notation any more.
  -> cannot highlight exact byte string part, but only full byte string.
* Possible Enhancement?: List invalid chars in a certain notation? For example in `\u` notation.
  * Pro:
    * Gives an idea which chars are incorrect
  * Con:
    * Might be difficult to process by user because output might be different notation than written in string
    * Might be a long list with invalid chars

Author: Booksbaum

src/Compiler/FSComp.txt

@@ -1019,7 +1019,7 @@ lexfltSeparatorTokensOfPatternMatchMisaligned,"The '|' tokens separating rules o
 # -----------------------------------------------------------------------------
 lexCharNotAllowedInOperatorNames,"'%s' is not permitted as a character in operator names and is reserved for future use"
 lexUnexpectedChar,"Unexpected character '%s'"
-1140,lexByteArrayCannotEncode,"This byte array literal contains characters that do not encode as a single byte"
+1140,lexByteArrayCannotEncode,"This byte array literal contains %d characters that do not encode as a single byte"
 1141,lexIdentEndInMarkReserved,"Identifiers followed by '%s' are reserved for future use"
 1142,lexOutsideEightBitSigned,"This number is outside the allowable range for 8-bit signed integers"
 1143,lexOutsideEightBitSignedHex,"This number is outside the allowable range for hexadecimal 8-bit signed integers"
@@ -1132,6 +1132,7 @@ lexIfOCaml,"IF-FSHARP/IF-CAML regions are no longer supported"
 1250,lexTooManyPercentsInTripleQuote,"The interpolated triple quoted string literal does not start with enough '$' characters to allow this many consecutive '%%' characters."
 1251,lexExtendedStringInterpolationNotSupported,"Extended string interpolation is not supported in this version of F#."
 1252,lexInvalidCharLiteralInString,"'%s' is not a valid character literal.\nNote: Currently the value is wrapped around byte range to '%s'. In a future F# version this Warning will be promoted to Error!"
+1253,lexByteArrayOutisdeAscii,"This byte array literal contains %d non-ASCII characters. All characters should be < 128y."
 # reshapedmsbuild.fs
 1300,toolLocationHelperUnsupportedFrameworkVersion,"The specified .NET Framework version '%s' is not supported. Please specify a value from the enumeration Microsoft.Build.Utilities.TargetDotNetFrameworkVersion."
 # -----------------------------------------------------------------------------

src/Compiler/SyntaxTree/LexHelpers.fs

@@ -222,16 +222,31 @@ let addUnicodeChar buf c = addIntChar buf (int c)
 
 let addByteChar buf (c: char) = addIntChar buf (int32 c % 256)
 
+type LargerThanOneByte = int
+type LargerThan127ButInsideByte = int
 /// Sanity check that high bytes are zeros. Further check each low byte <= 127
-let stringBufferIsBytes (buf: ByteBuffer) =
+let errorsInByteStringBuffer (buf: ByteBuffer) =
     let bytes = buf.AsMemory()
-    let mutable ok = true
+    assert(bytes.Length % 2 = 0)
+    
+    // Enhancement?: return faulty values?
+    //     But issue: we don't know range of values -> no direct mapping from value to range & notation
+    
+    // values with high byte <> 0
+    let mutable largerThanOneByteCount = 0
+    // values with high byte = 0, but low byte > 127
+    let mutable largerThan127ButSingleByteCount = 0
 
     for i = 0 to bytes.Length / 2 - 1 do
         if bytes.Span[i * 2 + 1] <> 0uy then
-            ok <- false
+            largerThanOneByteCount <- largerThanOneByteCount + 1
+        elif bytes.Span[i * 2] > 127uy then
+            largerThan127ButSingleByteCount <- largerThan127ButSingleByteCount + 1
 
-    ok
+    if largerThanOneByteCount + largerThan127ButSingleByteCount > 0 then
+        Some (largerThanOneByteCount, largerThan127ButSingleByteCount)
+    else
+        None
 
 let newline (lexbuf: LexBuffer<_>) = lexbuf.EndPos <- lexbuf.EndPos.NextLine
 

src/Compiler/SyntaxTree/LexHelpers.fsi

@@ -97,7 +97,9 @@ val stringBufferAsString: ByteBuffer -> string
 
 val stringBufferAsBytes: ByteBuffer -> byte[]
 
-val stringBufferIsBytes: ByteBuffer -> bool
+type LargerThanOneByte = int
+type LargerThan127ButInsideByte = int
+val errorsInByteStringBuffer: ByteBuffer -> Option<LargerThanOneByte * LargerThan127ButInsideByte>
 
 val newline: Lexing.LexBuffer<'a> -> unit
 

src/Compiler/lex.fsl

@@ -133,10 +133,14 @@ let startString args (lexbuf: UnicodeLexing.Lexbuf) =
                 if kind.IsInterpolated then
                     fail args lexbuf (FSComp.SR.lexByteStringMayNotBeInterpolated()) ()
                     BYTEARRAY (Lexhelp.stringBufferAsBytes buf, synByteStringKind, cont)
-                elif Lexhelp.stringBufferIsBytes buf then
-                    BYTEARRAY (Lexhelp.stringBufferAsBytes buf, synByteStringKind, cont)
                 else
-                    fail args lexbuf (FSComp.SR.lexByteArrayCannotEncode()) ()
+                    match Lexhelp.errorsInByteStringBuffer buf with
+                    | Some (largerThanOneByte, largerThan127) ->
+                        if largerThanOneByte > 0 then
+                            fail args lexbuf (FSComp.SR.lexByteArrayCannotEncode(largerThanOneByte)) ()
+                        if largerThan127 > 0 then
+                            warning (Error(FSComp.SR.lexByteArrayOutisdeAscii(largerThan127), lexbuf.LexemeRange))
+                    | None -> ()
                     BYTEARRAY (Lexhelp.stringBufferAsBytes buf, synByteStringKind, cont)
             elif kind.IsInterpolated then
                 let s = Lexhelp.stringBufferAsString buf