Method decode

internal/api/encoder/decoder.go:138–180

()

}

func (d *astDecoder) decode() (*ast.Node, error) {
	if d.nodeCount < 2 {
		return nil, errors.New("no nodes to decode")
	}

	d.nodes = make([]*ast.Node, d.nodeCount)
	d.nodeLists = make([]*ast.NodeList, d.nodeCount)
	// Pre-allocate arena for NodeList child slices. Each node can appear as a
	// child at most once, so nodeCount is an upper bound on total child pointers.
	d.nodeArena = make([]*ast.Node, 0, d.nodeCount)

	// Process bottom-up so children exist before parents.
	for i := d.nodeCount - 1; i >= 1; i-- {
		kind := d.nodeField(i, NodeOffsetKind)
		pos := d.nodeField(i, NodeOffsetPos)
		end := d.nodeField(i, NodeOffsetEnd)
		data := d.nodeField(i, NodeOffsetData)
		childIndices := d.collectChildren(i)

		if kind == SyntaxKindNodeList {
			childNodes := d.allocNodeSlice(len(childIndices))
			for _, ci := range childIndices {
				if d.nodes[ci] != nil {
					childNodes = append(childNodes, d.nodes[ci])
				}
			}
			nl := d.factory.NewNodeList(childNodes)
			nl.Loc = core.NewTextRange(int(pos), int(end))
			d.nodeLists[i] = nl
			continue
		}

		node, err := d.createNode(ast.Kind(kind), data, childIndices)
		if err != nil {
			return nil, fmt.Errorf("at node %d (kind %v): %w", i, ast.Kind(kind), err)
		}
		node.Loc = core.NewTextRange(int(pos), int(end))
		node.Flags = ast.NodeFlags(d.nodeField(i, NodeOffsetFlags))
		d.nodes[i] = node
	}

	return d.nodes[1], nil
}

// getModifierList creates a *ast.ModifierList from a child index that is a NodeList.
func (d *astDecoder) getModifierList(ci int) *ast.ModifierList {