Font-lock types differently

[gracjan]

Types and constructors share namespace in Haskell and only context tell how a token starting with uppercase letter should be interpreted. Emacs' font lock isn't best at context but can be coerced to use one. The plan:

1. Trigger type font lock on :: token.
2. Parse what comes after that as a type expression.
3. Mark where the type expression starts and ends.
4. Font lock tokens in marked region as types instead of constructors.

Tricky situations:

putStrLn (123 :: Int)
x :: String <- return ""
x :: String = "xx"
x :: (HasField "field" r) => r
x + y :: Int where y = 45
data T = C

And everything related to DataKinds.

[gracjan]

More tricky:

fun = let x, y :: Int
          x = 5; y = 7 in x + y

fun = do
    x :: Int -> Int <- return (\(x :: Int) -> x + 5)

[gracjan]

How about this as approximation:

1. Start with :: (or Unicode version of it).
2. Go over the line.
3. Stop at any keyword.
4. Stop at any closing parenthesis.
5. If an open parenthesis is found, jump over whole block.
6. If at the end of line look at the last token and the next token in the next line, if any is any operator then continue.

This should properly catch cases:

(x :: Int)

x :: (Monad m,
      Applicative m) => m a

x :: Int
  -> Int

fun = do
   x :: Int -> String <- return show

fun = let x :: Int = 5 in x

This will not catch line continuation broken on non-operator:

x = Lens s t
         a b

This style of code should be pretty rare, I hope.

[gracjan]

Now about the mechanics of this.

Seems the only way to parse Haskell is from beginning to the end, we have one place where we do this, its haskell-syntax-propertize. It uses lexemes as its building block.

It could get sensitive to :: class, data, newtype, type and instance and also keywords that are type-enders and then just go by tokens, enable type mode when it sees one of type introduction tokens and disable type mode when it sees one of enders. It would have to keep track of parenthesis pairs, sadly. And of newlines.

And type declaration is special because it has types on both sides of equal sign:

type F a b = M a -> M b

It might be easier to just parse the type when :: is spotted. Note that this requires multiline for font-lock, otherwise it may go haywire.

[gracjan]

More cases to handle:

data X a b = X Int String a b
data family X a b = X a b
type X a b = X a b
type family X a b = X a b
class X a b
instance (Monad m) => X m b | x -> b where
newtype X = X Int
data X a where
   X1 :: Int -> X Int