Go 接口自动实现

复制import ast
import textwrap

# 解析 Go 接口定义，生成空方法实现模板
# 输入：Go 接口源码字符串
# 输出：结构体实现该接口的代码模板

def generate_stub(interface_code: str, struct_name: str = "MyStruct") -> str:
    tree = ast.parse(interface_code)
    methods = []
    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef):
            # 提取方法签名
            args = [arg.arg for arg in node.args.args]
            returns = ast.unparse(node.returns) if node.returns else ""
            methods.append((node.name, args, returns))
    
    lines = [f"type {struct_name} struct {{}}"]
    for name, args, ret in methods:
        params = ", ".join([f"{a} interface{{}}" for a in args])
        if ret:
            lines.append(f"func (s {struct_name}) {name}({params}) {ret} {{ return nil }}")
        else:
            lines.append(f"func (s {struct_name}) {name}({params}) {{}}")
    return "\n".join(lines)

# 示例：输入一个简单接口
iface = """
type Reader interface {
    Read(p []byte) (n int, err error)
    Close() error
}
"""
print(generate_stub(iface, "FileReader"))
# 输出：
# type FileReader struct {}
# func (s FileReader) Read(p interface{}) (int, error) { return nil }
# func (s FileReader) Close() interface{} { return nil }

复制package main

import (
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
)

// 解析 Go 接口并生成空实现结构体代码
func generateStub(interfaceCode string, structName string) string {
	fset := token.NewFileSet()
	node, err := parser.ParseFile(fset, "", interfaceCode, parser.ParseComments)
	if err != nil {
		return fmt.Sprintf("// 解析错误: %v", err)
	}

	var methods []string
	for _, decl := range node.Decls {
		genDecl, ok := decl.(*ast.GenDecl)
		if !ok || genDecl.Tok != token.TYPE {
			continue
		}
		for _, spec := range genDecl.Specs {
			typeSpec, ok := spec.(*ast.TypeSpec)
			if !ok {
				continue
			}
			ifaceType, ok := typeSpec.Type.(*ast.InterfaceType)
			if !ok {
				continue
			}
			for _, method := range ifaceType.Methods.List {
				if len(method.Names) == 0 {
					continue
				}
				funcType, ok := method.Type.(*ast.FuncType)
				if !ok {
					continue
				}
				name := method.Names[0].Name
				params := ""
				if funcType.Params != nil {
					for i, param := range funcType.Params.List {
						if i > 0 {
							params += ", "
						}
						for _, n := range param.Names {
							params += n.Name + " interface{}"
						}
					}
				}
				returns := ""
				if funcType.Results != nil {
					returns = " ("
					for i, r := range funcType.Results.List {
						if i > 0 {
							returns += ", "
						}
						returns += fmt.Sprintf("%s", r.Type)
					}
					returns += ")"
				}
				methods = append(methods, fmt.Sprintf("func (s %s) %s(%s)%s { return }", structName, name, params, returns))
			}
		}
	}

	result := fmt.Sprintf("type %s struct {}\n", structName)
	for _, m := range methods {
		result += m + "\n"
	}
	return result
}

func main() {
	iface := `type Reader interface {
	Read(p []byte) (n int, err error)
	Close() error
}`
	fmt.Println(generateStub(iface, "FileReader"))
	// 输出:
	// type FileReader struct {}
	// func (s FileReader) Read(p interface{}) (int, error) { return }
	// func (s FileReader) Close() error { return }
}

复制// 解析 Go 接口定义并生成空方法实现模板（Node.js 环境）
// 使用正则简化解析，适合常见接口格式

function generateStub(interfaceCode, structName = 'MyStruct') {
  // 提取方法签名：匹配 func 行
  const methodRegex = /\b(\w+)\(([^)]*)\)\s*(?:([^(]+))?/g;
  let match;
  const methods = [];
  
  while ((match = methodRegex.exec(interfaceCode)) !== null) {
    const name = match[1];
    const params = match[2].split(',').map(p => p.trim()).filter(p => p);
    const returns = match[3] ? match[3].trim() : '';
    methods.push({ name, params, returns });
  }

  // 生成结构体定义
  let result = `type ${structName} struct {}\n`;
  for (const m of methods) {
    const paramList = m.params.map(p => `${p.split(' ')[0] || p} interface{}`).join(', ');
    const retPart = m.returns ? ` ${m.returns}` : '';
    result += `func (s ${structName}) ${m.name}(${paramList})${retPart} { return }\n`;
  }
  return result;
}

// 示例
const iface = `type Reader interface {
  Read(p []byte) (n int, err error)
  Close() error
}`;
console.log(generateStub(iface, 'FileReader'));
// 输出:
// type FileReader struct {}
// func (s FileReader) Read(p interface{}) (int, err error) { return }
// func (s FileReader) Close() error { return }