typenative 0.2.0 → 0.3.0

package/tsparser/check.go

@@ -0,0 +1,157 @@
+// Type-checking for the self-hosted compiler (`tsparser --check`): the same
+// program the Node CLI checks with the typescript package (src/typecheck-node.ts),
+// built with typescript-go. Prints the errors as a JSON array.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/buke/typescript-go-internal/pkg/ast"
+	"github.com/buke/typescript-go-internal/pkg/bundled"
+	"github.com/buke/typescript-go-internal/pkg/compiler"
+	"github.com/buke/typescript-go-internal/pkg/core"
+	"github.com/buke/typescript-go-internal/pkg/diagnostics"
+	"github.com/buke/typescript-go-internal/pkg/diagnosticwriter"
+	"github.com/buke/typescript-go-internal/pkg/locale"
+	"github.com/buke/typescript-go-internal/pkg/scanner"
+	"github.com/buke/typescript-go-internal/pkg/tsoptions"
+	"github.com/buke/typescript-go-internal/pkg/tspath"
+	"github.com/buke/typescript-go-internal/pkg/vfs"
+	"github.com/buke/typescript-go-internal/pkg/vfs/osvfs"
+)
+
+// checkDiagnostic is one error, in the shape src/parse-native.ts reads
+// (file is absolute; line and column are 1-based, 0 for global errors)
+type checkDiagnostic struct {
+	File    string `json:"file"`
+	Line    int    `json:"line"`
+	Column  int    `json:"column"`
+	Code    int32  `json:"code"`
+	Message string `json:"message"`
+}
+
+type configHost struct {
+	fs  vfs.FS
+	cwd string
+}
+
+func (h configHost) FS() vfs.FS                 { return h.fs }
+func (h configHost) GetCurrentDirectory() string { return h.cwd }
+
+// The bundled declarations that replace the default lib (types/ in the package)
+var typenativeTypes = []string{"typenative.d.ts", "typenative-go.d.ts", "typenative-npm.d.ts"}
+
+// TS18003: "No inputs were found in config file" (only the entry is checked)
+const noInputsFound = 18003
+
+// runCheck type-checks entry with the nearest tsconfig.json's options (or
+// TypeNative's defaults) and prints the errors. The program's roots are the
+// entry plus the config's .d.ts files, so other entry points in the same
+// project don't redeclare each other's globals.
+func runCheck(entry string, typesDir string) {
+	wd, err := os.Getwd()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "getwd:", err)
+		os.Exit(1)
+	}
+	cwd := tspath.NormalizePath(wd)
+	fs := bundled.WrapFS(osvfs.FS())
+	entryPath := tspath.GetNormalizedAbsolutePath(entry, cwd)
+	roots := []string{entryPath}
+	out := []checkDiagnostic{}
+
+	var options *core.CompilerOptions
+	if configPath := findConfigFile(fs, tspath.GetDirectoryPath(entryPath)); configPath != "" {
+		parsed, errs := tsoptions.GetParsedCommandLineOfConfigFile(configPath, &core.CompilerOptions{}, nil, configHost{fs, cwd}, nil)
+		for _, d := range errs {
+			out = append(out, toCheckDiagnostic(d))
+		}
+		if parsed == nil {
+			printDiagnostics(out)
+			return
+		}
+		for _, d := range parsed.Errors {
+			if d.Code() != noInputsFound {
+				out = append(out, toCheckDiagnostic(d))
+			}
+		}
+		options = parsed.CompilerOptions()
+		for _, name := range parsed.FileNames() {
+			if tspath.IsDeclarationFileName(name) && name != entryPath {
+				roots = append(roots, name)
+			}
+		}
+	} else {
+		options = &core.CompilerOptions{
+			Target:                       core.ScriptTargetES2020,
+			Module:                       core.ModuleKindESNext,
+			ModuleResolution:             core.ModuleResolutionKindBundler,
+			Lib:                          []string{},
+			Types:                        []string{},
+			Strict:                       core.TSTrue,
+			NoImplicitAny:                core.TSTrue,
+			AllowSyntheticDefaultImports: core.TSTrue,
+			AllowImportingTsExtensions:   core.TSTrue,
+			Jsx:                          core.JsxEmitPreserve,
+			SkipLibCheck:                 core.TSTrue,
+		}
+		typesPath := tspath.GetNormalizedAbsolutePath(typesDir, cwd)
+		for _, name := range typenativeTypes {
+			roots = append(roots, tspath.CombinePaths(typesPath, name))
+		}
+	}
+	options.NoEmit = core.TSTrue
+
+	config := tsoptions.NewParsedCommandLine(options, roots, tspath.ComparePathsOptions{
+		UseCaseSensitiveFileNames: fs.UseCaseSensitiveFileNames(),
+		CurrentDirectory:          cwd,
+	})
+	host := compiler.NewCompilerHost(cwd, fs, bundled.LibPath(), nil, nil)
+	program := compiler.NewProgram(compiler.ProgramOptions{Config: config, Host: host})
+	ctx := context.Background()
+	for _, d := range compiler.GetDiagnosticsOfAnyProgram(ctx, program, nil, false, program.GetBindDiagnostics, program.GetSemanticDiagnostics) {
+		if d.Category() == diagnostics.CategoryError {
+			out = append(out, toCheckDiagnostic(d))
+		}
+	}
+	printDiagnostics(out)
+}
+
+// findConfigFile walks up from dir to the nearest tsconfig.json
+func findConfigFile(fs vfs.FS, dir string) string {
+	for {
+		candidate := tspath.CombinePaths(dir, "tsconfig.json")
+		if fs.FileExists(candidate) {
+			return candidate
+		}
+		parent := tspath.GetDirectoryPath(dir)
+		if parent == dir {
+			return ""
+		}
+		dir = parent
+	}
+}
+
+func toCheckDiagnostic(d *ast.Diagnostic) checkDiagnostic {
+	out := checkDiagnostic{
+		Code:    d.Code(),
+		Message: diagnosticwriter.FlattenDiagnosticMessage(&diagnosticwriter.ASTDiagnostic{Diagnostic: d}, "\n", locale.Default),
+	}
+	if file := d.File(); file != nil {
+		line, character := scanner.GetECMALineAndUTF16CharacterOfPosition(file, d.Pos())
+		out.File = file.FileName()
+		out.Line = line + 1
+		out.Column = int(character) + 1
+	}
+	return out
+}
+
+func printDiagnostics(out []checkDiagnostic) {
+	if err := json.NewEncoder(os.Stdout).Encode(out); err != nil {
+		fmt.Fprintln(os.Stderr, "encode:", err)
+		os.Exit(1)
+	}
+}

package/tsparser/main.go

@@ -6,6 +6,8 @@
 // the same transpiler code can consume ASTs from either source.
 //
 // Usage: tsparser < file.ts > ast.json
+//
+//	tsparser --check <file.ts> <types dir>   type-checks a program (see check.go)
 package main
 
 import (
@@ -25,7 +27,18 @@ import (
 // The parsed source, for template raw text
 var sourceText string
 
+// The parsed file, for node positions
+var parsedFile *ast.SourceFile
+
 func main() {
+	if len(os.Args) > 1 && os.Args[1] == "--check" {
+		if len(os.Args) < 4 {
+			fmt.Fprintln(os.Stderr, "usage: tsparser --check <file.ts> <types dir>")
+			os.Exit(2)
+		}
+		runCheck(os.Args[2], os.Args[3])
+		return
+	}
 	sourceBytes, err := io.ReadAll(os.Stdin)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "read stdin:", err)
@@ -44,6 +57,7 @@ func main() {
 		string(sourceBytes),
 		scriptKind,
 	)
+	parsedFile = sourceFile
 	out := serializeNode(sourceFile.AsNode())
 	enc := json.NewEncoder(os.Stdout)
 	enc.SetIndent("", "  ")
@@ -126,6 +140,7 @@ func serializeNode(n *ast.Node) any {
 	inProgress[n] = true
 	defer delete(inProgress, n)
 	obj := map[string]any{"kind": strings.TrimPrefix(n.Kind.String(), "Kind")}
+	setPosition(n, obj)
 	// SourceFile bookkeeping fields are not part of the language AST
 	if n.Kind == ast.KindSourceFile {
 		statements := []any{}
@@ -166,7 +181,9 @@ func serializeNode(n *ast.Node) any {
 	// BindingElement; the TypeScript API exposes them as OmittedExpression
 	if n.Kind == ast.KindBindingElement {
 		if be := n.AsBindingElement(); be != nil && be.Name() == nil && be.DotDotDotToken == nil {
-			return map[string]any{"kind": "OmittedExpression"}
+			hole := map[string]any{"kind": "OmittedExpression"}
+			setPosition(n, hole)
+			return hole
 		}
 	}
 
@@ -194,6 +211,18 @@ func serializeNode(n *ast.Node) any {
 	return obj
 }
 
+// setPosition records the 1-based line and column of the node's first token
+// (columns count UTF-16 units, as in the TypeScript API); the transpiler maps
+// Go positions back to them
+func setPosition(n *ast.Node, obj map[string]any) {
+	if n.Kind == ast.KindSourceFile || n.Pos() < 0 || parsedFile == nil {
+		return
+	}
+	line, character := scanner.GetECMALineAndUTF16CharacterOfPosition(parsedFile, scanner.GetTokenPosOfNode(n, parsedFile, false))
+	obj["line"] = line + 1
+	obj["column"] = int(character) + 1
+}
+
 // collectFields serializes a typed data struct's fields into obj, recursing
 // into embedded base structs (DeclarationBase, FunctionLikeBase, ...) so their
 // fields are hoisted like the TypeScript API exposes them.

package/types/typenative-npm.d.ts

@@ -2463,11 +2463,14 @@ declare module 'node:sqlite' {
       useBigIntArguments?: boolean;
       varargs?: boolean;
     }
+    // Callbacks get each SQL argument converted to the type their parameter
+    // declares ((x: number) => …), so their arguments are typed `any` here
+    // rather than SQLOutputValue as in @types/node
     interface AggregateOptions<T extends SQLInputValue = SQLInputValue> extends FunctionOptions {
       start: T | (() => T);
-      step: (accumulator: T, ...args: SQLOutputValue[]) => T;
+      step: (accumulator: T, ...args: any[]) => T;
       result?: (accumulator: T) => SQLInputValue;
-      inverse?: (accumulator: T, ...args: SQLOutputValue[]) => T;
+      inverse?: (accumulator: T, ...args: any[]) => T;
     }
     interface PrepareOptions {
       readBigInts?: boolean;
@@ -2488,8 +2491,8 @@ declare module 'node:sqlite' {
       exec(sql: string): void;
       prepare(sql: string, options?: PrepareOptions): StatementSync;
       location(dbName?: string): string | null;
-      function(name: string, options: FunctionOptions, fn: (...args: SQLOutputValue[]) => SQLInputValue): void;
-      function(name: string, fn: (...args: SQLOutputValue[]) => SQLInputValue): void;
+      function(name: string, options: FunctionOptions, fn: (...args: any[]) => SQLInputValue): void;
+      function(name: string, fn: (...args: any[]) => SQLInputValue): void;
       aggregate(name: string, options: AggregateOptions): void;
       aggregate<T extends SQLInputValue>(name: string, options: AggregateOptions<T>): void;
       setAuthorizer(