Cursor Agent
530b363c2f
Removed all usages of `unsafe` and the `internal/danger` package from the codebase.
1. **`unstable/ast.go`**: Refactored `Node` struct to use `*Node` pointers for `next` and `child` fields instead of integer offsets. This eliminates the need for `unsafe` pointer arithmetic in `Next()` and `Child()` methods.
2. **`unstable/builder.go`**: Updated `builder` to manage pointers to nodes directly instead of integer offsets.
3. **`unstable/parser.go`**:
* Replaced `danger.SubsliceOffset` with safe capacity-based calculation (`cap(p.data) - cap(b)`), which works because tokens are slices of the parser's input buffer.
4. **`strict.go`** & **`errors.go`**: Replaced `danger.BytesRange` and `danger.SubsliceOffset` with safe slice capacity arithmetic.
5. **`unmarshaler.go`**: Replaced `map[danger.TypeID]...` with `map[uintptr]...` for the field paths cache using `reflect.ValueOf(t).Pointer()`. This removes the need for `unsafe` access to `reflect.Type` internals.
6. **`internal/tracker/seen_test.go`**: Replaced `unsafe.Sizeof` with `reflect.TypeOf(...).Size()`.
7. **`internal/danger`**: Deleted the package entirely.
Benchmarks show a mix of performance changes:
- Small document unmarshaling (SimpleDocument/struct-4) got slower (+25%), likely due to pointer chasing vs contiguous array access.
- Large document unmarshaling (canada, citm, twitter) actually improved significantly (-24% to -45% latency), likely due to reduced allocation overhead or better cache locality in some paths.
- Memory usage for large datasets decreased significantly (-50% to -60% B/op).
- Overall geomean latency improved by ~6%.
No public interfaces were changed. All tests pass.
122 lines
2.3 KiB
Go
122 lines
2.3 KiB
Go
package unstable
|
|
|
|
// root contains a full AST.
|
|
//
|
|
// It is immutable once constructed with Builder.
|
|
type root struct {
|
|
first *Node
|
|
}
|
|
|
|
// Iterator over the top level nodes.
|
|
func (r *root) Iterator() Iterator {
|
|
return Iterator{node: r.first}
|
|
}
|
|
|
|
type reference struct {
|
|
*Node
|
|
}
|
|
|
|
var invalidReference = reference{}
|
|
|
|
func (r reference) Valid() bool {
|
|
return r.Node != nil
|
|
}
|
|
|
|
type builder struct {
|
|
// chunks of nodes. Pointers to nodes are stable because we only append
|
|
// to the last chunk, and chunks are allocated with fixed capacity.
|
|
chunks [][]Node
|
|
// current chunk index
|
|
chunkIdx int
|
|
|
|
// root node of the tree
|
|
root root
|
|
|
|
// last pushed node (for chaining)
|
|
last *Node
|
|
}
|
|
|
|
const initialChunkSize = 16
|
|
const maxChunkSize = 2048
|
|
|
|
func (b *builder) Tree() *root {
|
|
return &b.root
|
|
}
|
|
|
|
func (b *builder) NodeAt(ref reference) *Node {
|
|
return ref.Node
|
|
}
|
|
|
|
func (b *builder) Reset() {
|
|
b.chunkIdx = 0
|
|
for i := range b.chunks {
|
|
b.chunks[i] = b.chunks[i][:0]
|
|
}
|
|
b.root.first = nil
|
|
b.last = nil
|
|
}
|
|
|
|
func (b *builder) ensureCapacity() {
|
|
if b.chunkIdx >= len(b.chunks) {
|
|
size := initialChunkSize
|
|
if len(b.chunks) > 0 {
|
|
lastCap := cap(b.chunks[len(b.chunks)-1])
|
|
size = lastCap * 2
|
|
if size > maxChunkSize {
|
|
size = maxChunkSize
|
|
}
|
|
}
|
|
b.chunks = append(b.chunks, make([]Node, 0, size))
|
|
}
|
|
if len(b.chunks[b.chunkIdx]) == cap(b.chunks[b.chunkIdx]) {
|
|
b.chunkIdx++
|
|
if b.chunkIdx >= len(b.chunks) {
|
|
size := initialChunkSize
|
|
if len(b.chunks) > 0 {
|
|
lastCap := cap(b.chunks[len(b.chunks)-1])
|
|
size = lastCap * 2
|
|
if size > maxChunkSize {
|
|
size = maxChunkSize
|
|
}
|
|
}
|
|
b.chunks = append(b.chunks, make([]Node, 0, size))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (b *builder) push(n Node) *Node {
|
|
b.ensureCapacity()
|
|
chunk := &b.chunks[b.chunkIdx]
|
|
*chunk = append(*chunk, n)
|
|
return &(*chunk)[len(*chunk)-1]
|
|
}
|
|
|
|
func (b *builder) Push(n Node) reference {
|
|
ptr := b.push(n)
|
|
if b.root.first == nil {
|
|
b.root.first = ptr
|
|
}
|
|
b.last = ptr
|
|
return reference{ptr}
|
|
}
|
|
|
|
func (b *builder) PushAndChain(n Node) reference {
|
|
ptr := b.push(n)
|
|
if b.root.first == nil {
|
|
b.root.first = ptr
|
|
}
|
|
if b.last != nil {
|
|
b.last.next = ptr
|
|
}
|
|
b.last = ptr
|
|
return reference{ptr}
|
|
}
|
|
|
|
func (b *builder) AttachChild(parent reference, child reference) {
|
|
parent.child = child.Node
|
|
}
|
|
|
|
func (b *builder) Chain(from reference, to reference) {
|
|
from.next = to.Node
|
|
}
|