src_info.pony

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
use json = "../json"
use parser = "../parser"

primitive Inherited
primitive Reified
primitive Desugared

type SrcDerivation is (Inherited | Reified | Desugared)

class val SrcInfo is Equatable[SrcInfo]
  """
    Source file span information.
    `locator`: an identifier for a source file or other source of code.
    `start`: the start location of the span.
    `next`: the location immediately after the span.
    `derived_from`: how this span is derived from original source.
  """

  let locator: parser.Locator
  let start: (parser.Loc | None)
  let next: (parser.Loc | None)
  let line: (USize | None)
  let column: (USize | None)
  let next_line: (USize | None)
  let next_column: (USize | None)
  let derived_from: ((SrcDerivation, Node) | None)

  new val create(
    locator': String,
    start': (parser.Loc | None) = None,
    next': (parser.Loc | None) = None,
    line': (USize | None) = None,
    column': (USize | None) = None,
    next_line': (USize | None) = None,
    next_column': (USize | None) = None,
    derived_from': ((SrcDerivation, Node)  | None) = None)
  =>
    locator = locator'
    start = start'
    next = next'
    line = line'
    column = column'
    next_line = next_line'
    next_column = next_column'
    derived_from = derived_from'

  new val from(
    orig: SrcInfo,
    locator': (parser.Locator | None) = None,
    start': (parser.Loc | None) = None,
    next': (parser.Loc | None) = None,
    line': (USize | None) = None,
    column': (USize | None) = None,
    next_line': (USize | None) = None,
    next_column': (USize | None) = None,
    derived_from': ((SrcDerivation, Node) | None) = None)
  =>
    locator =
      match locator'
      | let l: parser.Locator => l
      else orig.locator
      end
    start =
      match start'
      | let s: parser.Loc => s
      else orig.start
      end
    next =
      match next'
      | let n: parser.Loc => n
      else orig.next
      end
    line =
      match line'
      | let n: USize => n
      else orig.line
      end
    column =
      match column'
      | let n: USize => n
      else orig.column
      end
    next_line =
      match next_line'
      | let n: USize => n
      else orig.next_line
      end
    next_column =
      match next_column'
      | let n: USize => n
      else orig.next_column
      end
    derived_from =
      match derived_from'
      | (let sd: SrcDerivation, let n: Node) => (sd, n)
      else orig.derived_from
      end

  fun eq(other: box->SrcInfo): Bool =>
    if locator != other.locator then
      return false
    end
    match (start, next, other.start, other.next)
    | (let s': parser.Loc, let n': parser.Loc,
       let os': parser.Loc, let on': parser.Loc)
    =>
      return (s' == os') and (n' == on')
    end
    match (line, column, other.line, other.column)
    | (let l': USize, let c': USize, let ol': USize, let oc': USize) =>
      if (l' == ol') and (c' == oc') then
        match (next_line, next_column, other.next_line, other.next_column)
        | (let nl': USize, let nc': USize, let onl': USize, let onc': USize) =>
          (nl' == onl') and (nc' == onc')
        else
          true
        end
      end
    end
    false

  fun ne(other: box->SrcInfo): Bool =>
    not this.eq(other)

  fun length(): USize =>
    match (start, next)
    | (let start': parser.Loc, let next': parser.Loc) =>
      var len: USize = 0
      var cur = start'
      while (cur != next') and cur.has_value() do
        cur = cur.next()
        len = len + 1
      end
      len
    else
      0
    end

  fun literal_source(post: (NodeSeq | None) = None): String =>
    match (start, next)
    | (let start': parser.Loc, let next': parser.Loc) =>
      let next'' =
        match try (post as NodeSeq)(0)?.src_info().start end
        | let loc: parser.Loc =>
          loc
        else
          next
        end

        // match post
        // | let seq: NodeSeq if seq.size() > 0 =>
        //   match try seq(0)?.src_info() end
        //   | let si: SrcInfo =>
        //     match si.start
        //     | let loc: parser.Loc =>
        //       loc
        //     else
        //       next
        //     end
        //   else
        //     next
        //   end
        // else
        //   next
        // end
      recover val String .> concat(start'.values(next'')) end
    else
      ""
    end