@smoothbricks/lmao-ttsc 0.0.0-bootstrap.0 → 0.1.6

package/plugin/optimization.go

@@ -0,0 +1,462 @@
+package main
+
+import (
+	"sort"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+const (
+	runtimeHintTag      uint32 = 1 << 16
+	runtimeHintLog      uint32 = 1 << 17
+	runtimeHintFF       uint32 = 1 << 18
+	runtimeHintSpan     uint32 = 1 << 19
+	runtimeHintResult   uint32 = 1 << 20
+	runtimeHintScope    uint32 = 1 << 21
+	runtimeHintDeps     uint32 = 1 << 22
+	runtimeHintAnalyzed uint32 = 1 << 23
+)
+
+var contextCapability = map[string]uint32{
+	"tag": runtimeHintTag, "log": runtimeHintLog, "ff": runtimeHintFF,
+	"span": runtimeHintSpan, "spanSync": runtimeHintSpan,
+	"ok": runtimeHintResult, "err": runtimeHintResult,
+	"scope": runtimeHintScope, "setScope": runtimeHintScope, "deps": runtimeHintDeps,
+}
+
+type opCompileAnalysis struct {
+	runtimeHint    uint32
+	logTemplateIds []string
+}
+
+type hintRewrite struct {
+	call    *shimast.CallExpression
+	hints   map[string]opCompileAnalysis
+	single  opCompileAnalysis
+	isGroup bool
+}
+
+const maxLogTemplateID = 0xffff
+
+func functionParts(node *shimast.Node) (params *shimast.ParameterList, body *shimast.Node, async bool, ok bool) {
+	switch node.Kind {
+	case shimast.KindArrowFunction:
+		fn := node.AsArrowFunction()
+		return fn.Parameters, fn.Body, node.ModifierFlags()&shimast.ModifierFlagsAsync != 0, true
+	case shimast.KindFunctionExpression:
+		fn := node.AsFunctionExpression()
+		return fn.Parameters, fn.Body, node.ModifierFlags()&shimast.ModifierFlagsAsync != 0, true
+	case shimast.KindMethodDeclaration:
+		fn := node.AsMethodDeclaration()
+		return fn.Parameters, fn.Body, node.ModifierFlags()&shimast.ModifierFlagsAsync != 0, true
+	default:
+		return nil, nil, false, false
+	}
+}
+
+func isNestedFunction(node *shimast.Node) bool {
+	switch node.Kind {
+	case shimast.KindArrowFunction, shimast.KindFunctionExpression, shimast.KindFunctionDeclaration,
+		shimast.KindMethodDeclaration, shimast.KindGetAccessor, shimast.KindSetAccessor, shimast.KindConstructor:
+		return true
+	default:
+		return false
+	}
+}
+
+func isLoop(node *shimast.Node) bool {
+	switch node.Kind {
+	case shimast.KindForStatement, shimast.KindForInStatement, shimast.KindForOfStatement,
+		shimast.KindWhileStatement, shimast.KindDoStatement:
+		return true
+	default:
+		return false
+	}
+}
+
+// analyzeOpFunction is intentionally closed-world. A hint is emitted only when
+// every use of the context parameter is a direct access to a known capability.
+func analyzeOpFunction(fn *shimast.Node) uint32 {
+	params, body, _, ok := functionParts(fn)
+	if !ok || params == nil || len(params.Nodes) == 0 || body == nil {
+		return 0
+	}
+	first := params.Nodes[0]
+	if first.Kind != shimast.KindParameter || first.Name() == nil || first.Name().Kind != shimast.KindIdentifier {
+		return 0
+	}
+	ctxName := shimast.NodeText(first.Name())
+	if ctxName == "" {
+		return 0
+	}
+
+	valid := true
+	capacityKnown := true
+	capacity := uint32(2) // rows 0 (tags) and 1 (terminal result)
+	caps := uint32(0)
+	var visit func(*shimast.Node, bool)
+	visit = func(node *shimast.Node, root bool) {
+		if node == nil || !valid {
+			return
+		}
+		if !root && isNestedFunction(node) {
+			valid = false
+			return
+		}
+		if isLoop(node) {
+			capacityKnown = false
+		}
+		if node.Kind == shimast.KindIdentifier && shimast.NodeText(node) == ctxName {
+			parent := node.Parent
+			if parent == nil || parent.Kind != shimast.KindPropertyAccessExpression {
+				valid = false
+				return
+			}
+			pa := parent.AsPropertyAccessExpression()
+			if pa.Expression != node || pa.Name() == nil {
+				valid = false
+				return
+			}
+			name := shimast.NodeText(pa.Name())
+			capability, recognized := contextCapability[name]
+			if !recognized || !isClosedWorldCapabilityUse(parent, name) {
+				valid = false
+				return
+			}
+			caps |= capability
+		}
+		if node.Kind == shimast.KindCallExpression {
+			call := node.AsCallExpression()
+			if call.Expression.Kind == shimast.KindPropertyAccessExpression {
+				method := call.Expression.AsPropertyAccessExpression()
+				if logMethods[shimast.NodeText(method.Name())] && method.Expression.Kind == shimast.KindPropertyAccessExpression {
+					logAccess := method.Expression.AsPropertyAccessExpression()
+					if shimast.NodeText(logAccess.Name()) == "log" && logAccess.Expression.Kind == shimast.KindIdentifier && shimast.NodeText(logAccess.Expression) == ctxName {
+						if capacityKnown && capacity < 0xffff {
+							capacity++
+						} else {
+							capacityKnown = false
+						}
+					}
+				}
+			}
+		}
+		node.ForEachChild(func(child *shimast.Node) bool {
+			visit(child, false)
+			return !valid
+		})
+	}
+	visit(body, true)
+	if !valid {
+		return 0
+	}
+	if !capacityKnown {
+		capacity = 0
+	}
+	return runtimeHintAnalyzed | caps | capacity
+}
+
+func literalLogMessage(node *shimast.Node) (string, bool) {
+	if node == nil {
+		return "", false
+	}
+	switch node.Kind {
+	case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+		return shimast.NodeText(node), true
+	default:
+		return "", false
+	}
+}
+
+// analyzeOpCompileMetadata runs against the untouched tree. It assigns IDs in
+// lexical order and records the exact call nodes consumed later by the emitter.
+func (t *fileTransformer) analyzeOpCompileMetadata(fn *shimast.Node) opCompileAnalysis {
+	analysis := opCompileAnalysis{runtimeHint: analyzeOpFunction(fn)}
+	params, body, _, ok := functionParts(fn)
+	if !ok || params == nil || len(params.Nodes) == 0 || body == nil {
+		return analysis
+	}
+	first := params.Nodes[0]
+	if first.Kind != shimast.KindParameter || first.Name() == nil || first.Name().Kind != shimast.KindIdentifier {
+		return analysis
+	}
+	contextName := shimast.NodeText(first.Name())
+	idsByMessage := map[string]uint16{}
+	var visit func(*shimast.Node)
+	visit = func(node *shimast.Node) {
+		if node == nil {
+			return
+		}
+		if isNestedFunction(node) {
+			return
+		}
+		if node.Kind == shimast.KindCallExpression {
+			call := node.AsCallExpression()
+			if len(call.Arguments.Nodes) == 1 && call.Expression.Kind == shimast.KindPropertyAccessExpression {
+				method := call.Expression.AsPropertyAccessExpression()
+				logNode := method.Expression
+				if logMethods[shimast.NodeText(method.Name())] && logNode.Kind == shimast.KindPropertyAccessExpression {
+					logAccess := logNode.AsPropertyAccessExpression()
+					if shimast.NodeText(logAccess.Name()) == "log" && logAccess.Expression.Kind == shimast.KindIdentifier &&
+						shimast.NodeText(logAccess.Expression) == contextName {
+						logType := t.checker.GetTypeAtLocation(logNode)
+						if logType != nil && isSpanLoggerType(t.checker, logType) {
+							if message, literal := literalLogMessage(call.Arguments.Nodes[0]); literal {
+								id, exists := idsByMessage[message]
+								if !exists && len(analysis.logTemplateIds) < maxLogTemplateID {
+									analysis.logTemplateIds = append(analysis.logTemplateIds, message)
+									id = uint16(len(analysis.logTemplateIds))
+									idsByMessage[message] = id
+									exists = true
+								}
+								if exists {
+									t.logTemplateIDs[call] = id
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		node.ForEachChild(func(child *shimast.Node) bool {
+			visit(child)
+			return false
+		})
+	}
+	visit(body)
+	return analysis
+}
+
+func isClosedWorldCapabilityUse(access *shimast.Node, name string) bool {
+	parent := access.Parent
+	switch name {
+	case "log", "tag":
+		if parent == nil || parent.Kind != shimast.KindPropertyAccessExpression || parent.AsPropertyAccessExpression().Expression != access {
+			return false
+		}
+		if name == "log" && !logMethods[shimast.NodeText(parent.AsPropertyAccessExpression().Name())] {
+			return false
+		}
+		grandparent := parent.Parent
+		return grandparent != nil && grandparent.Kind == shimast.KindCallExpression && grandparent.AsCallExpression().Expression == parent
+	case "ff":
+		if parent != nil && parent.Kind == shimast.KindCallExpression && parent.AsCallExpression().Expression == access {
+			return true
+		}
+		if parent == nil || parent.Kind != shimast.KindPropertyAccessExpression || parent.AsPropertyAccessExpression().Expression != access {
+			return false
+		}
+		grandparent := parent.Parent
+		return grandparent != nil && grandparent.Kind == shimast.KindCallExpression && grandparent.AsCallExpression().Expression == parent
+	case "span", "spanSync", "ok", "err", "setScope":
+		return parent != nil && parent.Kind == shimast.KindCallExpression && parent.AsCallExpression().Expression == access
+	case "deps", "scope":
+		return parent != nil && parent.Kind == shimast.KindPropertyAccessExpression && parent.AsPropertyAccessExpression().Expression == access
+	default:
+		return false
+	}
+}
+
+func literalPropertyName(node *shimast.Node) (string, bool) {
+	if node == nil {
+		return "", false
+	}
+	switch node.Kind {
+	case shimast.KindIdentifier, shimast.KindStringLiteral, shimast.KindNumericLiteral:
+		return shimast.NodeText(node), true
+	default:
+		return "", false
+	}
+}
+
+func collectDefineOpsHints(t *fileTransformer, object *shimast.ObjectLiteralExpression) map[string]opCompileAnalysis {
+	hints := map[string]opCompileAnalysis{}
+	for _, prop := range object.Properties.Nodes {
+		if prop.Name() == nil {
+			continue
+		}
+		key, named := literalPropertyName(prop.Name())
+		if !named {
+			continue
+		}
+		switch prop.Kind {
+		case shimast.KindPropertyAssignment:
+			initializer := prop.AsPropertyAssignment().Initializer
+			if _, _, _, ok := functionParts(initializer); ok {
+				hints[key] = t.analyzeOpCompileMetadata(initializer)
+			}
+		case shimast.KindMethodDeclaration:
+			hints[key] = t.analyzeOpCompileMetadata(prop)
+		}
+	}
+	return hints
+}
+
+func isLmaoDeclarationNode(declaration *shimast.Node) bool {
+	if declaration == nil {
+		return false
+	}
+	if source := shimast.GetSourceFileOfNode(declaration); source != nil {
+		fileName := strings.ReplaceAll(source.FileName(), "\\", "/")
+		if strings.HasPrefix(fileName, "packages/lmao/") || strings.Contains(fileName, "/packages/lmao/") || strings.Contains(fileName, "/node_modules/@smoothbricks/lmao/") {
+			return true
+		}
+	}
+	for current := declaration; current != nil; current = current.Parent {
+		if current.Kind == shimast.KindModuleDeclaration && current.Name() != nil && shimast.NodeText(current.Name()) == "@smoothbricks/lmao" {
+			return true
+		}
+	}
+	return false
+}
+
+func isNamedType(chk *shimchecker.Checker, node *shimast.Node, name string) bool {
+	typ := chk.GetTypeAtLocation(node)
+	if typ == nil {
+		return false
+	}
+	if sym := shimchecker.Type_getTypeNameSymbol(typ); sym != nil && sym.Name == name {
+		return true
+	}
+	return strings.HasPrefix(chk.TypeToString(typ), name+"<")
+}
+
+func isNamedLmaoType(chk *shimchecker.Checker, node *shimast.Node, name string) bool {
+	typ := chk.GetTypeAtLocation(node)
+	if typ == nil {
+		return false
+	}
+	sym := shimchecker.Type_getTypeNameSymbol(typ)
+	if sym == nil || sym.Name != name {
+		return false
+	}
+	for _, declaration := range sym.Declarations {
+		if isLmaoDeclarationNode(declaration) {
+			return true
+		}
+	}
+	return false
+}
+
+func hasLmaoCallProvenance(chk *shimchecker.Checker, call *shimast.CallExpression) bool {
+	signature := chk.GetResolvedSignature(call.AsNode())
+	return signature != nil && isLmaoDeclarationNode(signature.Declaration())
+}
+
+func (t *fileTransformer) collectOptimizations(root *shimast.Node) []hintRewrite {
+	if t.checker == nil {
+		return nil
+	}
+	var hints []hintRewrite
+	var visit func(*shimast.Node)
+	visit = func(node *shimast.Node) {
+		if node == nil {
+			return
+		}
+		if node.Kind == shimast.KindCallExpression {
+			call := node.AsCallExpression()
+			_, name := calleeNames(call)
+			provenLmaoCall := hasLmaoCallProvenance(t.checker, call)
+			switch name {
+			case "defineOp":
+				if provenLmaoCall && len(call.Arguments.Nodes) >= 2 && len(call.Arguments.Nodes) < 4 && isNamedType(t.checker, call.AsNode(), "Op") {
+					hints = append(hints, hintRewrite{call: call, single: t.analyzeOpCompileMetadata(call.Arguments.Nodes[1])})
+				}
+			case "defineOps":
+				if provenLmaoCall && len(call.Arguments.Nodes) == 1 && call.Arguments.Nodes[0].Kind == shimast.KindObjectLiteralExpression && isNamedType(t.checker, call.AsNode(), "OpGroup") {
+					group := collectDefineOpsHints(t, call.Arguments.Nodes[0].AsObjectLiteralExpression())
+					if len(group) > 0 {
+						hints = append(hints, hintRewrite{call: call, hints: group, isGroup: true})
+					}
+				}
+			case "span":
+				recv, _ := calleeNames(call)
+				if recv != nil && len(call.Arguments.Nodes) >= 2 && len(call.Arguments.Nodes) <= 10 &&
+					(recv.Kind == shimast.KindIdentifier || recv.Kind == shimast.KindThisKeyword) &&
+					call.Arguments.Nodes[1].Kind == shimast.KindIdentifier &&
+					isNamedLmaoType(t.checker, call.Arguments.Nodes[1], "Op") {
+					recvType := t.checker.GetTypeAtLocation(recv)
+					if recvType != nil && isLmaoContextType(t.checker, recvType) {
+						t.opSpans[call] = true
+					}
+				}
+			}
+		}
+		node.ForEachChild(func(child *shimast.Node) bool {
+			visit(child)
+			return false
+		})
+	}
+	visit(root)
+	return hints
+}
+
+func isOpType(chk *shimchecker.Checker, typ *shimchecker.Type) bool {
+	name := chk.TypeToString(typ)
+	if strings.HasPrefix(name, "Op<") {
+		return true
+	}
+	sym := shimchecker.Type_getTypeNameSymbol(typ)
+	return sym != nil && sym.Name == "Op"
+}
+
+func (t *fileTransformer) spanContextApproved(node *shimast.Node) bool {
+	parent := node.Parent
+	if parent == nil {
+		return false
+	}
+	if parent.Kind == shimast.KindAwaitExpression && parent.AsAwaitExpression().Expression == node {
+		return true
+	}
+	if parent.Kind == shimast.KindReturnStatement && parent.AsReturnStatement().Expression == node {
+		for current := parent.Parent; current != nil; current = current.Parent {
+			if isNestedFunction(current) {
+				return current.ModifierFlags()&shimast.ModifierFlagsAsync != 0
+			}
+		}
+		return false
+	}
+	if parent.Kind == shimast.KindArrowFunction {
+		fn := parent.AsArrowFunction()
+		return fn.Body == node && parent.ModifierFlags()&shimast.ModifierFlagsAsync != 0
+	}
+	return false
+}
+
+func compileMetadataNode(analysis opCompileAnalysis) *shimast.Node {
+	templates := make([]*shimast.Node, len(analysis.logTemplateIds))
+	for i, message := range analysis.logTemplateIds {
+		templates[i] = str(message)
+	}
+	return factory.NewObjectLiteralExpression(factory.NewNodeList([]*shimast.Node{
+		factory.NewPropertyAssignment(nil, ident("runtimeHint"), nil, nil, num(int(analysis.runtimeHint))),
+		factory.NewPropertyAssignment(nil, ident("logTemplateIds"), nil, nil,
+			factory.NewArrayLiteralExpression(factory.NewNodeList(templates), false)),
+	}), true)
+}
+
+func applyHintRewrites(rewrites []hintRewrite) {
+	for _, rewrite := range rewrites {
+		args := append([]*shimast.Node{}, rewrite.call.Arguments.Nodes...)
+		if rewrite.isGroup {
+			names := make([]string, 0, len(rewrite.hints))
+			for name := range rewrite.hints {
+				names = append(names, name)
+			}
+			sort.Strings(names)
+			props := make([]*shimast.Node, 0, len(names))
+			for _, name := range names {
+				props = append(props, factory.NewPropertyAssignment(nil, str(name), nil, nil, compileMetadataNode(rewrite.hints[name])))
+			}
+			args = append(args, factory.NewObjectLiteralExpression(factory.NewNodeList(props), true))
+		} else {
+			for len(args) < 3 {
+				args = append(args, ident("undefined"))
+			}
+			args = append(args, compileMetadataNode(rewrite.single))
+		}
+		rewrite.call.Arguments = factory.NewNodeList(args)
+	}
+}

package/plugin/resultinline.go

@@ -0,0 +1,211 @@
+// resultinline.go — partial inlining of result chains (ctx.ok/ctx.err).
+//
+// The runtime's Ok/Err fluent methods (.line/.message/.with/schema setters)
+// delegate to a GeneratedResultWriter — a fixed-position writer at ROW 1
+// (packages/lmao/src/lib/codegen/fixedPositionWriterGenerator.ts), the same
+// family as the TagWriter at row 0. That makes result chains tag-shaped:
+// every chained write lands at a compile-time-known index. The partial
+// inline keeps the ok()/err() call itself (entry semantics, value capture)
+// and replaces the fluent chain with direct writes at [1], guarded on the
+// result's buffer being present (reproducing the runtime's
+// `_resultWriter()?.` no-op when there is no buffer):
+//
+//	return ctx.ok(user).line(42).with({ userId: u });
+//
+// becomes
+//
+//	{
+//	  const $$r = ctx.ok(user);
+//	  const $$b = $$r._buffer;
+//	  if ($$b) {
+//	    if ($$b.line_values) { $$b.line_values[1] = 42; ...nulls bit 1... }
+//	    if ($$b.userId_values) { $$b.userId_values[1] = u; ... }
+//	  }
+//	  return $$r;
+//	}
+//
+// Fires in ExpressionStatement and ReturnStatement contexts. Conservative
+// bails: receiver not Checker-proved LMAO context (TaskContext/SpanContext/
+// ModuleContext/RequestContext), chained method that is not line/message/
+// with/schema field, non-literal with(), non-single-arg links.
+package main
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+var lmaoContextTypeNames = []string{"TaskContext", "SpanContext", "ModuleContext", "RequestContext"}
+
+type resultInline struct {
+	list     *shimast.NodeList
+	index    int
+	isReturn bool
+	okCall   *shimast.Node // the ctx.ok(...) / ctx.err(...) call, kept verbatim
+	writes   []tagWrite    // line/message/schema writes in execution order
+	schema   map[string]schemaField
+}
+
+func isLmaoContextType(chk *shimchecker.Checker, t *shimchecker.Type) bool {
+	name := chk.TypeToString(t)
+	for _, w := range lmaoContextTypeNames {
+		if name == w || strings.HasPrefix(name, w+"<") {
+			return true
+		}
+	}
+	if sym := shimchecker.Type_getTypeNameSymbol(t); sym != nil {
+		for _, w := range lmaoContextTypeNames {
+			if sym.Name == w {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// findResultInline analyzes an ok/err chain. Checker queries only; no mutation.
+func (t *fileTransformer) findResultInline(call *shimast.CallExpression) (*resultInline, bool) {
+	if t.checker == nil {
+		return nil, false
+	}
+	type link struct {
+		name string
+		args []*shimast.Node
+	}
+	var links []link
+	current := call
+	for {
+		expr := current.Expression
+		if expr.Kind != shimast.KindPropertyAccessExpression {
+			return nil, false
+		}
+		pa := expr.AsPropertyAccessExpression()
+		name := shimast.NodeText(pa.Name())
+
+		if resultMethods[name] {
+			// Chain root: receiver must be a Checker-proved LMAO context.
+			recvType := t.checker.GetTypeAtLocation(pa.Expression)
+			if recvType == nil || !isLmaoContextType(t.checker, recvType) {
+				return nil, false
+			}
+			if len(links) == 0 {
+				return nil, false // bare ok()/err(): nothing to inline
+			}
+			// Schema comes from the Ok/Err type's own fluent surface.
+			okType := t.checker.GetTypeAtLocation(current.AsNode())
+			schema := map[string]schemaField{}
+			if okType != nil {
+				schema = extractSchema(t.checker, okType)
+				for _, sys := range []string{"line", "message", "isOk", "isErr", "map", "match", "unwrapOr", "success"} {
+					delete(schema, sys)
+				}
+			}
+			// Mark the kept ok/err call processed so the §6 chain-line pass
+			// does not ALSO append .line() to it inside our block.
+			t.processed[current] = true
+			in := &resultInline{okCall: current.AsNode(), schema: schema}
+			hasLine := false
+			for _, l := range links {
+				if l.name == "line" {
+					hasLine = true
+				}
+			}
+			if !hasLine {
+				// §6 semantics folded in: inject the call-site line.
+				in.writes = append(in.writes, tagWrite{field: "line", arg: num(t.lineOf(current.AsNode()))})
+			}
+			for _, l := range links {
+				switch {
+				case l.name == "line" || l.name == "message":
+					if len(l.args) != 1 {
+						return nil, false
+					}
+					in.writes = append(in.writes, tagWrite{field: l.name, arg: l.args[0]})
+				case l.name == "with":
+					if len(l.args) != 1 || l.args[0].Kind != shimast.KindObjectLiteralExpression {
+						return nil, false
+					}
+					for _, prop := range l.args[0].AsObjectLiteralExpression().Properties.Nodes {
+						if prop.Kind != shimast.KindPropertyAssignment {
+							return nil, false
+						}
+						p := prop.AsPropertyAssignment()
+						nameNode := p.Name()
+						if nameNode.Kind != shimast.KindIdentifier && nameNode.Kind != shimast.KindStringLiteral {
+							return nil, false
+						}
+						field := shimast.NodeText(nameNode)
+						if _, known := in.schema[field]; !known {
+							return nil, false
+						}
+						in.writes = append(in.writes, tagWrite{field: field, arg: p.Initializer})
+					}
+				default:
+					if len(l.args) != 1 {
+						return nil, false
+					}
+					if _, known := in.schema[l.name]; !known {
+						return nil, false
+					}
+					in.writes = append(in.writes, tagWrite{field: l.name, arg: l.args[0]})
+				}
+			}
+			return in, true
+		}
+
+		links = append([]link{{name: name, args: current.Arguments.Nodes}}, links...)
+		next := pa.Expression
+		if next.Kind != shimast.KindCallExpression {
+			return nil, false
+		}
+		current = next.AsCallExpression()
+	}
+}
+
+// applyResultInlines splices replacement blocks (phase B — no checker use).
+func (t *fileTransformer) applyResultInlines(inlines []resultInline) {
+	for _, in := range inlines {
+		res := ident("$$r")
+		buf := ident("$$b")
+
+		var writes []*shimast.Node
+		for _, w := range in.writes {
+			info, known := in.schema[w.field]
+			switch {
+			case known && info.kind == fieldEnum:
+				var enumIdx *shimast.Node
+				if isCompileTimeLiteral(w.arg) && w.arg.Kind == shimast.KindStringLiteral {
+					v := 0
+					for i, ev := range info.enumValues {
+						if ev == shimast.NodeText(w.arg) {
+							v = i
+							break
+						}
+					}
+					enumIdx = num(v)
+				} else {
+					enumIdx = enumSwitchIIFE(w.arg, info.enumValues)
+				}
+				writes = append(writes, factory.NewExpressionStatement(
+					callExpr(propAccess(buf, w.field), []*shimast.Node{num(1), enumIdx})))
+			case known && info.kind == fieldBool:
+				writes = append(writes, factory.NewExpressionStatement(
+					callExpr(propAccess(buf, w.field), []*shimast.Node{num(1), w.arg})))
+			default:
+				writes = append(writes, guardedRawWrite(buf, num(1), w.field, w.arg))
+			}
+		}
+
+		stmts := []*shimast.Node{
+			constDecl(res, in.okCall),
+			constDecl(buf, propAccess(res, "_buffer")),
+			factory.NewIfStatement(buf, factory.NewBlock(factory.NewNodeList(writes), true), nil),
+		}
+		if in.isReturn {
+			stmts = append(stmts, factory.NewReturnStatement(res))
+		}
+		in.list.Nodes[in.index] = factory.NewBlock(factory.NewNodeList(stmts), true)
+	}
+}