@sayoriqwq/effect-harness 0.0.1 → 0.0.3

package/repos/tsgo/internal/refactors/async_await_to_gen_try_promise.go

@@ -0,0 +1,263 @@
+package refactors
+
+import (
+	"fmt"
+
+	"github.com/effect-ts/tsgo/internal/refactor"
+	"github.com/effect-ts/tsgo/internal/typeparser"
+	"github.com/microsoft/typescript-go/shim/ast"
+	"github.com/microsoft/typescript-go/shim/astnav"
+	"github.com/microsoft/typescript-go/shim/ls"
+	"github.com/effect-ts/tsgo/internal/rewriter"
+)
+
+var AsyncAwaitToGenTryPromise = refactor.Refactor{
+	Name:        "asyncAwaitToGenTryPromise",
+	Description: "Convert async/await to Effect.gen (with error handling)",
+	Kind:        "rewrite.effect.asyncAwaitToGenTryPromise",
+	Run:         runAsyncAwaitToGenTryPromise,
+}
+
+func runAsyncAwaitToGenTryPromise(ctx *refactor.Context) []ls.CodeAction {
+	token := astnav.GetTokenAtPosition(ctx.SourceFile, ctx.Span.Pos())
+	if token == nil {
+		return nil
+	}
+
+	// Walk ancestor chain to find the nearest async function
+	asyncFn := findAsyncFunction(token)
+	if asyncFn == nil {
+		return nil
+	}
+
+	effectModuleName := typeparser.FindEffectModuleIdentifier(ctx.SourceFile)
+	dataModuleName := typeparser.FindModuleIdentifier(ctx.SourceFile, "Data")
+
+	action := ctx.NewRefactorAction(refactor.RefactorAction{
+		Description: "Rewrite to Effect.gen with failures",
+		Run: func(tracker *rewriter.Tracker) {
+			transformAsyncToEffectGenTryPromise(tracker, ctx.SourceFile, asyncFn, effectModuleName, dataModuleName)
+		},
+	})
+	if action == nil {
+		return nil
+	}
+
+	action.Kind = "refactor.rewrite.effect.asyncAwaitToGenTryPromise"
+	return []ls.CodeAction{*action}
+}
+
+func transformAsyncToEffectGenTryPromise(tracker *rewriter.Tracker, sf *ast.SourceFile, node *ast.Node, effectModuleName string, dataModuleName string) {
+	body := typeparser.GetFunctionLikeBody(node)
+	if body == nil {
+		return
+	}
+
+	// Track error classes to generate
+	errorCount := 0
+	var errorClasses []*ast.Node
+
+	// Determine if function is exported (error classes should match)
+	isExported := ast.GetCombinedModifierFlags(node)&ast.ModifierFlagsExport != 0
+	// Also check parent variable statement for export
+	if !isExported {
+		varStmt := findParentOfKind(node, ast.KindVariableStatement)
+		if varStmt != nil {
+			isExported = ast.GetCombinedModifierFlags(varStmt)&ast.ModifierFlagsExport != 0
+		}
+	}
+
+	// Transform await expressions to yield* Effect.tryPromise(...)
+	transformedBody := transformBodyAwaitToYield(tracker, body, func(t *rewriter.Tracker, expr *ast.Node) *ast.Node {
+		errorCount++
+		errorName := fmt.Sprintf("Error%d", errorCount)
+
+		// Build the error class declaration
+		errorClass := buildTaggedErrorClass(t, dataModuleName, errorName, isExported)
+		errorClasses = append(errorClasses, errorClass)
+
+		return buildYieldStarTryPromise(t, expr, effectModuleName, errorName)
+	})
+
+	// Build Effect.gen(function*() { transformedBody })
+	effectGenCall := buildEffectGenCall(tracker, transformedBody, effectModuleName)
+
+	// Build non-async declaration wrapping the gen call
+	newDecl := buildNonAsyncDeclaration(tracker, node, effectGenCall)
+	if newDecl == nil {
+		return
+	}
+
+	ast.SetParentInChildren(newDecl)
+
+	// Find the top-level statement containing the function (for inserting error classes before it)
+	topLevelStmt := findTopLevelStatement(node)
+
+	// Insert error classes before the top-level statement
+	for _, errorClass := range errorClasses {
+		ast.SetParentInChildren(errorClass)
+		tracker.InsertNodeBefore(sf, topLevelStmt, errorClass, true, rewriter.LeadingTriviaOptionNone)
+	}
+
+	// Replace the function
+	if node.Kind == ast.KindFunctionDeclaration {
+		tracker.ReplaceNode(sf, node, newDecl, nil)
+	} else {
+		replaceExpressionViaStatement(tracker, sf, node, newDecl)
+	}
+}
+
+// findTopLevelStatement walks up the parent chain from node until it finds
+// a node whose parent is the SourceFile.
+func findTopLevelStatement(node *ast.Node) *ast.Node {
+	current := node
+	for current.Parent != nil && current.Parent.Kind != ast.KindSourceFile {
+		current = current.Parent
+	}
+	return current
+}
+
+// buildYieldStarTryPromise builds: yield* Effect.tryPromise({ try: () => expr, catch: cause => new ErrorN({ cause }) })
+func buildYieldStarTryPromise(tracker *rewriter.Tracker, expr *ast.Node, effectModuleName string, errorName string) *ast.Node {
+	// try: () => expr
+	tryArrow := tracker.NewArrowFunction(
+		nil,                                // modifiers
+		nil,                                // typeParameters
+		tracker.NewNodeList([]*ast.Node{}), // parameters (empty)
+		nil,                                // returnType
+		nil,                                // fullSignature
+		tracker.NewToken(ast.KindEqualsGreaterThanToken),
+		expr,
+	)
+	tryProp := tracker.NewPropertyAssignment(
+		nil, // modifiers
+		tracker.NewIdentifier("try"),
+		nil, // postfixToken
+		nil, // typeNode
+		tryArrow,
+	)
+
+	// catch: cause => new ErrorN({ cause })
+	causeParam := tracker.NewParameterDeclaration(
+		nil, // modifiers
+		nil, // dotDotDotToken
+		tracker.NewIdentifier("cause"),
+		nil, // questionToken
+		nil, // typeNode
+		nil, // initializer
+	)
+
+	// new ErrorN({ cause })
+	causeShorthand := tracker.NewShorthandPropertyAssignment(
+		nil, // modifiers
+		tracker.NewIdentifier("cause"),
+		nil, // postfixToken
+		nil, // typeNode
+		nil, // equalsToken
+		nil, // objectAssignmentInitializer
+	)
+	objLiteral := tracker.NewObjectLiteralExpression(
+		tracker.NewNodeList([]*ast.Node{causeShorthand}),
+		false, // not multiline
+	)
+	newErrorExpr := tracker.NewNewExpression(
+		tracker.NewIdentifier(errorName),
+		nil, // typeArguments
+		tracker.NewNodeList([]*ast.Node{objLiteral}),
+	)
+
+	catchArrow := tracker.NewArrowFunction(
+		nil, // modifiers
+		nil, // typeParameters
+		tracker.NewNodeList([]*ast.Node{causeParam}),
+		nil, // returnType
+		nil, // fullSignature
+		tracker.NewToken(ast.KindEqualsGreaterThanToken),
+		newErrorExpr,
+	)
+	catchProp := tracker.NewPropertyAssignment(
+		nil, // modifiers
+		tracker.NewIdentifier("catch"),
+		nil, // postfixToken
+		nil, // typeNode
+		catchArrow,
+	)
+
+	// { try: () => expr, catch: cause => new ErrorN({ cause }) }
+	optionsObj := tracker.NewObjectLiteralExpression(
+		tracker.NewNodeList([]*ast.Node{tryProp, catchProp}),
+		false, // not multiline
+	)
+
+	// Effect.tryPromise({ ... })
+	effectId := tracker.NewIdentifier(effectModuleName)
+	tryPromiseAccess := tracker.NewPropertyAccessExpression(
+		effectId, nil, tracker.NewIdentifier("tryPromise"), ast.NodeFlagsNone,
+	)
+	tryPromiseCall := tracker.NewCallExpression(
+		tryPromiseAccess, nil, nil,
+		tracker.NewNodeList([]*ast.Node{optionsObj}),
+		ast.NodeFlagsNone,
+	)
+
+	// yield* Effect.tryPromise({ ... })
+	return tracker.NewYieldExpression(
+		tracker.NewToken(ast.KindAsteriskToken),
+		tryPromiseCall,
+	)
+}
+
+// buildTaggedErrorClass builds: class ErrorN extends Data.TaggedError("ErrorN")<{ cause: unknown }> {}
+func buildTaggedErrorClass(tracker *rewriter.Tracker, dataModuleName string, errorName string, isExported bool) *ast.Node {
+	// Data.TaggedError("ErrorN")
+	dataId := tracker.NewIdentifier(dataModuleName)
+	taggedErrorAccess := tracker.NewPropertyAccessExpression(
+		dataId, nil, tracker.NewIdentifier("TaggedError"), ast.NodeFlagsNone,
+	)
+	taggedErrorCall := tracker.NewCallExpression(
+		taggedErrorAccess, nil, nil,
+		tracker.NewNodeList([]*ast.Node{tracker.NewStringLiteral(errorName, 0)}),
+		ast.NodeFlagsNone,
+	)
+
+	// <{ cause: unknown }>
+	causePropSig := tracker.NewPropertySignatureDeclaration(
+		nil, // modifiers
+		tracker.NewIdentifier("cause"),
+		nil, // postfixToken
+		tracker.NewKeywordTypeNode(ast.KindUnknownKeyword),
+		nil, // initializer
+	)
+	typeLiteral := tracker.NewTypeLiteralNode(
+		tracker.NewNodeList([]*ast.Node{causePropSig}),
+	)
+
+	// Data.TaggedError("ErrorN")<{ cause: unknown }>
+	exprWithTypeArgs := tracker.NewExpressionWithTypeArguments(
+		taggedErrorCall,
+		tracker.NewNodeList([]*ast.Node{typeLiteral}),
+	)
+
+	// extends clause
+	heritageClause := tracker.NewHeritageClause(
+		ast.KindExtendsKeyword,
+		tracker.NewNodeList([]*ast.Node{exprWithTypeArgs}),
+	)
+
+	// Modifiers (export if needed)
+	var modifiers *ast.ModifierList
+	if isExported {
+		modifiers = tracker.NewModifierList([]*ast.Node{
+			tracker.NewModifier(ast.KindExportKeyword),
+		})
+	}
+
+	// class ErrorN extends Data.TaggedError("ErrorN")<{ cause: unknown }> {}
+	return tracker.NewClassDeclaration(
+		modifiers,
+		tracker.NewIdentifier(errorName),
+		nil, // typeParameters
+		tracker.NewNodeList([]*ast.Node{heritageClause}),
+		tracker.NewNodeList([]*ast.Node{}), // empty members
+	)
+}

package/repos/tsgo/internal/refactors/effect_gen_to_fn.go

@@ -0,0 +1,308 @@
+package refactors
+
+import (
+	"github.com/effect-ts/tsgo/internal/refactor"
+	"github.com/effect-ts/tsgo/internal/typeparser"
+	"github.com/microsoft/typescript-go/shim/ast"
+	"github.com/microsoft/typescript-go/shim/astnav"
+	"github.com/microsoft/typescript-go/shim/checker"
+	"github.com/microsoft/typescript-go/shim/ls"
+	"github.com/effect-ts/tsgo/internal/rewriter"
+)
+
+var EffectGenToFn = refactor.Refactor{
+	Name:        "effectGenToFn",
+	Description: "Convert to Effect.fn",
+	Kind:        "rewrite.effect.effectGenToFn",
+	Run:         runEffectGenToFn,
+}
+
+// effectGenParsed holds the parsed components of a function returning Effect.gen.
+type effectGenParsed struct {
+	funcNode *ast.Node                       // The function-like node (arrow, declaration, expression, method)
+	genCall  *typeparser.EffectGenCallResult // The parsed Effect.gen call
+	pipeArgs []*ast.Node                     // Collected pipe arguments (from .pipe() or pipe() wrappers)
+}
+
+func runEffectGenToFn(ctx *refactor.Context) []ls.CodeAction {
+	c := ctx.Checker
+
+	token := astnav.GetTokenAtPosition(ctx.SourceFile, ctx.Span.Pos())
+	if token == nil {
+		return nil
+	}
+
+	// Walk ancestor chain to find a function-like node returning Effect.gen
+	parsed := findFunctionReturningEffectGen(ctx.TypeParser, c, token)
+	if parsed == nil {
+		return nil
+	}
+
+	fnName := typeparser.GetFunctionLikeName(parsed.funcNode)
+
+	description := "Convert to Effect.fn"
+	if fnName != "" {
+		description = "Convert to Effect.fn(\"" + fnName + "\")"
+	}
+
+	action := ctx.NewRefactorAction(refactor.RefactorAction{
+		Description: description,
+		Run: func(tracker *rewriter.Tracker) {
+			newNode := buildEffectGenToFnReplacement(tracker, parsed, fnName)
+			if newNode == nil {
+				return
+			}
+			ast.SetParentInChildren(newNode)
+
+			switch parsed.funcNode.Kind {
+			case ast.KindFunctionDeclaration, ast.KindMethodDeclaration:
+				tracker.ReplaceNode(ctx.SourceFile, parsed.funcNode, newNode, nil)
+			default:
+				replaceExpressionViaStatement(tracker, ctx.SourceFile, parsed.funcNode, newNode)
+			}
+		},
+	})
+	if action == nil {
+		return nil
+	}
+
+	action.Kind = "refactor.rewrite.effect.effectGenToFn"
+	return []ls.CodeAction{*action}
+}
+
+// findFunctionReturningEffectGen walks from the token up the ancestor chain to find
+// a function-like node whose body directly returns an Effect.gen call, optionally
+// wrapped in pipe/pipeable chains.
+func findFunctionReturningEffectGen(tp *typeparser.TypeParser, c *checker.Checker, token *ast.Node) *effectGenParsed {
+	for node := token; node != nil; node = node.Parent {
+		switch node.Kind {
+		case ast.KindArrowFunction, ast.KindFunctionDeclaration, ast.KindMethodDeclaration:
+			parsed := parseFunctionReturningEffectGen(tp, c, node)
+			if parsed != nil {
+				return parsed
+			}
+			// Hit a function boundary without finding Effect.gen — stop
+			return nil
+		case ast.KindFunctionExpression:
+			// Don't match on generator functions (those are inside Effect.gen already)
+			fe := node.AsFunctionExpression()
+			if fe.AsteriskToken != nil {
+				continue
+			}
+			parsed := parseFunctionReturningEffectGen(tp, c, node)
+			if parsed != nil {
+				return parsed
+			}
+			return nil
+		}
+	}
+	return nil
+}
+
+// parseFunctionReturningEffectGen extracts the Effect.gen call and any pipe args
+// from a function-like node. Returns nil if the function doesn't match.
+func parseFunctionReturningEffectGen(tp *typeparser.TypeParser, _ *checker.Checker, node *ast.Node) *effectGenParsed {
+	body := typeparser.GetFunctionLikeBody(node)
+	if body == nil {
+		return nil
+	}
+
+	// Skip through { return <expr> } blocks to get the actual expression
+	subject := skipReturnBlock(body)
+
+	// Peel off pipe wrappers, collecting args
+	var pipeArgs []*ast.Node
+	for {
+		pipeResult := tp.ParsePipeCall(subject)
+		if pipeResult == nil {
+			break
+		}
+		// Prepend args (inner pipes go first)
+		pipeArgs = append(pipeResult.Args, pipeArgs...)
+		subject = pipeResult.Subject
+	}
+
+	// Check if the core expression is Effect.gen(function*() { ... })
+	genCall := tp.EffectGenCall(subject)
+	if genCall == nil {
+		return nil
+	}
+
+	return &effectGenParsed{
+		funcNode: node,
+		genCall:  genCall,
+		pipeArgs: pipeArgs,
+	}
+}
+
+// skipReturnBlock unwraps a block containing a single return statement to get the expression.
+func skipReturnBlock(node *ast.Node) *ast.Node {
+	if node.Kind != ast.KindBlock {
+		return node
+	}
+	block := node.AsBlock()
+	if block.Statements == nil || len(block.Statements.Nodes) != 1 {
+		return node
+	}
+	stmt := block.Statements.Nodes[0]
+	if stmt.Kind != ast.KindReturnStatement {
+		return node
+	}
+	ret := stmt.AsReturnStatement()
+	if ret.Expression == nil {
+		return node
+	}
+	return ret.Expression
+}
+
+// buildEffectGenToFnReplacement builds the replacement node for the effectGenToFn refactor.
+func buildEffectGenToFnReplacement(tracker *rewriter.Tracker, parsed *effectGenParsed, fnName string) *ast.Node {
+	node := parsed.funcNode
+	genCall := parsed.genCall
+
+	// Get the generator body
+	var blockBody *ast.Node
+	if genCall.Body != nil {
+		body := genCall.Body
+		if body.Kind == ast.KindBlock {
+			blockBody = tracker.DeepCloneNode(body)
+		} else {
+			// Expression body: wrap in { return <expr> }
+			clonedExpr := tracker.DeepCloneNode(body)
+			returnStmt := tracker.NewReturnStatement(clonedExpr)
+			blockBody = tracker.NewBlock(tracker.NewNodeList([]*ast.Node{returnStmt}), true)
+		}
+	}
+	if blockBody == nil {
+		return nil
+	}
+
+	// Get type parameters and parameters from the outer function
+	var typeParams *ast.NodeList
+	var params *ast.NodeList
+
+	switch node.Kind {
+	case ast.KindArrowFunction:
+		af := node.AsArrowFunction()
+		typeParams = cloneNodeList(tracker, af.TypeParameters)
+		params = cloneNodeList(tracker, af.Parameters)
+	case ast.KindFunctionDeclaration:
+		fd := node.AsFunctionDeclaration()
+		typeParams = cloneNodeList(tracker, fd.TypeParameters)
+		params = cloneNodeList(tracker, fd.Parameters)
+	case ast.KindFunctionExpression:
+		fe := node.AsFunctionExpression()
+		typeParams = cloneNodeList(tracker, fe.TypeParameters)
+		params = cloneNodeList(tracker, fe.Parameters)
+	case ast.KindMethodDeclaration:
+		md := node.AsMethodDeclaration()
+		typeParams = cloneNodeList(tracker, md.TypeParameters)
+		params = cloneNodeList(tracker, md.Parameters)
+	}
+
+	// Build function*(params) { body }
+	genFn := tracker.NewFunctionExpression(
+		nil,                                     // modifiers
+		tracker.NewToken(ast.KindAsteriskToken), // asterisk (generator)
+		nil,                                     // name
+		typeParams,                              // typeParameters
+		params,                                  // parameters
+		nil,                                     // returnType
+		nil,                                     // fullSignature
+		blockBody,
+	)
+
+	// Build Effect.fn or Effect.fn("name")
+	effectId := tracker.DeepCloneNode(genCall.EffectModule)
+	fnAccess := tracker.NewPropertyAccessExpression(
+		effectId, nil, tracker.NewIdentifier("fn"), ast.NodeFlagsNone,
+	)
+
+	var fnCallExpr *ast.Node
+	if fnName != "" {
+		// Effect.fn("name")
+		fnCallExpr = tracker.NewCallExpression(
+			fnAccess, nil, nil,
+			tracker.NewNodeList([]*ast.Node{tracker.NewStringLiteral(fnName, 0)}),
+			ast.NodeFlagsNone,
+		)
+	} else {
+		fnCallExpr = fnAccess
+	}
+
+	// Build the arguments: [generatorFn, ...pipeArgs]
+	args := []*ast.Node{genFn}
+	for _, pipeArg := range parsed.pipeArgs {
+		args = append(args, tracker.DeepCloneNode(pipeArg))
+	}
+
+	// Effect.fn("name")(function*(params) { body }, ...pipeArgs)
+	effectFnCall := tracker.NewCallExpression(
+		fnCallExpr, nil, nil,
+		tracker.NewNodeList(args),
+		ast.NodeFlagsNone,
+	)
+
+	// Wrap in appropriate declaration
+	return buildEffectGenToFnDeclaration(tracker, node, effectFnCall)
+}
+
+// buildEffectGenToFnDeclaration wraps the Effect.fn call in the appropriate declaration.
+func buildEffectGenToFnDeclaration(tracker *rewriter.Tracker, node *ast.Node, effectFnCall *ast.Node) *ast.Node {
+	switch node.Kind {
+	case ast.KindFunctionDeclaration:
+		fd := node.AsFunctionDeclaration()
+		if fd.Name() == nil {
+			return effectFnCall
+		}
+
+		// Collect modifiers
+		var mods *ast.ModifierList
+		if fd.Modifiers() != nil {
+			var modNodes []*ast.Node
+			for _, mod := range fd.Modifiers().Nodes {
+				modNodes = append(modNodes, tracker.NewModifier(mod.Kind))
+			}
+			if len(modNodes) > 0 {
+				mods = tracker.NewModifierList(modNodes)
+			}
+		}
+
+		// const name = Effect.fn("name")(...)
+		varDecl := tracker.NewVariableDeclaration(
+			tracker.DeepCloneNode(fd.Name()),
+			nil, // exclamationToken
+			nil, // type
+			effectFnCall,
+		)
+		varDeclList := tracker.NewVariableDeclarationList(
+			tracker.NewNodeList([]*ast.Node{varDecl}),
+			ast.NodeFlagsConst,
+		)
+		return tracker.NewVariableStatement(mods, varDeclList)
+
+	case ast.KindMethodDeclaration:
+		md := node.AsMethodDeclaration()
+		// Convert method to property declaration: name = Effect.fn("name")(...)
+		var mods *ast.ModifierList
+		if md.Modifiers() != nil {
+			var modNodes []*ast.Node
+			for _, mod := range md.Modifiers().Nodes {
+				modNodes = append(modNodes, tracker.NewModifier(mod.Kind))
+			}
+			if len(modNodes) > 0 {
+				mods = tracker.NewModifierList(modNodes)
+			}
+		}
+		return tracker.NewPropertyDeclaration(
+			mods,
+			tracker.DeepCloneNode(md.Name()),
+			nil, // postfixToken
+			nil, // type
+			effectFnCall,
+		)
+	}
+
+	// For arrow functions and function expressions, return the expression directly
+	return effectFnCall
+}