Use the new ASDL_TYPE reflection API.

- In format.py
- In encode.py (oheap)

Remove unused code in AbbreviateNodes that used the old API.

The addition of the 'spids' field means that this abbreviation never got
applied.  I never noticed, so let's just get rid of the code.

Also:

- One more spec test passes, because of name validation in 'export'.

asdl/asdl_.py

@@ -106,8 +106,15 @@ def __init__(self, module, app_types=None):
    # TODO: Fold this in
    self.types.update(DESCRIPTORS_BY_NAME)

  def Get(self, type_name):
    return self.types[type_name]
  def Get(self, field):
    t = self.types[field.type]
    if field.seq:
      return ArrayType(t)

    if field.opt:
      return MaybeType(t)

    return t

  def __repr__(self):
    return repr(self.types)
@@ -116,7 +123,7 @@ def __repr__(self):
def _CheckFieldsAndWire(typ, type_lookup):
  for f in typ.fields:
    # Will fail if it doesn't exist
    _ = type_lookup.Get(f.type)
    _ = type_lookup.Get(f)
  typ.type_lookup = type_lookup  # wire it for lookup


@@ -202,7 +209,7 @@ class _CompoundType(AST):

    def __init__(self, fields):
        self.fields = fields or []
        self.field_lookup = {f.name: f.type for f in self.fields}
        self.field_lookup = {f.name: f for f in self.fields}
        self.type_lookup = None  # for runtime reflection

    def GetFields(self):
@@ -211,8 +218,8 @@ def GetFields(self):
          yield field_name, self.LookupFieldType(field_name)

    def LookupFieldType(self, field_name):
        type_name = self.field_lookup[field_name]
        return self.type_lookup.Get(type_name)
        field = self.field_lookup[field_name]
        return self.type_lookup.Get(field)

asdl/encode.py

@@ -217,8 +217,7 @@ def EncodeObj(obj, enc, out):
  if isinstance(obj.DESCRIPTOR, asdl.Constructor):
    enc.Tag(obj.tag, this_chunk)

  for name in obj.FIELDS:  # encode in order
    desc = obj.DESCRIPTOR_LOOKUP[name]
  for name, desc in obj.ASDL_TYPE.GetFields():  # encode in order
    field_val = getattr(obj, name)

    # TODO:

asdl/format.py

@@ -230,14 +230,15 @@ def __repr__(self):
class _ColoredString:
  """Node for pretty-printing."""
  def __init__(self, s, str_type):
    assert isinstance(s, str), s
    self.s = s
    self.str_type = str_type

  def __repr__(self):
    return '<_ColoredString %s %s>' % (self.s, self.str_type)


def MakeFieldSubtree(obj, field_name, abbrev_hook, omit_empty=True):
def MakeFieldSubtree(obj, field_name, desc, abbrev_hook, omit_empty=True):
  try:
    field_val = getattr(obj, field_name)
  except AttributeError:
@@ -246,7 +247,6 @@ def MakeFieldSubtree(obj, field_name, abbrev_hook, omit_empty=True):
    raise AssertionError(
        '%s is missing field %r' % (obj.__class__, field_name))

  desc = obj.DESCRIPTOR_LOOKUP[field_name]
  if isinstance(desc, asdl.IntType) or isinstance(desc, asdl.BoolType):
    out_val = _ColoredString(str(field_val), _OTHER_LITERAL)

@@ -298,8 +298,8 @@ def MakeTree(obj, abbrev_hook=None, omit_empty=True):
    out_node = _Obj(obj.__class__.__name__)
    fields = out_node.fields

    for field_name in obj.FIELDS:
      out_val = MakeFieldSubtree(obj, field_name, abbrev_hook,
    for field_name, desc in obj.ASDL_TYPE.GetFields():
      out_val = MakeFieldSubtree(obj, field_name, desc, abbrev_hook,
                                 omit_empty=omit_empty)

      if out_val is not None:

asdl/py_meta.py

@@ -248,26 +248,19 @@ def _MakeFieldDescriptors(module, fields, type_lookup, add_spids=True):
  desc_lookup = {}
  for f in fields:
    # Lookup order: primitive, defined in the ASDL file, passed by the app
    desc = type_lookup.Get(f.type)

    # Wrap descriptor here.  Then we can type check.
    # And then encode too.
    assert not (f.opt and f.seq), f
    if f.opt:
      desc = asdl.MaybeType(desc)

    if f.seq:
      desc = asdl.ArrayType(desc)
    desc = type_lookup.Get(f)

    desc_lookup[f.name] = desc

  field_names = [f.name for f in fields]

  # Add 'int* spids' if requested.
  # TODO: Use ASDL attributes for this!
  if add_spids:
    field_names.append('spids')
    desc_lookup['spids'] = asdl.ArrayType(asdl.IntType())

  # TODO: remove these
  class_attr = {
      'FIELDS': field_names,
      'DESCRIPTOR_LOOKUP': desc_lookup,

asdl/run.sh

@@ -34,14 +34,15 @@ asdl-py() {
}

smoke-test() {
  local arith_expr=${1:-"2 + 3 * 4"}
  # Print Schema (asdl_.py, py_meta.py)
  asdl-py asdl/arith.asdl

  # Parse real values and pretty print (format.py)
  asdl-arith-format '1+2*3'
  asdl-arith-format "$arith_expr"

  # encode.py
  arith-demo
  asdl-arith-oheap "$arith_expr"
}

asdl-cpp() {
@@ -125,12 +126,13 @@ build-demo() {
  chmod +x $bin
}

arith-demo() {
asdl-arith-oheap() {
  local arith_expr=${1:-"1 + 2 * 3"}
  local name=arith
  local data=_tmp/${name}.bin

  # Write a binary
  asdl-arith-encode '1 + 2 * 3' $data
  asdl-arith-encode "$arith_expr" $data

  local bin=_tmp/${name}_demo 

osh/ast_.py

@@ -102,17 +102,6 @@ def AbbreviateNodes(obj, node):
      # Well actually then the printer needs to recursively handle it
      node.unnamed_fields.append(MakeTree(w, AbbreviateNodes))

  else:
    # Do generic abbreviation here if none of the specific ones applied.
    field_names = getattr(obj, 'FIELDS', None)
    if field_names is not None and len(field_names) == 1:
      field_name = field_names[0]
      actual_desc = obj.DESCRIPTOR_LOOKUP[field_name]
      if not isinstance(actual_desc, asdl.ArrayType):  # Arrays can't be abbreviated
        node.abbrev = True
        out_val = fmt.FormatField(obj, field_name, AbbreviateNodes)
        node.unnamed_fields.append(out_val)


def PrettyPrint(node, f=sys.stdout):
  ast_f = fmt.DetectConsoleOutput(f)

test/spec.sh

@@ -333,7 +333,7 @@ explore-parsing() {
}

parse-errors() {
  sh-spec spec/parse-errors.test.sh --osh-failures-allowed 4 \
  sh-spec spec/parse-errors.test.sh --osh-failures-allowed 3 \
    ${REF_SHELLS[@]} $OSH "$@"
}