exp_operation.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
use json = "../json"

class val ExpOperation is NodeData
  """A binary infix operation expression, or a unary prefix operation."""

  let lhs:
    ( NodeWith[TypeType]
    | NodeWith[Expression]
    | NodeWith[Identifier]
    | None)
  let op: (NodeWith[Keyword] | NodeWith[Token])
  let rhs: (NodeWith[TypeType] | NodeWith[Expression] | NodeWith[Identifier])
  let partial: Bool

  new val create(
    lhs':
      ( NodeWith[TypeType]
      | NodeWith[Expression]
      | NodeWith[Identifier]
      | None),
    op': (NodeWith[Keyword] | NodeWith[Token]),
    rhs': (NodeWith[TypeType] | NodeWith[Expression] | NodeWith[Identifier]),
    partial': Bool = false)
  =>
    lhs = lhs'
    op = op'
    rhs = rhs'
    partial = partial'

  fun name(): String => "ExpOperation"

  fun val clone(updates: ChildUpdateMap): NodeData =>
    let lhs' =
      match lhs
      | let lhs_type: NodeWith[TypeType] =>
        _map_with[TypeType](lhs_type, updates)
      | let lhs_exp: NodeWith[Expression] =>
        _map_with[Expression](lhs_exp, updates)
      | let lhs_id: NodeWith[Identifier] =>
        _map_with[Identifier](lhs_id, updates)
      end
    let op' =
      match op
      | let op_kw: NodeWith[Keyword] =>
        _map_with[Keyword](op_kw, updates)
      | let op_tok: NodeWith[Token] =>
        _map_with[Token](op_tok, updates)
      end
    let rhs' =
      match rhs
      | let rhs_type: NodeWith[TypeType] =>
        _map_with[TypeType](rhs_type, updates)
      | let rhs_exp: NodeWith[Expression] =>
        _map_with[Expression](rhs_exp, updates)
      | let rhs_id: NodeWith[Identifier] =>
        _map_with[Identifier](rhs_id, updates)
      end
    ExpOperation(lhs', op', rhs', partial)

  fun add_json_props(node: Node box, props: Array[(String, json.Item)]) =>
    match lhs
    | let lhs': Node =>
      props.push(("lhs", node.child_ref(lhs')))
    end
    props.push(("op", node.child_ref(op)))
    props.push(("rhs", node.child_ref(rhs)))
    if partial then
      props.push(("partial", partial))
    end

primitive ParseExpOperation
  fun apply(obj: json.Object val, children: NodeSeq): (ExpOperation | String) =>
    let lhs =
      match ParseNode._get_child(
        obj,
        children,
        "lhs",
        "ExpOperation.lhs must be (TypeType | Expression | Identifier)",
        false)
      | let tt: NodeWith[TypeType] =>
        tt
      | let ex: NodeWith[Expression] =>
        ex
      | let id: NodeWith[Identifier] =>
        id
      | let err: String =>
        return err
      end
    let op =
      match ParseNode._get_child(
        obj,
        children,
        "op",
        "ExpOperation.op must be (Keyword | Token)")
      | let kw: NodeWith[Keyword] =>
        kw
      | let tk: NodeWith[Token] =>
        tk
      | let err: String =>
        return err
      else
        return "ExpOperation.op must be (Keyword | Token)"
      end
    let rhs =
      match ParseNode._get_child(
        obj,
        children,
        "rhs",
        "ExpOperation.rhs must be (TypeType | Expression | Identifier)")
      | let tt: NodeWith[TypeType] =>
        tt
      | let ex: NodeWith[Expression] =>
        ex
      | let id: NodeWith[Identifier] =>
        id
      | let err: String =>
        return err
      else
        return "ExpOperation.rhs must be (TypeType | Expression | Identifier)"
      end
    let partial =
      match try obj("partial")? end
      | let bool: Bool =>
        bool
      | let item: json.Item =>
        return "ExpOperation.partial must be a boolean"
      else
        false
      end
    ExpOperation(lhs, op, rhs, partial)