Add benchmarks for experimental and make the compiler 2x faster

Makefile

@@ -59,10 +59,10 @@ clean: ## Delete intermediate build artifacts
 test: build ## Run unit tests
 	$(GO) test -race -cover ./...
 	$(GO) test -tags protolegacy ./...
-	cd internal/benchmarks && SKIP_DOWNLOAD_GOOGLEAPIS=true $(GO) test -race -cover ./...
 
 .PHONY: benchmarks
 benchmarks: build ## Run benchmarks
+	$(GO) test -bench -benchmem -v ./experimental/benchmark
 	cd internal/benchmarks && $(GO) test -bench=. -benchmem -v ./...
 
 .PHONY: build

experimental/ast/commas.go

@@ -66,14 +66,14 @@ func (c commas[T, _]) AppendComma(value T, comma token.Token) {
 }
 
 func (c commas[T, _]) InsertComma(n int, value T, comma token.Token) {
-	c.file.Nodes().panicIfNotOurs(comma)
+	c.file.Nodes().panicIfNotOurs(comma.Context())
 	v := c.SliceInserter.Unwrap(n, value)
 	v.Comma = comma.ID()
 
 	*c.Slice = slices.Insert(*c.Slice, n, v)
 }
 
 func (c commas[T, _]) SetComma(n int, comma token.Token) {
-	c.file.Nodes().panicIfNotOurs(comma)
+	c.file.Nodes().panicIfNotOurs(comma.Context())
 	(*c.SliceInserter.Slice)[n].Comma = comma.ID()
 }

experimental/ast/decl.go

@@ -124,18 +124,24 @@ func (d DeclAny) AsRange() DeclRange {
 
 // Span implements [source.Spanner].
 func (d DeclAny) Span() source.Span {
-	// At most one of the below will produce a non-zero decl, and that will be
-	// the span selected by source.Join. If all of them are zero, this produces
-	// the zero span.
-	return source.Join(
-		d.AsEmpty(),
-		d.AsSyntax(),
-		d.AsPackage(),
-		d.AsImport(),
-		d.AsDef(),
-		d.AsBody(),
-		d.AsRange(),
-	)
+	switch d.Kind() {
+	case DeclKindBody:
+		return d.AsBody().Span()
+	case DeclKindDef:
+		return d.AsDef().Span()
+	case DeclKindEmpty:
+		return d.AsEmpty().Span()
+	case DeclKindImport:
+		return d.AsImport().Span()
+	case DeclKindPackage:
+		return d.AsPackage().Span()
+	case DeclKindRange:
+		return d.AsRange().Span()
+	case DeclKindSyntax:
+		return d.AsSyntax().Span()
+	default:
+		return source.Span{}
+	}
 }
 
 func (DeclKind) DecodeDynID(lo, _ int32) DeclKind {

experimental/ast/decl_body.go

@@ -108,7 +108,7 @@ func (d DeclBody) Decls() seq.Inserter[DeclAny] {
 			return id.WrapDyn(d.Context(), id.NewDyn(k, p))
 		},
 		func(_ int, d DeclAny) (DeclKind, id.ID[DeclAny]) {
-			d.Context().Nodes().panicIfNotOurs(d)
+			d.Context().Nodes().panicIfNotOurs(d.Context())
 			return d.ID().Kind(), d.ID().Value()
 		},
 	)

experimental/ast/decl_def.go

@@ -520,15 +520,15 @@ func (d DeclDef) Span() source.Span {
 		return source.Span{}
 	}
 
-	return source.Join(
-		d.Type(),
-		d.Name(),
-		d.Signature(),
-		d.Equals(),
-		d.Value(),
-		d.Options(),
-		d.Body(),
-		d.Semicolon(),
+	return source.JoinSpans(
+		d.Type().Span(),
+		d.Name().Span(),
+		d.Signature().Span(),
+		d.Equals().Span(),
+		d.Value().Span(),
+		d.Options().Span(),
+		d.Body().Span(),
+		d.Semicolon().Span(),
 	)
 }
 

experimental/ast/decl_file.go

@@ -323,7 +323,7 @@ func (d DeclImport) ModifierTokens() seq.Inserter[token.Token] {
 	return seq.NewSliceInserter(&d.Raw().modifiers,
 		func(_ int, e token.ID) token.Token { return id.Wrap(d.Context().Stream(), e) },
 		func(_ int, t token.Token) token.ID {
-			d.Context().Nodes().panicIfNotOurs(t)
+			d.Context().Nodes().panicIfNotOurs(t.Context())
 			return t.ID()
 		},
 	)

experimental/ast/decl_range.go

@@ -93,7 +93,7 @@ func (d DeclRange) Ranges() Commas[ExprAny] {
 				return id.WrapDyn(d.Context(), c.Value)
 			},
 			func(_ int, e ExprAny) withComma[id.Dyn[ExprAny, ExprKind]] {
-				d.Context().Nodes().panicIfNotOurs(e)
+				d.Context().Nodes().panicIfNotOurs(e.Context())
 				return withComma[id.Dyn[ExprAny, ExprKind]]{Value: e.ID()}
 			},
 		),

experimental/ast/expr.go

@@ -143,18 +143,26 @@ func (e ExprAny) AsField() ExprField {
 
 // Span implements [source.Spanner].
 func (e ExprAny) Span() source.Span {
-	// At most one of the below will produce a non-nil type, and that will be
-	// the span selected by source.Join. If all of them are nil, this produces
-	// the nil span.
-	return source.Join(
-		e.AsLiteral(),
-		e.AsPath(),
-		e.AsPrefixed(),
-		e.AsRange(),
-		e.AsArray(),
-		e.AsDict(),
-		e.AsField(),
-	)
+	switch e.Kind() {
+	case ExprKindArray:
+		return e.AsArray().Span()
+	case ExprKindDict:
+		return e.AsDict().Span()
+	case ExprKindError:
+		return e.AsError().Span()
+	case ExprKindField:
+		return e.AsField().Span()
+	case ExprKindLiteral:
+		return e.AsLiteral().Span()
+	case ExprKindPath:
+		return e.AsPath().Span()
+	case ExprKindPrefixed:
+		return e.AsPrefixed().Span()
+	case ExprKindRange:
+		return e.AsRange().Span()
+	default:
+		return source.Span{}
+	}
 }
 
 // ExprError represents an unrecoverable parsing error in an expression context.

experimental/ast/expr_array.go

@@ -69,7 +69,7 @@ func (e ExprArray) Elements() Commas[ExprAny] {
 				return id.WrapDyn(e.Context(), c.Value)
 			},
 			func(_ int, e ExprAny) withComma[id.Dyn[ExprAny, ExprKind]] {
-				e.Context().Nodes().panicIfNotOurs(e)
+				e.Context().Nodes().panicIfNotOurs(e.Context())
 				return withComma[id.Dyn[ExprAny, ExprKind]]{Value: e.ID()}
 			},
 		),

experimental/ast/expr_dict.go

@@ -73,7 +73,7 @@ func (e ExprDict) Elements() Commas[ExprField] {
 				return id.Wrap(e.Context(), c.Value)
 			},
 			func(_ int, e ExprField) withComma[id.ID[ExprField]] {
-				e.Context().Nodes().panicIfNotOurs(e)
+				e.Context().Nodes().panicIfNotOurs(e.Context())
 				return withComma[id.ID[ExprField]]{Value: e.ID()}
 			},
 		),