" Vim indent file
" Language: Haskell
" Maintainer: Tristan Ravitch

if exists('b:did_indent')
  finish
endif

let b:did_indent = 1

if !exists('g:hasksyn_indent_search_backward')
  let g:hasksyn_indent_search_backward = 100
endif

if !exists('g:hasksyn_dedent_after_return')
  let g:hasksyn_dedent_after_return = 1
endif

if !exists('g:hasksyn_dedent_after_catchall_case')
  let g:hasksyn_dedent_after_catchall_case = 1
endif

setlocal noautoindent
setlocal indentexpr=HIndent(v:lnum)
setlocal indentkeys+=0=where
setlocal indentkeys+=0=->
setlocal indentkeys+=0==>
setlocal indentkeys+=0=in
setlocal indentkeys+=0=class,0=instance,0=import
setlocal indentkeys+=<Bar>
setlocal indentkeys+=0\,

if exists("*HIndent")
  finish
endif


function! HIndent(lnum)
  " Don't do anything boneheaded if we are inside of a block comment
  if s:IsInBlockComment()
    return -1
  endif

  let plnum = s:PrevNonCommentLineNum(a:lnum)
  if plnum == 0
    return 0
  endif

  let prevl = s:GetAndStripTrailingComments(plnum)
  let thisl = s:GetAndStripTrailingComments(a:lnum)
  let previ = indent(plnum)

  " If this is a bare where clause, indent it one step.  where as part of an
  " instance should be unaffected unless you put it in an odd place.
  " This is the wrong thing if you are deeply indented already and want to put
  " a where clause on the top-level construct, but there isn't much that can
  " be done about that case...
  if thisl =~ '^\s*where\s*$'
    return previ + &sw
  endif

  " If we start a new line for a type signature, see if we can line it up with
  " the previous line.
  if thisl =~ '^\s*\(->\|=>\)\s*'
    let tokPos = s:BackwardPatternSearch(a:lnum, '\(::\|->\|=>\)')
    if tokPos != -1
      return tokPos
    endif
  endif

  if prevl =~ '\Wof\s*$' || prevl =~ '\Wdo\s*$'
    return previ + &sw
  endif

  " Now for commas.  Commas will align pretty naturally for simple pattern
  " guards, so don't worry about that for now.  If we see the line is just a
  " comma, search up for something to align it to.  In the easy case, look
  " for a [ or { (the last in their line).  Also consider other commas that
  " are preceeded only by whitespace.  This isn't just a previous line check
  " necessarily, though that would cover most cases.
  if thisl =~ '^\s*,'
    let cmatch = match(prevl, '\(^\s*\)\@<=,')
    if cmatch != -1
      return cmatch
    endif

    let bmatch = match(prevl, '\({\|\[\)')
    if bmatch != -1
      return bmatch
    endif
  endif

  " Match an 'in' keyword with the corresponding let.  Unfortunately, if the
  " name of your next binding happens to start with 'in', this will muck with
  " it.  Not sure if there is a workaround because we can't force an
  " auto-indent after 'in ' as far as I can see.
  if thisl =~ '\s*in$'
    let letStart = s:BackwardPatternSearch(a:lnum, '\(\W\)\@<=let\W')
    if letStart != -1
      return letStart
    endif
  endif

  " We don't send data or type to column zero because they can be indented
  " inside of 'class' definitions for data/type families
  if thisl =~ '^\s*\(class\|instance\|newtype\|import\)'
    return 0
  endif

  " FIXME: Only do this if the previous line was not already indented for the
  " same reason.  Also be careful of -> in type signatures.  Make sure we have
  " an earlier rule to line those up properly.
  if prevl =~ '[=>\$\.\^+\&`(-]\s*$'
    return previ + &sw
  endif

  " We have a special case for dealing with trailing '*' operators.  If the *
  " is the end of a kind signature in a type family/associated type, we don't
  " want to indent the next line.  We do if it is just being a * operator in
  " an expression, though.
  if prevl =~ '\(\(type\|data\).*\)\@<!\*\s*$'
    return previ + &sw
  endif

  " If the previous line ends in a where, indent us a step
  if prevl =~ '\Wwhere\s*$'
    return previ + &sw
  endif

  " If we see a |, first try to line it up with the pipe on the previous line.
  " Search backward on nearby lines, giving up if we hit a line with a \w at
  " column 0. Otherwise, indent it relative to the previous line
  "
  " Here we can also handle the case of lining up data declarations.  The
  " backwards pipe search will fail for a data declaration (since data is at
  " column 0), so we can have an extra check after the pipe search for
  " data..=.
  if thisl =~ '^\s*|$'
    let nearestPipeIndex = s:BackwardPatternSearch(a:lnum, '\(^\s*\)\@<=|')
    if nearestPipeIndex != -1
      return nearestPipeIndex
    endif

    let dataEquals = match(prevl, '\(data.*\)\@<==')
    if dataEquals != -1
      return dataEquals
    endif

    return previ + &sw
  endif

  " If the previous line has a let, line the cursor up with the start of the
  " first binding name.  Autoindent handles subsequent cases.
  "
  " This should come after the 'in' aligner so that 'in' is not treated as
  " just something to be aligned to the previous binding.
  let lbindStart = match(prevl, '\(\Wlet\s\+\)\@<=\w')
  if lbindStart != -1
    return lbindStart
  endif

  " If requested, dedent from a bare return (presumably in a do block).
  " This comes after the trailing operator case - hopefully that will avoid
  " returns on lines by themselves but not really in a do block.  This is a
  " heuristic.
  if g:hasksyn_dedent_after_return && prevl =~ '^\s*return\W'
    return previ - &sw
  endif

  " Similar to the return dedent - after a catchall case _ -> ..., we can
  " almost certainly dedent.  Again, it comes after the line continuation
  " heuristic so we don't dedent while someone is making an obviously
  " multi-line construct
  if g:hasksyn_dedent_after_catchall_case && prevl =~ '^\s*_\s*->\W'
    return previ - &sw
  endif

  " On the other hand, if the previous line is a where with some bindings
  " following it on the same line, accommodate and align with the first non-ws
  " char after the where
  if prevl =~ '\Wwhere\s\+\w'
    let bindStart = match(prevl, '\(\Wwhere\s\+\)\@<=\w')
    if bindStart != -1
      return bindStart
    endif

    return previ + &sw
  endif

  return previ
endfunction

" Search backwards for a token from the cursor position
function! s:FindTokenNotInCommentOrString(tok)
  return search('\(--.*\|"\([^"]\|\\"\)*\)\@<!' . tok, 'bcnW')
endfunction

" Should return -1 if the given line is inside of an unclosed block comment.
" This is meant to let us exit early from the indenter if we are in a comment.
" Look for the nearest -} and {- such that they are not between "" or in a
" line comment
"
" Note: we may need to restrict how far back this will search.  On the other
" hand, the native vim 'search' function might be efficient enough to support
" entire buffers.
function! s:IsInBlockComment()
  let openCommPos = s:FindTokenNotInCommentOrString('{-')
  " If there is no open comment, then we don't have to look for a close
  if openCommPos == 0
    return 0
  endif

  " Or if there is a close comment marker that comes after the open marker, we
  " are not in a comment.  Note that we potentially need to check the position
  " in the line if they are both on the same line.  I'll fix it later.
  let closeCommPos = s:FindTokenNotInCommentOrString('-}')
  if closeCommPos >= openCommPos
    return 0
  endif

  return 1
endfunction

" Get the previous line that is not a comment.  Pass in the *current* line
" number.  Also skips blank lines.
function! s:PrevNonCommentLineNum(lnum)
  if a:lnum <= 1
    return 0
  endif

  let lnum = a:lnum - 1

  while 1
    if lnum == 0
      return 0
    endif

    let aline = getline(lnum)
    if aline =~ '^\s*--'
      let lnum = lnum - 1
    else
      return lnum
    endif
  endwhile
endfunction

function! s:GetAndStripTrailingComments(lnum)
  let aline = getline(a:lnum)
  " We can't just remove the string literal since that leaves us with a
  " trailing operator (=), so replace it with a fake identifier
  let noStrings = substitute(aline, '"\([^"]\|\\"\)*"', 's', '')
  let noLineCom = substitute(noStrings, '--.*$', '', '')

  " If there are no fancy block comments involved, skip some of this extra
  " work
  if noLineCom !~ '\({-\|-}\)'
    return noLineCom
  endif

  " We stripped line comments, now we need to strip out any relevant multiline
  " comments.  This includes comments starting much earlier but ending on this
  " line or comments starting on this line and continuing to the next.  This
  " is probably easiest in two steps: {- to (-}|$) and then ^ to -}.
  " Note we are using a non-greedy match here so that only the minimal {- -}
  " pair is consumed.
  let noBlock1 = substitute(noLineComm, '{-.\{-}-}', '', '')
  let noBlock2 = substitute(noBlock1, '{-.\{-}$', '', '')
  let noBlock3 = substitute(noBlock2, '^.\{-}-}', '', '')
  return noBlock3
endfunction

" Search backwards from lnum for pat, returning the starting index if found
" within the search range or -1 if not found.  Stops searching at lines
" starting at column 0 with an identifier character.
function! s:BackwardPatternSearch(lnum, pat)
  let lnum = s:PrevNonCommentLineNum(a:lnum)
  while 1
    let aline = s:GetAndStripTrailingComments(lnum)
    if a:lnum - lnum > g:hasksyn_indent_search_backward
      return -1
    endif

    let theMatch = match(aline, a:pat)
    if theMatch != -1
      return theMatch
    else
      " We want to be able to consider lines starting in column 0, but we don't
      " want to search back past them.
      if aline =~ '^\w'
        return -1
      endif
      let lnum = s:PrevNonCommentLineNum(lnum)
    endif
  endwhile
endfunction