ionide / ionide-fsgrammar Goto Github PK

Preview

Code

    let tuple2 (decoder1: Decoder<'T1>) (decoder2: Decoder<'T2>) : Decoder<'T1 * 'T2> =

Syntax Colorization Failure

let update _msg model =
  model

msg is colorized but not the underscore.

System Details

• osX
• VSCode
• current extensionversion

Moved from ionide/ionide-vscode-fsharp#640

by @vasily-kirichenko

Code

VS

type X(x: int, y: int) = class end
type Y private (x: int, y: int) = class end

(On latest stable VS Code with latest version of ionide-fsharp)

• paket.references
• paket.template
• paket.local
• fslex
• fsyacc
• .ionide

A function named "eval" will be highlighted correctly when it's defined. But when you call it, it will be highlighted as if the "val" part of the function is a keyword:

I have also been able to reproduce this behavior with other functions that contain keywords inside their names, like is_a_member, as long as the "keyword" comes at the end of the name:

Also, if the line is eval (x + 4), then the function is highlighted correctly (the val part is not seen as a keyword). Only when the line looks like eval x does the highlighting get it wrong. In other words, when it would match a regex that looks like correct use of the val keyword.

Adding a simple "start-of-word" lookahead to the keyword regex will probably solve this issue.

In VSCode, if I use an Unicode symbol (for example an accented character) in a type name, the syntax coloration is broken, as seen below for the type "Evénement":

It may be related to the issue #10

Remark: this also happens if you just have whitespaces after the }, but intentional or not, I actually like that ;)

Syntax Colorization Failure

type One =
    { Id : string }

type Two =
    { Id : int } //test

type Three =
    { Id : int }

System Details

• OS: Windows
• VSCode
• Installed Extension Version: v3.22.3

Based on - https://github.com/IBM-Bluemix/vscode-log-output-colorizer

Syntax Colorization Failure

type Example = //does work here correctly
    { Id : int //doesn't work here
      Whatever : string }

System Details

• OS: windows
• VSCode
• Installed Extension Version: 3.22.2

It would be nice if (** ... *) comment blocks (and single-line comments with ///) were internally highlighted as Markdown, because they're most likely FSharp.Formatting comments (either literate .fsx files or API documentation).

Issues to figure out:

• What is the name of the Markdown syntax that most people will have? AFAIK the most popular one for Atom is language-markdown, where the name of the syntax is text.md. But people might also be using language-gfm, where the name of the syntax is source.gfm. And I don't know anything about Visual Studio Code's syntax highlighting; what are the Markdown syntax names there?
• Should this be an option that people can turn on and off? (Is that even possible in a syntax grammar?) Some people might use XML in /// comments, as ugly as that is compared to Markdown syntax.

Would it be possible to add a license to this project? I assume its MIT like the rest of ionide, just want to make sure though.

Preview

Code

open Thoth.Json.Decode

> decodeString string "\"maxime\""
val it : Result<string, string> = Ok "maxime"

> decodeString int "25"
val it : Result<int, string> = Ok 25

> decodeString bool "true"
val it : Result<bool, string> = Ok true

> decodeString float "true"
val it : Result<float, string> = Err "Expecting a float but instead got: true"

type R = private { X  : int }
type U = private | X of int

(Even github gets it wrong!)

(On latest stable VS Code with latest version of ionide-fsharp)

We are still missing some grammar part and I am working on it.

After adding them, we should do a pass over the symbols and choose what is a symbol or not and their color.

Example {, =, : etc. are colored in purple:

When (, ,, ? aren't:

I noticed a problem this morning with font ligatures, but I believe after some stack overflow conversations it may be due to the grammer for f# causing issues.

See https://stackoverflow.com/questions/42225024/vscode-font-ligature-issue-whose-issue-is-it for details.

In short, anonymous functions seems to be having a little bit of a problem with detecting the -> at the end of the declaration. When you put something in the anon function def like parens or the like, it seems to cause the capture scope to break out of the anon function scope and everything seems ok, but if I put just a single variable declaration after fun, it doesnt recognize that its out of the anon function scope until after it sees the - in he ->. this seems to cause the engine to both color the - and > differently, but it also seems to confused the glyph engine into thinking they should be different characters and not combined into one.

I'll see if I can find a fix, I've submitted a few other pr's for f# syntax not working right, but I'm not very sure how to fix this one yet. If anyone has any thoughts, please let me know.

System Details

• Windows 10
• VSCode 1.9.1
• ionide 2.22.2

the ] is already inserted and when you type the coloring is broken. Please add ] as stop token in atttribute regex

@MangelMaxime

Repro:

create test.fs, and put the following code inside:

type T = C of int
let m = C 3
let (C n) = C 3

Expected behaviour: the let keywords should have the same color; m and n should have the same color.

Actual behavior:

ionide-fsharp 2.22.0, reproducible on OS X and Windows 10, VS Code stable and insiders.

Preview:

Code:

let success (builder : Builder<_, _>) : Cmd<'msg> =
    [ fun dispatch ->
        triggerEvent builder Success dispatch ]

github should be only colorized if it's on begging of line (type of dependency)
git should be colorized if it's on begging of line (type of dependency)

Syntax Colorization Failure

    Program.mkProgram init update
    #if DEBUG
    |> Program.withConsoleTrace
    #endif
    |> Program.run

System Details

• OS: mac OS High Sierra version 10.13.5
• VSCode 1.25.1
• Installed Extension Version: 3.22.3

After #51 the colorization of the opening brace of computation expressions stopped working. I noticed that today.

With 611f9ce (Before merging #51):

Current master of this repository and whatever is in Ionide:

This is how it looks like in VS2013:

Syntax Colorization Failure

let zero = async { return 0 }

/cc @MangelMaxime

Preview

Code

type [<AllowNullLiteral>] IGrammarFiles =
    [<Emit "$0[$1]{{=$2}}">] abstract Item: selector: string -> string with get, set

Reported in; ionide/ionide-vscode-fsharp#207

Original comment:

Interesting that they are properly colored in tooltips.

adding a space after } breaks coloring:

Sample code:

    type Company = { 
        OperatorID : string }

    [<RequireQualifiedAccess>]
    type Customer =
    | Company of Company

/cc @MangelMaxime

This is an issue in other languages also (for example ruby), you can check the discussion in
tonsky/FiraCode#63
and the solution
atom/language-ruby#117

Expected ligatures (Picture is with syntax text):

This is what is shown (Picture is with syntax F#):

"Repro:

let foo = @"""\""" 

This represents the string "" (including quotes). It looks like Ionide interprets the backslash as escaping the closing quote, and then the subsequent pair of quotes as a second escaped quote, so the full quoted string is never closed. Subsequent lines of code are interpreted by ionide as part of the string.
"

by @simra

Stumbled on this. Maybe the grammar is the source. At least in VSCode, either of the following lines will break error messages and type checking for the file being processed.

let λ = 1 + 2
let ∑ of numbers should be 💩 = List.sum [1..5]
let whoops = 1 + "abcd"

Also see:
https://github.com/fsharp/fsharp/blob/master/tests/xplat/core/FsharpUnitTestProject/SharedTests/unicode.fs

or

https://github.com/fsharp/fsharp/tree/master/tests/fsharp/core/unicode

...
This is a super edge case, but it's something that can break. All from a silly tweet that said I could use certain Unicode let bindings.

Reported in ionide/ionide-vscode-fsharp#457

Original comment:

The colorization for types with attribute Measure is wrong. See screenshot here:

I am creating this issue to share my current work on the grammar. I am trying to make the regex works for all/most of the possible signatures.

The idea is to find a regex, that can later be re-used if possible. If you think not all the possible signature are covered here please. Please comment with the missing code.

Preview

Code

let primitive : int = 0

let tupleOfPrimitives : int * string = 0, ""
let tupleOfPrimitives : (int * string) = 0, ""

let generics : Result<string list, int array> = Ok []

let tupleWithGenerics : Result<string list, int array> * int = Ok [], 0

let tupleWithGenerics2 : (Result<string list, int array> * int) = Ok [], 0

let lambda : int -> unit = ignore
let lambda : (int -> unit) = ignore
let lambda : (int -> unit) -> unit = ignore
let lambda : (Result<string list, int array> -> (string * int)) -> unit = ignore
let lambda : (Result<string list, int array> -> string * int) -> unit = ignore

let inline isLoadingTime<'a> = ""

let printFullName { Firstname = firstname; Surname = surname } : string = firstname + " " + surname
let printFirstName { Firstname = firstname } : string = firstname
let printFirstName ({ Firstname = firstname } : NameRecord) : string = firstname

PS: Yes, I am indeed crazy :D

/cc @MangelMaxime

🤗

Preview:

Code:

let debounce (debounce : int option) =

I have a value named match' that I'm performing a pattern match on, and the match part of the name (not the apostrophe) is colored as a keyword. This is also the case if I name the value e.g. return'.

Ionide 3.8.0.

Moved from ionide/ionide-vscode-fsharp#603

Syntax Colorization Failure

// Wrong colorization of 'of'
let aofb = ()
aofb
let ofb = ()
ofb
let aof = ()
aof

// Expected colorization
let bla = ()
bla

System Details

• OS: Windows 10
• VSCode 1.23.1
• Installed Extension: Ionide-fsharp 3.21.0

I’m trying to configure keywords to display using bold italic text, because it looks awesome.

Unfortunately it looks like the grammar assigns almost everything to the keyword.other.fsharp scope including operators, punctuation, the colon in type annotations, every parenthesis (except for unit, weirdly) etc. This doesn’t look as awesome.

Would you be open to splitting these out into things like keyword.operator, punctuation.separator, punctuation.section.braces etc? I can start on this if so. Or is there are good reason why everything is keyword.other.fsharp?

Currently we treat every function that is followed by { as a builder. The common case that { is a record and not a block is therefore falsely colored.

I hereby propose we move the error to the builder side and use whitelisting. We should whitelist:

• async
• promise
• task
• maybe
• asyncMaybe
• all Saturn builders like controller

When you put the params on a new line of a function, it no longer works.

Syntax Colorization Failure

let example user
            name
            title = 
    ()

System Details

• OS: windows, mac
• vscode 1.24
• v3.22.1

Moved from ionide/ionide-vscode-fsharp#764

by @hstk

Highlighting / underlining applied to type declarations trails until the =.

Built-in vscode Abyss color theme is sufficient to notice the problem.

Preview

Code

let createGrammarFiles (files : (string * string) list) =

With latest master:

Syntax Colorization Failure

let t1 = typeof<int>
let t2 = typedefof<Option<_>>

ionide/ionide-vscode-fsharp#410

Original comment:

reposted from ionide/ionide-vscode-fsharp#123 (comment)

Take a look at the following picture. In the definition of x1, the C case is shown in blue. This is inconsistent with the other examples.

Moved from: ionide/ionide-vscode-fsharp#600

type X( num) = class end
type Y(?num) = class end

(Again, github seems to get it wrong too)

(On latest stable VS Code with latest version of ionide-fsharp)