@zyno-io/ts-reflection 26.803.2224

package/dist/type-compiler/download-prebuilt.cjs

@@ -0,0 +1,114 @@
+'use strict';
+/* oxlint-disable typescript/no-require-imports -- this helper is spawned by the CommonJS plugin descriptor. */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const http = require('node:http');
+const https = require('node:https');
+const os = require('node:os');
+const path = require('node:path');
+
+const MAX_BINARY_BYTES = 128 * 1024 * 1024;
+const MAX_MANIFEST_BYTES = 64 * 1024;
+const MAX_REDIRECTS = 5;
+
+async function main() {
+    const input = JSON.parse(fs.readFileSync(0, 'utf8'));
+    const manifest = JSON.parse((await download(input.manifestUrl, MAX_MANIFEST_BYTES, input)).toString('utf8'));
+    validateManifest(manifest, input.expected);
+
+    const binary = await download(input.binaryUrl, MAX_BINARY_BYTES, input);
+    const digest = crypto.createHash('sha256').update(binary).digest('hex');
+    if (digest !== manifest.binarySha256) throw new Error(`binary checksum mismatch: expected ${manifest.binarySha256}, received ${digest}`);
+    if (binary.length !== manifest.binarySize) throw new Error(`binary size mismatch: expected ${manifest.binarySize}, received ${binary.length}`);
+
+    const temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'tsf-type-compiler-'));
+    const temporaryBinary = path.join(temporaryDirectory, path.basename(input.destination));
+    try {
+        fs.writeFileSync(temporaryBinary, binary, { mode: 0o755 });
+        fs.mkdirSync(path.dirname(input.destination), { recursive: true });
+        if (fs.existsSync(input.destination)) return;
+        try {
+            fs.renameSync(temporaryBinary, input.destination);
+        } catch (error) {
+            if (!fs.existsSync(input.destination)) throw error;
+        }
+        if (process.platform !== 'win32') fs.chmodSync(input.destination, 0o755);
+    } finally {
+        fs.rmSync(temporaryDirectory, { force: true, recursive: true });
+    }
+}
+
+function validateManifest(manifest, expected) {
+    for (const key of [
+        'schemaVersion',
+        'packageVersion',
+        'platform',
+        'arch',
+        'pluginSourceSha256',
+        'ttscVersion',
+        'typescriptVersion',
+        'binaryAsset'
+    ]) {
+        if (manifest[key] !== expected[key]) throw new Error(`manifest ${key} mismatch: expected ${expected[key]}, received ${manifest[key]}`);
+    }
+    if (manifest.cgoEnabled !== false) throw new Error('prebuilt compiler must be produced with CGO_ENABLED=0');
+    if (!/^[a-f0-9]{64}$/.test(manifest.binarySha256)) throw new Error('manifest has an invalid binary checksum');
+    if (!Number.isSafeInteger(manifest.binarySize) || manifest.binarySize <= 0 || manifest.binarySize > MAX_BINARY_BYTES) {
+        throw new Error('manifest has an invalid binary size');
+    }
+}
+
+function download(location, maximumBytes, options, redirects = 0) {
+    const url = new URL(location);
+    if (url.protocol !== 'https:' && !(options.allowHttp === true && url.protocol === 'http:')) {
+        throw new Error(`refusing prebuilt compiler URL protocol ${url.protocol}`);
+    }
+    const client = url.protocol === 'https:' ? https : http;
+    return new Promise((resolve, reject) => {
+        const request = client.get(
+            url,
+            {
+                headers: {
+                    Accept: 'application/octet-stream, application/json',
+                    'User-Agent': 'ts-server-foundation-type-compiler'
+                }
+            },
+            response => {
+                if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+                    response.resume();
+                    if (redirects >= MAX_REDIRECTS) return reject(new Error('too many prebuilt compiler redirects'));
+                    return resolve(download(new URL(response.headers.location, url).href, maximumBytes, options, redirects + 1));
+                }
+                if (response.statusCode !== 200) {
+                    response.resume();
+                    return reject(new Error(`prebuilt compiler request returned HTTP ${response.statusCode}`));
+                }
+                const declaredLength = Number(response.headers['content-length']);
+                if (Number.isFinite(declaredLength) && declaredLength > maximumBytes) {
+                    response.destroy();
+                    return reject(new Error(`prebuilt compiler response exceeds ${maximumBytes} bytes`));
+                }
+                const chunks = [];
+                let size = 0;
+                response.on('data', chunk => {
+                    size += chunk.length;
+                    if (size > maximumBytes) {
+                        response.destroy(new Error(`prebuilt compiler response exceeds ${maximumBytes} bytes`));
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                response.on('end', () => resolve(Buffer.concat(chunks)));
+                response.on('error', reject);
+            }
+        );
+        request.setTimeout(options.requestTimeoutMs, () => request.destroy(new Error('prebuilt compiler request timed out')));
+        request.on('error', reject);
+    });
+}
+
+main().catch(error => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/type-compiler/go/ast_expression.go

@@ -0,0 +1,187 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimcore "github.com/microsoft/typescript-go/shim/core"
+	shimparser "github.com/microsoft/typescript-go/shim/parser"
+	shimprinter "github.com/microsoft/typescript-go/shim/printer"
+)
+
+const (
+	runtimeImportPlaceholderName    = "__tsf_runtime_import__"
+	runtimeNamespacePlaceholderName = "__tsf_runtime_namespace__"
+	runtimeAliasPlaceholderName     = "__tsf_runtime_alias__"
+)
+
+type expressionTemplate struct {
+	parsed *shimast.Node
+}
+
+func parseExpressionTemplate(source string) (expressionTemplate, error) {
+	source = strings.TrimSpace(source)
+	if source == "" {
+		return expressionTemplate{}, fmt.Errorf("generated expression is empty")
+	}
+	fileName := filepath.ToSlash(filepath.Join(os.TempDir(), "tsf-generated-metadata-expression.ts"))
+	file := shimparser.ParseSourceFile(
+		shimast.SourceFileParseOptions{FileName: fileName},
+		"("+source+");",
+		shimcore.ScriptKindTS,
+	)
+	if file == nil {
+		return expressionTemplate{}, fmt.Errorf("generated expression did not parse")
+	}
+	if diagnostics := file.Diagnostics(); len(diagnostics) != 0 {
+		return expressionTemplate{}, fmt.Errorf("generated expression has %d parse diagnostic(s)", len(diagnostics))
+	}
+	if file.Statements == nil || len(file.Statements.Nodes) != 1 {
+		return expressionTemplate{}, fmt.Errorf("generated expression did not parse as one statement")
+	}
+	statement := file.Statements.Nodes[0]
+	if statement == nil || statement.Kind != shimast.KindExpressionStatement || statement.AsExpressionStatement().Expression == nil {
+		return expressionTemplate{}, fmt.Errorf("generated expression did not parse as an expression statement")
+	}
+	parsed := statement.AsExpressionStatement().Expression.AsNode()
+	if err := validateRuntimePlaceholders(parsed); err != nil {
+		return expressionTemplate{}, err
+	}
+	return expressionTemplate{parsed: parsed}, nil
+}
+
+func validateRuntimePlaceholders(node *shimast.Node) error {
+	var validationErr error
+	var walk func(*shimast.Node)
+	walk = func(current *shimast.Node) {
+		if current == nil || validationErr != nil {
+			return
+		}
+		if current.Kind == shimast.KindCallExpression {
+			call := current.AsCallExpression()
+			if call != nil && call.Expression != nil && call.Expression.Kind == shimast.KindIdentifier {
+				name := call.Expression.Text()
+				expected := -1
+				switch name {
+				case runtimeImportPlaceholderName:
+					expected = 3
+				case runtimeNamespacePlaceholderName:
+					expected = 2
+				case runtimeAliasPlaceholderName:
+					expected = 3
+				}
+				if expected >= 0 {
+					if call.Arguments == nil || len(call.Arguments.Nodes) != expected {
+						validationErr = fmt.Errorf("%s requires %d string arguments", name, expected)
+						return
+					}
+					for _, argument := range call.Arguments.Nodes {
+						if argument == nil || !shimast.IsStringLiteral(argument) {
+							validationErr = fmt.Errorf("%s arguments must be string literals", name)
+							return
+						}
+					}
+				}
+			}
+		}
+		current.ForEachChild(func(child *shimast.Node) bool {
+			walk(child)
+			return validationErr != nil
+		})
+	}
+	walk(node)
+	return validationErr
+}
+
+func (template expressionTemplate) materialize(ec *shimprinter.EmitContext, imports *astImportRegistry) *shimast.Node {
+	if template.parsed == nil {
+		panic("tsf metadata compiler: nil expression template")
+	}
+	cloned := ec.Factory.DeepCloneNode(template.parsed)
+	var visitor *shimast.NodeVisitor
+	visitor = ec.NewNodeVisitor(func(node *shimast.Node) *shimast.Node {
+		if node == nil {
+			return nil
+		}
+		if replacement := materializeRuntimePlaceholder(node, imports); replacement != nil {
+			return replacement
+		}
+		return visitor.VisitEachChild(node)
+	})
+	result := visitor.VisitNode(cloned)
+	if containsRuntimePlaceholder(result) {
+		panic("tsf metadata compiler: runtime placeholder survived AST materialization")
+	}
+	return result
+}
+
+func materializeRuntimePlaceholder(node *shimast.Node, imports *astImportRegistry) *shimast.Node {
+	if node.Kind != shimast.KindCallExpression {
+		return nil
+	}
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindIdentifier || call.Arguments == nil {
+		return nil
+	}
+	args := call.Arguments.Nodes
+	switch call.Expression.Text() {
+	case runtimeNamespacePlaceholderName:
+		if len(args) == 2 && shimast.IsStringLiteral(args[0]) && shimast.IsStringLiteral(args[1]) {
+			return imports.namespace(args[0].Text(), args[1].Text())
+		}
+	case runtimeImportPlaceholderName:
+		if len(args) == 3 && shimast.IsStringLiteral(args[0]) && shimast.IsStringLiteral(args[1]) && shimast.IsStringLiteral(args[2]) {
+			return imports.member(args[0].Text(), args[1].Text(), args[2].Text())
+		}
+	case runtimeAliasPlaceholderName:
+		if len(args) == 3 && shimast.IsStringLiteral(args[0]) && shimast.IsStringLiteral(args[1]) && shimast.IsStringLiteral(args[2]) {
+			arguments := []*shimast.Node{}
+			if imports.commonJS {
+				arguments = append(arguments,
+					imports.ec.Factory.NewIdentifier("require"),
+					imports.ec.Factory.NewStringLiteral(imports.resolvedSpecifier(args[0].Text(), ""), shimast.TokenFlagsNone),
+				)
+			} else {
+				arguments = append(arguments, imports.optionalModuleLoader(args[0].Text(), ""))
+			}
+			arguments = append(arguments,
+				imports.ec.Factory.NewStringLiteral(args[1].Text(), shimast.TokenFlagsNone),
+				imports.ec.Factory.NewStringLiteral(args[2].Text(), shimast.TokenFlagsNone),
+			)
+			return imports.ec.Factory.NewCallExpression(
+				imports.staticMember(compactMetadataRuntimeSpec, compactMetadataAliasResolverName),
+				nil,
+				nil,
+				imports.ec.Factory.NewNodeList(arguments),
+				shimast.NodeFlagsNone,
+			)
+		}
+	}
+	return nil
+}
+
+func containsRuntimePlaceholder(node *shimast.Node) bool {
+	found := false
+	var walk func(*shimast.Node)
+	walk = func(current *shimast.Node) {
+		if current == nil || found {
+			return
+		}
+		if current.Kind == shimast.KindIdentifier {
+			name := current.Text()
+			if name == runtimeImportPlaceholderName || name == runtimeNamespacePlaceholderName || name == runtimeAliasPlaceholderName {
+				found = true
+				return
+			}
+		}
+		current.ForEachChild(func(child *shimast.Node) bool {
+			walk(child)
+			return found
+		})
+	}
+	walk(node)
+	return found
+}

package/dist/type-compiler/go/ast_metadata.go

@@ -0,0 +1,388 @@
+package main
+
+import (
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+func resolveImport(fromFile string, spec string, reg *registry) *fileInfo {
+	if !strings.HasPrefix(spec, ".") {
+		if spec == reflectionPackageSpec {
+			return resolveReflectionPackageImport(reg)
+		}
+		return nil
+	}
+	base := filepath.Clean(filepath.Join(filepath.Dir(fromFile), spec))
+	ext := strings.ToLower(filepath.Ext(base))
+	withoutExt := strings.TrimSuffix(base, filepath.Ext(base))
+	candidates := []string{}
+	switch ext {
+	case ".mjs":
+		candidates = append(candidates, moduleKey(withoutExt+".mts"), moduleKey(withoutExt+".d.mts"))
+	case ".cjs":
+		candidates = append(candidates, moduleKey(withoutExt+".cts"), moduleKey(withoutExt+".d.cts"))
+	case ".js":
+		candidates = append(candidates, moduleKey(withoutExt+".ts"), moduleKey(withoutExt+".tsx"), moduleKey(withoutExt+".d.ts"))
+	default:
+		candidates = append(candidates,
+			moduleKey(base),
+			moduleKey(base+".ts"),
+			moduleKey(base+".tsx"),
+			moduleKey(base+".mts"),
+			moduleKey(base+".cts"),
+			moduleKey(base+".d.ts"),
+			moduleKey(base+".d.mts"),
+			moduleKey(base+".d.cts"),
+			moduleKey(filepath.Join(base, "index.ts")),
+			moduleKey(filepath.Join(base, "index.mts")),
+			moduleKey(filepath.Join(base, "index.cts")),
+			moduleKey(filepath.Join(base, "index.d.ts")),
+			moduleKey(filepath.Join(base, "index.d.mts")),
+			moduleKey(filepath.Join(base, "index.d.cts")),
+		)
+	}
+	for _, candidate := range candidates {
+		if info := reg.byPath[candidate]; info != nil {
+			return info
+		}
+	}
+	return nil
+}
+
+func resolveReflectionPackageImport(reg *registry) *fileInfo {
+	for _, info := range reg.files {
+		fileName := filepath.ToSlash(info.file.FileName())
+		if strings.HasSuffix(fileName, "/@zyno-io/ts-reflection/dist/index.d.ts") ||
+			strings.HasSuffix(fileName, "/packages/reflection/dist/index.d.ts") {
+			return info
+		}
+	}
+	return nil
+}
+
+func classFromNode(info *fileInfo, node *shimast.Node) *classInfo {
+	file := info.file
+	nameNode := node.Name()
+	if nameNode == nil {
+		return nil
+	}
+	class := &classInfo{
+		name:                 nameNode.Text(),
+		pos:                  node.Pos(),
+		end:                  node.End(),
+		ambient:              node.ModifierFlags()&shimast.ModifierFlagsAmbient != 0 || node.Flags&shimast.NodeFlagsAmbient != 0,
+		decoratedMethodsOnly: info.decoratedMethodsOnly,
+	}
+	for _, member := range node.Members() {
+		if member.ModifierFlags()&shimast.ModifierFlagsPrivate != 0 {
+			continue
+		}
+		switch member.Kind {
+		case shimast.KindPropertyDeclaration:
+			if isStaticMember(file, member) {
+				continue
+			}
+			name := memberName(file, member)
+			if name == "" {
+				continue
+			}
+			class.properties = append(class.properties, propertyInfo{
+				name:     name,
+				typeText: nodeText(file, member.Type()),
+				typeNode: member.Type(),
+				optional: member.QuestionToken() != nil,
+			})
+		case shimast.KindMethodDeclaration:
+			name := memberName(file, member)
+			if name == "" {
+				continue
+			}
+			preferTypia := isHttpRouteMethod(info, member)
+			method := methodInfo{
+				name:           name,
+				description:    jsDocDescription(file, member),
+				typeParams:     typeParameterNames(member),
+				returnType:     nodeText(file, member.Type()),
+				returnTypeNode: member.Type(),
+				preferTypia:    preferTypia,
+				decorated:      len(member.Decorators()) != 0,
+				params:         paramsFromNode(file, member),
+			}
+			if isStaticMember(file, member) {
+				class.staticMethods = append(class.staticMethods, method)
+			} else {
+				class.methods = append(class.methods, method)
+			}
+		case shimast.KindConstructor:
+			class.ctor = paramsFromNode(file, member)
+			class.hasCtor = true
+		}
+	}
+	return class
+}
+
+func functionFromNode(file *shimast.SourceFile, node *shimast.Node) functionInfo {
+	nameNode := node.Name()
+	if nameNode == nil {
+		return functionInfo{}
+	}
+	return functionInfo{
+		name:       nameNode.Text(),
+		typeParams: typeParameterNames(node),
+		params:     paramsFromNode(file, node),
+		pos:        node.Pos(),
+	}
+}
+
+func typeParameterNames(node *shimast.Node) []string {
+	params := []string{}
+	for _, param := range node.TypeParameters() {
+		if param.Name() != nil {
+			params = append(params, param.Name().Text())
+		}
+	}
+	return params
+}
+
+func isHttpRouteMethod(info *fileInfo, member *shimast.Node) bool {
+	for _, decorator := range member.Decorators() {
+		if decorator.Kind != shimast.KindDecorator {
+			continue
+		}
+		if isHttpRouteDecoratorExpression(info, decorator.AsDecorator().Expression.AsNode()) {
+			return true
+		}
+	}
+	return false
+}
+
+func isHttpRouteDecoratorExpression(info *fileInfo, expr *shimast.Node) bool {
+	if expr == nil {
+		return false
+	}
+	switch expr.Kind {
+	case shimast.KindParenthesizedExpression:
+		return isHttpRouteDecoratorExpression(info, expr.Expression())
+	case shimast.KindCallExpression:
+		callee := expr.Expression()
+		if isHttpRouteCallee(info, callee) {
+			return true
+		}
+		return isHttpRouteDecoratorExpression(info, callee)
+	case shimast.KindPropertyAccessExpression:
+		if isHttpRouteCallee(info, expr) {
+			return true
+		}
+		return isHttpRouteDecoratorExpression(info, expr.Expression())
+	default:
+		return false
+	}
+}
+
+func isHttpRouteCallee(info *fileInfo, callee *shimast.Node) bool {
+	if callee == nil {
+		return false
+	}
+	switch callee.Kind {
+	case shimast.KindIdentifier:
+		name := callee.Text()
+		return isHttpVerb(name) && isDirectHttpVerbImport(info, name)
+	case shimast.KindPropertyAccessExpression:
+		access := callee.AsPropertyAccessExpression()
+		name := access.Name()
+		return name != nil && isHttpVerb(name.Text()) && isHttpNamespaceExpression(info, access.Expression.AsNode())
+	default:
+		return false
+	}
+}
+
+func isHttpNamespaceExpression(info *fileInfo, expr *shimast.Node) bool {
+	for expr != nil && expr.Kind == shimast.KindParenthesizedExpression {
+		expr = expr.Expression()
+	}
+	if expr == nil || expr.Kind != shimast.KindIdentifier {
+		return false
+	}
+	return isHttpNamespaceImport(info, expr.Text())
+}
+
+func isHttpNamespaceImport(info *fileInfo, name string) bool {
+	if name != "http" {
+		return false
+	}
+	ref, ok := info.imports[name]
+	return ok && ref.exportName == "http" && isFoundationHttpImport(ref)
+}
+
+func isDirectHttpVerbImport(info *fileInfo, name string) bool {
+	ref, ok := info.imports[name]
+	return ok && ref.exportName == name && isFoundationHttpImport(ref)
+}
+
+func isFoundationHttpImport(ref importRef) bool {
+	spec := filepath.ToSlash(ref.spec)
+	source := filepath.ToSlash(ref.source)
+	if strings.HasSuffix(source, "/src/index") ||
+		strings.HasSuffix(source, "/src/http") ||
+		strings.HasSuffix(source, "/src/http/index") ||
+		strings.HasSuffix(source, "/src/http/decorators") {
+		return true
+	}
+	return spec == foundationPackageSpec
+}
+
+func isHttpVerb(name string) bool {
+	switch name {
+	case "GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD":
+		return true
+	default:
+		return false
+	}
+}
+
+func isStaticMember(file *shimast.SourceFile, member *shimast.Node) bool {
+	return member.ModifierFlags()&shimast.ModifierFlagsStatic != 0
+}
+
+func memberName(file *shimast.SourceFile, member *shimast.Node) string {
+	name := member.Name()
+	if name == nil {
+		return ""
+	}
+	text := strings.TrimSpace(stripTypeComments(nodeText(file, name)))
+	if text == "" || strings.HasPrefix(text, "[") || strings.HasPrefix(text, "{") {
+		return ""
+	}
+	if len(text) >= 2 {
+		quote := text[0]
+		if (quote == '\'' || quote == '"' || quote == '`') && text[len(text)-1] == quote {
+			unquoted, err := strconv.Unquote(text)
+			if err == nil {
+				return unquoted
+			}
+			return strings.Trim(text, "'\"`")
+		}
+	}
+	return text
+}
+
+func paramsFromNode(file *shimast.SourceFile, node *shimast.Node) []paramInfo {
+	params := []paramInfo{}
+	for _, param := range node.Parameters() {
+		name := memberName(file, param)
+		if name == "" {
+			name = "arg"
+		}
+		params = append(params, paramInfo{
+			name:       name,
+			typeText:   nodeText(file, param.Type()),
+			typeNode:   param.Type(),
+			optional:   param.QuestionToken() != nil || param.Initializer() != nil,
+			hasDefault: param.Initializer() != nil,
+		})
+	}
+	return params
+}
+
+func nodeText(file *shimast.SourceFile, node *shimast.Node) string {
+	if node == nil {
+		return "unknown"
+	}
+	return strings.TrimSpace(stripTypeComments(file.Text()[node.Pos():node.End()]))
+}
+
+func jsDocDescription(file *shimast.SourceFile, node *shimast.Node) string {
+	docs := node.JSDoc(file)
+	if len(docs) == 0 {
+		return ""
+	}
+	doc := docs[len(docs)-1]
+	return cleanJsDocDescription(file.Text()[doc.Pos():doc.End()])
+}
+
+func cleanJsDocDescription(raw string) string {
+	raw = strings.TrimSpace(raw)
+	raw = strings.TrimPrefix(raw, "/**")
+	raw = strings.TrimSuffix(raw, "*/")
+	lines := strings.Split(raw, "\n")
+	parts := []string{}
+	for _, line := range lines {
+		line = strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(line), "*"))
+		if strings.HasPrefix(line, "@") {
+			break
+		}
+		if line == "" {
+			if len(parts) > 0 {
+				break
+			}
+			continue
+		}
+		parts = append(parts, line)
+	}
+	return strings.Join(parts, " ")
+}
+
+func classMetadata(info *fileInfo, reg *registry, class *classInfo, typeRef func(string) string) string {
+	props := []string{}
+	for _, prop := range class.properties {
+		items := []string{
+			"name: " + quote(prop.name),
+			"type: " + referMetadataType(typeRef, cachedTypeExpr(info, reg, prop.typeText, prop.typeNode, class.pos, prop.metadataText)),
+			"optional: " + boolLit(prop.optional),
+		}
+		flags := collectFlags(info, reg, prop.typeText)
+		if flags["primaryKey"] != "" {
+			items = append(items, "primaryKey: true")
+		}
+		if flags["autoIncrement"] != "" {
+			items = append(items, "autoIncrement: true")
+		}
+		for _, key := range []string{"reference", "index", "unique"} {
+			if value := flags[key]; value != "" {
+				items = append(items, key+": "+value)
+			}
+		}
+		props = append(props, "{"+strings.Join(items, ", ")+"}")
+	}
+	methods := []string{}
+	for _, method := range class.methods {
+		if class.decoratedMethodsOnly && !method.decorated {
+			continue
+		}
+		items := []string{
+			"name: " + quote(method.name),
+			"parameters: " + paramsExpr(info, reg, method.params, class.pos, typeRef),
+			"returnType: " + referMetadataType(typeRef, cachedTypeExpr(info, reg, method.returnType, method.returnTypeNode, class.pos, method.returnMetadataText)),
+		}
+		if method.description != "" {
+			items = append(items, "description: "+quote(method.description))
+		}
+		methods = append(methods, "{"+strings.Join(items, ", ")+"}")
+	}
+	return "{kind: 16, name: " + quote(class.name) +
+		", typeName: " + quote(class.name) +
+		", classType: () => " + class.name +
+		", properties: [" + strings.Join(props, ", ") + "]" +
+		", methods: [" + strings.Join(methods, ", ") + "]" +
+		", hasConstructor: " + boolLit(class.hasCtor) +
+		", constructorParameters: " + paramsExpr(info, reg, class.ctor, class.pos, typeRef) + "}"
+}
+
+func paramsExpr(info *fileInfo, reg *registry, params []paramInfo, pos int, typeRef func(string) string) string {
+	out := []string{}
+	for _, param := range params {
+		typeExpr := referMetadataType(typeRef, cachedTypeExpr(info, reg, param.typeText, param.typeNode, pos, param.metadataText))
+		out = append(out, "{name: "+quote(param.name)+", type: "+typeExpr+", optional: "+boolLit(param.optional)+", default: "+boolLit(param.hasDefault)+"}")
+	}
+	return "[" + strings.Join(out, ", ") + "]"
+}
+
+func referMetadataType(typeRef func(string) string, expr string) string {
+	if typeRef == nil {
+		return expr
+	}
+	return typeRef(expr)
+}