Currently foreign imports and exports as used by the Haskell C FFI do not seem to be highlighted correctly. The syntax is documented in the Haskell standard https://www.haskell.org/onlinereport/haskell2010/haskellch8.html#x15-1490008. In addition to the calling conventions listed there it would be nice to support the javascript calling convention which used by GHCJS.

See attached screenshot. Syntax highlighting for the first comment is broken for this snippet:

module Test
-- This is a comment
where
-- This is a comment

import Etc

Sorry for making so many issues, I just started using vscode and I'm just reporting things as I come across them. I can collect them into a single issue in future if you would prefer, since they are all very minor issues.

Thanks for awesome plugin!

I wrote haskell codes such as:

dbPageWrapper :: (DashBoardPage p, Monad m) =>
  T.Text -> p -> HtmlT m a -> HtmlT m b -> HtmlT m b -- disable type highlighting
dbPageWrapper pref page headerC mainC = do
  ...

Then, I noticed missing syntax.

I use GHC 7.10.3. Probably, because building is passed, this is legal syntax.

The identifier module' triggers the syntax highlighting associated with the normal module keyword, even though the inclusion of the prime/single-quote symbol should turn it into an ordinary, non-reserved identifier. Importantly, all text after the identifier module' is highlighted as though it were part of a module declaration, which can seriously break syntax highlighting on large parts of valid source files.

Here's an example of the incorrect syntax highlighting for the identifier module':

And an example of correct syntax highlighting for the identifier module_:

Types for the fields of a constructor which does not use the record syntax are not tagged as type or type variable.

Here are some examples of missing keywords:

the keywords "family", "instance" and "where" in type/data families, e.g.:

"via" from the deriving via extension:

(Note also that the type variable in the standalone deriving declaration is not highlighted correctly.)

"pattern" for a pattern synonym declaration

Having tough time using it under visual studio code. It randomly inserts this string at places:

<no location info>: Expected a span: "<module-name/filepath>" <start line> <start column> <end line> <end column> "<sample string>"

Removing it and correcting the code slows me down heavily. Wondering if I am not setup right?

Users can define their own snippets of code easily in VSCode, so I think the provided snippets are not needed. I personally don't use all of them and so they are mostly just annoyingly appearing, because there is no way to turn them off.

In existential types such as

data Exts = forall var . Class var => Exts var

the forall keyword is not highlighted.

Signatures in the class definition head are highlighted differently than in the instance declaration head and other general type signatures.

I believe this should be changed and unified.

Not entirely sure indentation rules are specified in the syntax packages, so just ignore this if that's not the case.

I find that I often wrestle with the automatic indentation, especially after where blocks. For example, pasting in Haskell code, will automatically indent everything after the module ... where in the top, which is not really intended. Take e.g.

module Main where

import Primes

main = putStrLn $ "The 101st prime is " ++ show (primes !! 100)

which becomes (when pasted),

module Main where

  import Primes

  main = putStrLn $ "The 101st prime is " ++ show (primes !! 100)

It would be great if one could either disable the indentation for module ... where specifically, or better yet have the behaviour of resetting indentation after two blank lines in a row.

Is this even possible in VS Code?

Originally reported by @metaleap in #15

If a deriving clause is followed by a single type class, which is not enclosed in parentheses it is tagged as storage.other and not type.

Are you thinking about supporting the code outline extension?

When making automatic line comments inside of a literate file, the Haskell comments are used, but should be the latex style comments (in my case).

> main = do

becomes

-- > main = do

rather than

% > main = do

Am I just doing something wrong? Let me know.

It would be nice if hightlighting would work on fenced markdown code blocks like this

```haskell
myhaskell code
```

here is an example of how to do this.

This behaviour is not observed when the part to the left of (<-) is wrapped in parenthesis.

Hi JustusAdam!

Do you have any useful background about what's happening with Literate Haskell syntax?

I've just cloned your repo and looking forward to take a shot at this issue. I'm still getting my head into vscode extension development and it will be my first contact with textmate syntax definitions so, no warrants included.

Thank you!

Works without kind signature.

It would be sufficient if data is treated as a keyword in case data TypeName (=|where) doesn't match.

I'm not sure this should be in haskell-configuration.json as although single quotes are used for literals, they're more often used as primes and data kind ticks.

Having to constantly delete the second prime is annoying.

.tidal is the standard extension for TidalCycles files. These are basically just a scratchpad containing Haskell expressions. You can then use the vscode-tidalcycles extension to feed these expressions into GHCi.

To get syntax highlighting at the moment, one has to associate *.tidal files with the Haskell filetype, but this causes other extensions like haskell-lsp to go a bit nuts because they expect the files to be valid Haskell modules.

P.S. If you think it is better to put this in its own extension I'll do that.

Proposal:

"languages": [
            ...
            {
                "id": "tidal",
                "aliases": [
                    "Tidal",
                    "tidal"
                ],
                "extensions": [
                    ".tidal"
                ],
                "configuration": "./haskell-configuration.json"
            }
],

module Main
  (
    -- * main func  <- disable highlighting
    main
    {- | disable, too
    -}
  ) where

-- enable comment highlighting

I think this is a miss. However, there are not supported services such as GitHub.
So, possibly, this issue is not needed.

This issue seems to be caused by textmate bundle, too.
Should I open an issue there?

Hello,

First of all, thanks a lot for all your work on the plugin.
I have an issue with multi-line signatures (as formatted by Brittany).
The rendering of types in lines 2..n of the signature is not consistent with line 1 (it looks like constructors rather than types).

See, eg,

vs (expected)

This could possibly be linked to #1.
Nb: I have seen also #27.

I am using:

• VSC 1.24.1
• Haskell Syntax 2.5.0 (but in the Changelog in VSC I see 3.0.0)
• Haskell Language Server 0.0.19
• HIE 0.2.0.0

Note the different colors:

The purpose of syntax highlighting is in my opinion to tell different type of constructs apart. It would be great to tell these apart by color:

• Types .... e.g. Int, Text, IO a
• Keywords .... e.g let, otherwise, ::, ->
• Primitives .... e.g. 5, "String"
• Data constructors .... e.g. Right, Just
• Function declaration, arguments
• Control characters .... e.g. (,), `

But right now, there are:

• Distinctions between Prelude/Non-Prelude which are useless in my opinion (they also don't hold if there is a custom prelude)
• Prelude functions have the same color as function declarations
• 3 different color for types (Bold, Thin Green, Thin Red).

I find the highlighting confusing at the moment. What do you think?

btw. this is not just the theme I'm using, most other themes behave like that

The following code snippet is parsed incorrectly. The last two lines for main are completely unhighlighted in the vscode editor. The problem goes away if "of" is changed to "f". I'm running language-haskell 2.4.0 on vscode 1.19.0 with ghc 8.2.2.

{-# LANGUAGE DataKinds, FlexibleInstances, KindSignatures, MultiParamTypeClasses, FunctionalDependencies #-}

import GHC.TypeLits

data Label (l :: Symbol) = Get

class Has a l b | a l -> b where
  from :: a -> Label l -> b

data Point = Point Int Int deriving Show

instance Has Point "of" Int where from (Point x _) _ = x

example = from (Point 1 2) (Get :: Label "of")

main :: IO ()
main = undefined

The string "^\\" causes the end quote to not be recognized.

Here's one example:

Note that the ticks at the beginning of the last line are highlighted orange (which is what my theme uses for character and string literals).

See https://github.com/haskell/c2hs

They can mean just about anything so their contents should be treated either as plain text or a string literal.

There is a list of reserved names for quotes that should remain as Haskell code.

Some code I am working in is using a function called module', but this severely messes up the syntax highlighting.

The reason is that all keywords in the grammar file is using \b to detect whole words. As I gather it, the \b will match any \w up until \W, where \w is a shorthand for [a-zA-Z0-9_] and \W is anything but \w. This is in conflict with Haskell's syntax, which actually allows any variable definition to end with '. I did a quick hack where I replaced the ending \b for the module-keyword with the following non-capturing group and it fixed the issue: (?:[^a-zA-Z0-9_'])

This problem is certainly affecting all keywords, and I was considering doing a pull request but my textmate grammar skills aren't that great so it is hard for me to know what the impact would be.

I am finding I am undoing the indent a lot of the time. It would be nice to have an option to disable it from happening.

Disabling editor.autoIndent for haskell in the user settings seems to avoid some of the instances (such as auto-indenting when pasting) but some basic ones still occur (such as hitting Enter and having it indent too far).

  "[haskell]": {
    "editor.autoIndent": false
  },

Thank you for making and maintaining this plugin! If you look at how GitHub displays blocks like this:

foobar = let
    foo = bar
    fuzz = buzz
    test = tested
    in (finalResponse)

you can see that the equal sign is highlighted. Without at least the equal sign being highlighted I have big blocks of entirely plain text code with no syntax highlighting at all.

I also recommend highlighting the $ operator.

foo = bar $ some thing

And ++ as well.

foo = "concated a " ++ "string"

It just seems like a lot of basic things aren't highlighted.

Integers in type signatures should be correctly identified and highlighted.

let x = (something :: MyLabel 5)

There should be a rule for overloaded labels. Currently they are sometimes identifier as C preprocessor instructions, and otherwise parsed as an operator applied to an identifier.

A class without any associated functions, e.g. just class A a, is valid Haskell, but gets highlighted incorrectly, as does everything following it.

Correct highlighting of non-empty class:

Incorrect highlighting of empty class:

Currently the increase indent regex increases the indent after any if, even if the if expression terminates on the same line.

Essentially it should not increase indent if a then follows the if.

The current regex is \bif\b(?!').*.

I tried \bif\b(?!').*(?!then.*) and \bif\b(?!').*?(?!then.*). Neither works.

I am not sure the regex is strong enough to even express what we need but I have not confirmed that yet.

Type variables within a visible type application are not highlighted.

This requires disambiguating between visible type application and as-patterns. Quoting Richard Eisenberg:

With -XTypeApplications on, the character immediately before an @ determines how it is lexed.

1. If the character is a legal end-of-identifier character (respecting the state of the -XMagicHash flag), then the @ is an as-pattern.
2. Otherwise, then the @ is the beginning of a type application.

Originally reported by @metaleap in #15 .

If a module is present in an export list it is tagged as function rather than keyword.

When I type module MyModule where and then tab or enter, it attempts the name = value completion which has to be deleted before moving on. Adding a space after where keeps this from happening but then I have an extra space character in my source file.

Is there a way to make this completion context aware and not try this completion when on the same line as module?

If possible, I'd be happy to make the change and submit a pull.

See for instance:

For keyword.control.haskell: where you have (do|if|then|else) I'd suggest (in the same spirit of those 2 concepts) to also add:

mdo, case, of

It seems VS code recommend .json for tmLanguage grammars. I used this extension to convert and it seems to work, if you decide in future to switch. Just friendly sharing knowledge - not suggesting you must! :)

Some promoted data constructors are getting confused with reserved operators:

Note also that the data declaration gets confused by the symbolic identifier and does not highlight properly.

This commit introduces the issue: ac3ae6b

According to this doc: https://code.visualstudio.com/docs/extensionAPI/extension-points#_contributeslanguages

vscode doesn't respect the field "indentationRules" in haskell-configuration.json, I just reverted the deletion of fields "main" and "activationEvents" in package.json and everything seems to work then.

The magic hash character, i.e. a hash sign at the end of an identifier, should be highlighted like the identifier that it is appended to. This should also apply to multiple hashes in a row.

This is common with haddock markup as shown above.

Minor quirk really, but for the sake of completeness of open (non)"issues" 😁 In the screenshot below, observe:

• at the bottom --- correct detection of deriving in keyword scope in the tagged-union data QueryData that has no record-syntax, vs.

• at the top (and also in the data Query near the bottom) --- incorrect mis-detection of deriving in variable scope when record-syntax is present in the data

My RegEx is super-rusty, maybe I'll try my hand here later today, but wanted to report for now ;)