walker.lua

   1 local M = {}
   2
   3 local function finishof(node) return node.finish end
   4 local function startof(node) return node.start end
   5 local function is_comment(node) return node.is_comment end
   6
   7 function M.new(parser, eol_at, bol_at)
   8
   9         local function is_line_comment(node) return node.is_comment and parser.opposite[node.d] == "\n" end
  10
  11         local function in_quasilist(t, range)
  12                 return t and t.d and not t.is_list and
  13                         range.start >= t.start + #t.d and range.finish <= t.finish + 1 - #parser.opposite[t.d]
  14         end
  15
  16         local function sexp_at(range, true_sexp)
  17                 local node, parent, nth = parser.tree.sexp_at(range)
  18                 if not in_quasilist(node, range) or true_sexp then
  19                         return node, parent, nth
  20                 else
  21                         return node.word_at(range), node
  22                 end
  23         end
  24
  25         local function escaped_at(range)
  26                 local node = parser.escaped.around(range)
  27                 -- TODO: distinguish between doublequoted strings, chars, line comments, and block comments
  28                 -- and use approprite offset comparisons for each
  29                 return node and range.start > node.start and range.finish <= node.finish and node
  30         end
  31
  32         local function find_before_innermost(t, range, key, pred)
  33                 if t.is_root or (t.d and t.start < range.start) then
  34                         if t.d and not t.is_list then
  35                                 local keypos = key(t)
  36                                 local start = keypos == startof(t)
  37                                 local finish = keypos == finishof(t)
  38                                 local newpos
  39                                 if finish then
  40                                         newpos = t.finish_before(range.finish)
  41                                 elseif start then
  42                                         newpos = t.start_before(range.start)
  43                                 end
  44                                 if newpos then
  45                                         local word = t.word_at({start = newpos, finish = newpos})
  46                                         if word and pred(word) then
  47                                                 return word
  48                                         end
  49                                 end
  50                                 return
  51                         end
  52                         local _, nearest_n = t.before(range.start, startof)
  53                         if nearest_n then
  54                                 for n = nearest_n, 1, -1 do
  55                                         local child = t[n]
  56                                         if child.d and not child.is_empty then
  57                                                 local ret = find_before_innermost(child, range, key, pred)
  58                                                 if ret then
  59                                                         return ret
  60                                                 end
  61                                         elseif key(child) < key(range) and pred(child, n, #t) then
  62                                                 return child, n, #t
  63                                         end
  64                                 end
  65                         end
  66                         if not t.is_root and pred(t) then
  67                                 return t
  68                         end
  69                 end
  70         end
  71
  72         local function find_after_innermost(t, range, key, pred)
  73                 if t.is_root or (t.d and t.finish >= range.finish) then
  74                         if t.d and not t.is_list then
  75                                 local keypos = key(t)
  76                                 local start = keypos == startof(t)
  77                                 local finish = keypos == finishof(t)
  78                                 local newpos
  79                                 if finish then
  80                                         newpos = t.finish_after(math.max(t.start + #t.d, range.finish))
  81                                 elseif start then
  82                                         newpos = range.finish < t.start and t.start + #t.d or t.start_after(range.start)
  83                                 end
  84                                 if newpos then
  85                                         local word = t.word_at({start = newpos, finish = newpos})
  86                                         if word and pred(word) then
  87                                                 return word
  88                                         end
  89                                 end
  90                                 return
  91                         end
  92                         local _, nearest_n = t.after(range.finish, finishof)
  93                         if nearest_n then
  94                                 for n = nearest_n, #t do
  95                                         local child = t[n]
  96                                         if child.d and not child.is_empty then
  97                                                 local ret = find_after_innermost(child, range, key, pred)
  98                                                 if ret then
  99                                                         return ret
 100                                                 end
 101                                         elseif key(child) >= key(range) and pred(child, n, #t) then
 102                                                 return child, n, #t
 103                                         end
 104                                 end
 105                         end
 106                         if not t.is_root and pred(t) then
 107                                 return t
 108                         end
 109                 end
 110         end
 111
 112         return {
 113
 114                 start_before = function(range, skip)
 115                         local _, parent = parser.tree.sexp_at(range)
 116                         local node = parent.before(range.start, startof, skip)
 117                         return node and startof(node)
 118                 end,
 119
 120                 start_after = function(range, skip)
 121                         local _, parent = parser.tree.sexp_at(range)
 122                         local node = parent.after(range.finish, startof, skip)
 123                         return node and startof(node)
 124                 end,
 125
 126                 finish_before = function(range, skip)
 127                         local _, parent = parser.tree.sexp_at(range)
 128                         local node = parent.before(range.start, finishof, skip)
 129                         return node and finishof(node) + 1
 130                 end,
 131
 132                 finish_after = function(range, skip)
 133                         local _, parent = parser.tree.sexp_at(range)
 134                         local node = parent.after(range.finish, finishof, skip)
 135                         return node and finishof(node) + 1
 136                 end,
 137
 138                 start_down_after = function(range, skip)
 139                         local node, parent = parser.tree.sexp_at(range)
 140                         if in_quasilist(node, range) then return end
 141                         if node and node.p then
 142                                 -- XXX: if we are past a prefix start, this will prevent skipping over its list
 143                                 range.start = node.start
 144                         end
 145                         local next_list = parent.find_after(range, function(t) return t.is_list end)
 146                         if next_list then
 147                                 local first = next_list.after(range.finish, startof, skip)
 148                                 if first then
 149                                         return first.start
 150                                 else
 151                                         return next_list.start + (next_list.p and #next_list.p or 0) + 1
 152                                 end
 153                         end
 154                 end,
 155
 156                 start_up_before = function(range)
 157                         local _, parent = sexp_at(range)
 158                         return parent.d and parent.start
 159                 end,
 160
 161                 finish_down_before = function(range, skip)
 162                         local node, parent = parser.tree.sexp_at(range)
 163                         if in_quasilist(node, range) then return end
 164                         local prev_list = parent.find_before(range, function(t) return t.is_list end)
 165                         if prev_list then
 166                                 local last = prev_list.before(range.start, finishof, skip)
 167                                 if last then
 168                                         return (last.finish or last.p and last.start + #last.p) + 1, prev_list
 169                                 else
 170                                         return prev_list.finish, prev_list
 171                                 end
 172                         end
 173                 end,
 174
 175                 finish_up_after = function(range)
 176                         local _, parent = sexp_at(range)
 177                         return parent.d and parent.finish + 1
 178                 end,
 179
 180                 indented_before = function(range)
 181                         return find_before_innermost(parser.tree, range, startof, function(t) return t.indent end)
 182                 end,
 183
 184                 start_float_before = function(range, up_empty_list)
 185                         if up_empty_list then
 186                                 local _, parent = sexp_at(range)
 187                                 if parent.is_empty then
 188                                         return parent.start, parent
 189                                 end
 190                         end
 191                         local node = find_before_innermost(parser.tree, range, startof, function(t, n, _)
 192                                 return not t.d or t.is_empty and n == 1 end)
 193                         return node and node.start, node
 194                 end,
 195
 196                 finish_float_after = function(range, up_empty_list)
 197                         if up_empty_list then
 198                                 local _, parent = sexp_at(range)
 199                                 if parent.is_empty then
 200                                         return parent.finish + 1, parent
 201                                 end
 202                         end
 203                         local node = find_after_innermost(parser.tree, range, finishof, function(t, n, max_n)
 204                                 return not t.d or t.is_empty and n == max_n end)
 205                         return node and node.finish + 1, node
 206                 end,
 207
 208                 start_word_after = function(t, range)
 209                         local newpos = t.start_after(range.start)
 210                         if newpos then
 211                                 local word = t.word_at({start = newpos, finish = newpos})
 212                                 return word and word.start
 213                         else
 214                                 local _, parent, n = sexp_at(range, true)
 215                                 local cur, nxt = parent[n], parent[n + 1]
 216                                 if nxt and is_line_comment(cur) and is_line_comment(nxt) then
 217                                         return nxt.start_after(range.start)
 218                                 end
 219                         end
 220                 end,
 221
 222                 finish_word_after = function(t, range)
 223                         local newpos = t.finish_after(math.max(t.start + #t.d, range.finish))
 224                         if newpos then
 225                                 local word = t.word_at({start = newpos, finish = newpos})
 226                                 return word and word.finish + 1
 227                         else
 228                                 local _, parent, n = sexp_at(range, true)
 229                                 local cur, nxt = parent[n], parent[n + 1]
 230                                 if nxt and is_line_comment(cur) and is_line_comment(nxt) then
 231                                         return nxt.finish_after(range.start)
 232                                 end
 233                         end
 234                 end,
 235
 236                 start_word_before = function(t, range)
 237                         local newpos = t.start_before(range.start)
 238                         if newpos then
 239                                 local word = t.word_at({start = newpos, finish = newpos})
 240                                 return word and word.start
 241                         else
 242                                 local _, parent, n = sexp_at(range, true)
 243                                 local cur, prev = parent[n], parent[n - 1]
 244                                 if prev and is_line_comment(cur) and is_line_comment(prev) then
 245                                         return prev.start_before(range.start)
 246                                 end
 247                         end
 248                 end,
 249
 250                 finish_word_before = function(t, range)
 251                         local newpos = t.finish_before(range.finish)
 252                         if newpos then
 253                                 local word = t.word_at({start = newpos, finish = newpos})
 254                                 return word and word.finish + 1
 255                         else
 256                                 local _, parent, n = sexp_at(range, true)
 257                                 local cur, prev = parent[n], parent[n - 1]
 258                                 if prev and is_line_comment(cur) and is_line_comment(prev) then
 259                                         return prev.finish_before(range.start)
 260                                 end
 261                         end
 262                 end,
 263
 264                 prev_start_wrapped = function(range)
 265                         local node, parent = parser.tree.sexp_at(range)
 266                         if in_quasilist(node, range) then parent = node end
 267                         local pstart = parent.start and (parent.start + (parent.p and #parent.p or 0) + #parent.d)
 268                         local bol = bol_at(range.start)
 269                         local prev_wrapped = (parent.is_list or parent.is_root) and parent.find_before(range,
 270                                 function(t) return t.start < bol and t.finish > bol end,
 271                                 function(t) return t.finish < bol
 272                         end)
 273                         local prev_start = prev_wrapped and prev_wrapped.start or bol
 274                         pstart = pstart or prev_start
 275                         return math.max(pstart, prev_start)
 276                 end,
 277
 278                 next_finish_wrapped = function(range)
 279                         local node, parent = parser.tree.sexp_at(range)
 280                         if in_quasilist(node, range) then parent = node end
 281                         local pfinish = parent.finish and parent.finish + 1 - #parser.opposite[parent.d]
 282                         local eol = eol_at(range.start)
 283                         local next_wrapped = (parent.is_list or parent.is_root) and parent.find_after(range,
 284                                 function(t) return t.start < eol and t.finish > eol end,
 285                                 function(t) return t.start > eol
 286                         end)
 287                         local next_finish = next_wrapped and next_wrapped.finish + 1 or eol
 288                         -- XXX: second return value, to be used for safe line-commenting:
 289                         local next_start_on_line = math.min(pfinish or range.start, next_wrapped and next_wrapped.start or eol)
 290                         return math.min(pfinish or next_finish, next_finish), next_start_on_line < eol and next_start_on_line or nil
 291                 end,
 292
 293                 paragraph_start_before = function(range, prev_line)
 294                         local prev, n = parser.tree.before(range.start, startof, is_comment)
 295                         if not prev_line then
 296                                 return prev and prev.start
 297                         end
 298                         local pprev = n and parser.tree[n - 1]
 299                         local has_eol = pprev and is_line_comment(pprev)
 300                         local adjacent = pprev and prev and prev.start - (pprev.finish + (has_eol and 0 or 1)) <= 1
 301                         return prev and prev.start - ((adjacent or prev.start == 0) and 0 or 1)
 302                 end,
 303
 304                 paragraph_finish_after = function(range, next_line)
 305                         local node = parser.tree.around(range)
 306                         local nxt, n = parser.tree.find_after(node or range, function(t)
 307                                 return not t.is_comment and t.finish > range.finish
 308                         end)
 309                         return nxt and nxt.finish + 1 + (next_line and parser.tree[n + 1] and parser.tree[n + 1].indent and 1 or 0)
 310                 end,
 311
 312                 beginning_of_quasilist = function(range)
 313                         local _, parent = sexp_at(range)
 314                         return parent.start and (parent.start + (parent.p and #parent.p or 0) + #parent.d)
 315                 end,
 316
 317                 end_of_quasilist = function(range)
 318                         local _, parent = sexp_at(range)
 319                         return parent.finish and parent.finish + 1 - #parser.opposite[parent.d]
 320                 end,
 321
 322                 repl_line_begin = function(range)
 323                         local _, parent = parser.tree.sexp_at(range)
 324                         if not parent.is_root then return end
 325                         local prev_indent = parent.find_before(range, function(t) return t.indent end)
 326                         return prev_indent and prev_indent.start
 327                 end,
 328
 329                 wider_than = function(range)
 330                         local node, parent = parser.tree.sexp_at(range)
 331                         if not node and parent.is_root then return end
 332                         local pstart, pfinish
 333                         if in_quasilist(node, range) then
 334                                 parent = node
 335                                 node = node.word_at(range)
 336                         end
 337                         if not parent.is_root then
 338                                 pstart, pfinish = parent.start + (parent.p and #parent.p or 0) + #parent.d,
 339                                         parent.finish + 1 - #parser.opposite[parent.d]
 340                         end
 341                         local same_as_inner = range.start == pstart and range.finish == pfinish
 342                         local same_as_node = node and range.start == node.start and range.finish - 1 == node.finish
 343                         if node and not same_as_node then
 344                                 return node.start, node.finish + 1
 345                         elseif not same_as_inner then
 346                                 return pstart, pfinish
 347                         end
 348                         return parent.start, parent.finish + 1
 349                 end,
 350
 351                 -- opening: nil - bracketed list; false - any quasilist;
 352                 quasilist_at = function(range, opening)
 353                         if opening and opening:match'[%;%"]' then
 354                                 local escaped = escaped_at(range)
 355                                 return escaped and escaped.d:find("^"..opening) and escaped
 356                         else
 357                                 local _, nodes = parser.tree.sexp_path(range)
 358                                 local parent
 359                                 local up = #nodes - 1
 360                                 repeat
 361                                         parent = nodes[up]
 362                                         up = up - 1
 363                                 until not parent or (opening == false or not opening or parent.d == opening)
 364                                 return parent
 365                         end
 366                 end,
 367
 368                 sexp_at = sexp_at,
 369                 escaped_at = escaped_at,
 370                 paragraph_at = parser.tree.around,
 371                 goto_path = parser.tree.goto_path,
 372                 sexp_path = parser.tree.sexp_path,
 373                 find_after = parser.tree.find_after,
 374                 find_before = parser.tree.find_before,
 375         }
 376 end
 377
 378 return M