@tsonic/frontend 0.0.1 → 0.0.4

package/src/program/dependency-graph.ts

@@ -1,245 +0,0 @@
-/**
- * Dependency graph builder - Multi-file compilation
- * Traverses local imports using ts.resolveModuleName()
- */
-
-import * as ts from "typescript";
-import { relative, resolve } from "path";
-import { Result, ok, error } from "../types/result.js";
-import { Diagnostic, createDiagnostic } from "../types/diagnostic.js";
-import { IrModule } from "../ir/types.js";
-import { buildIrModule } from "../ir/builder/orchestrator.js";
-import { createProgram, createCompilerOptions } from "./creation.js";
-import { CompilerOptions } from "./types.js";
-
-export type ModuleDependencyGraphResult = {
-  readonly modules: readonly IrModule[];
-  readonly entryModule: IrModule;
-};
-
-/**
- * Extract module specifier from import or re-export declaration
- * Returns the module specifier string literal, or null if not applicable
- */
-const getModuleSpecifier = (stmt: ts.Statement): ts.StringLiteral | null => {
-  // Handle: import { x } from "./module"
-  if (
-    ts.isImportDeclaration(stmt) &&
-    ts.isStringLiteral(stmt.moduleSpecifier)
-  ) {
-    return stmt.moduleSpecifier;
-  }
-
-  // Handle: export { x } from "./module" (re-exports)
-  if (
-    ts.isExportDeclaration(stmt) &&
-    stmt.moduleSpecifier &&
-    ts.isStringLiteral(stmt.moduleSpecifier)
-  ) {
-    return stmt.moduleSpecifier;
-  }
-
-  return null;
-};
-
-/**
- * Build complete module dependency graph from entry point
- * Traverses all local imports and builds IR for all discovered modules
- * Uses TypeScript's ts.resolveModuleName() for correct module resolution
- */
-export const buildModuleDependencyGraph = (
-  entryFile: string,
-  options: CompilerOptions
-): Result<ModuleDependencyGraphResult, readonly Diagnostic[]> => {
-  const diagnostics: Diagnostic[] = [];
-
-  // Normalize entry file and source root to absolute paths
-  const entryAbs = resolve(entryFile);
-  const sourceRootAbs = resolve(options.sourceRoot);
-
-  // Get TypeScript compiler options for module resolution
-  const compilerOptions = createCompilerOptions(options);
-
-  // Track all discovered files for later type checking
-  const allDiscoveredFiles: string[] = [];
-
-  // BFS to discover all local imports
-  const visited = new Set<string>();
-  const queue: string[] = [entryAbs];
-
-  // First pass: discover all files
-  while (queue.length > 0) {
-    const currentFile = queue.shift()!;
-
-    // Dedup by realpath (handles symlinks, relative paths)
-    const realPath = ts.sys.realpath?.(currentFile) ?? currentFile;
-    if (visited.has(realPath)) {
-      continue;
-    }
-    visited.add(realPath);
-    allDiscoveredFiles.push(realPath);
-
-    // Read source file directly from filesystem
-    const sourceText = ts.sys.readFile(currentFile);
-    if (!sourceText) {
-      // Missing file - add diagnostic but continue traversal
-      const relativeCurrent = relative(sourceRootAbs, currentFile);
-      diagnostics.push(
-        createDiagnostic(
-          "TSN1002",
-          "error",
-          `Cannot find module '${relativeCurrent}'`,
-          {
-            file: currentFile,
-            line: 1,
-            column: 1,
-            length: 1,
-          }
-        )
-      );
-      continue;
-    }
-
-    // Parse source file to extract imports
-    const sourceFile = ts.createSourceFile(
-      currentFile,
-      sourceText,
-      ts.ScriptTarget.Latest,
-      true
-    );
-
-    // Extract local imports and re-exports using TypeScript's resolution
-    for (const stmt of sourceFile.statements) {
-      // Handle import declarations: import { x } from "./module"
-      // Handle re-export declarations: export { x } from "./module"
-      const moduleSpecifier = getModuleSpecifier(stmt);
-      if (!moduleSpecifier) {
-        continue;
-      }
-
-      const importSpecifier = moduleSpecifier.text;
-
-      // Only process local imports (starts with . or /)
-      if (
-        !importSpecifier.startsWith(".") &&
-        !importSpecifier.startsWith("/")
-      ) {
-        continue;
-      }
-
-      // Resolve using TypeScript's module resolution
-      const resolved = ts.resolveModuleName(
-        importSpecifier,
-        currentFile,
-        compilerOptions,
-        ts.sys
-      );
-
-      if (resolved.resolvedModule?.resolvedFileName) {
-        const resolvedPath = resolved.resolvedModule.resolvedFileName;
-
-        // Only include .ts files (not .d.ts) within source root
-        if (
-          resolvedPath.startsWith(sourceRootAbs) &&
-          resolvedPath.endsWith(".ts") &&
-          !resolvedPath.endsWith(".d.ts")
-        ) {
-          queue.push(resolvedPath);
-        }
-      } else {
-        // Import resolution failed - add diagnostic with context
-        const relativeCurrent = relative(sourceRootAbs, currentFile);
-        diagnostics.push(
-          createDiagnostic(
-            "TSN1002",
-            "error",
-            `Cannot resolve import '${importSpecifier}' from '${relativeCurrent}'`,
-            {
-              file: currentFile,
-              line: stmt.getStart(sourceFile),
-              column: 1,
-              length: importSpecifier.length,
-            }
-          )
-        );
-      }
-    }
-  }
-
-  // If any diagnostics from discovery, fail the build
-  if (diagnostics.length > 0) {
-    return error(diagnostics);
-  }
-
-  // Ensure we discovered at least the entry file
-  if (allDiscoveredFiles.length === 0) {
-    return error([
-      createDiagnostic(
-        "TSN1002",
-        "error",
-        `No modules found starting from entry point '${entryFile}'`,
-        {
-          file: entryFile,
-          line: 1,
-          column: 1,
-          length: 1,
-        }
-      ),
-    ]);
-  }
-
-  // Second pass: Create TypeScript program with all discovered files for type checking
-  // Use absolute sourceRoot for consistency
-  const programResult = createProgram(allDiscoveredFiles, {
-    ...options,
-    sourceRoot: sourceRootAbs,
-  });
-
-  if (!programResult.ok) {
-    return error(programResult.error.diagnostics);
-  }
-
-  const tsonicProgram = programResult.value;
-
-  // Third pass: Build IR for all discovered modules
-  const modules: IrModule[] = [];
-
-  for (const filePath of allDiscoveredFiles) {
-    const sourceFile = tsonicProgram.program.getSourceFile(filePath);
-    if (!sourceFile) {
-      // This shouldn't happen since we already verified files exist
-      continue;
-    }
-
-    const moduleResult = buildIrModule(sourceFile, tsonicProgram, {
-      sourceRoot: sourceRootAbs,
-      rootNamespace: options.rootNamespace,
-    });
-
-    if (!moduleResult.ok) {
-      diagnostics.push(moduleResult.error);
-      continue;
-    }
-
-    modules.push(moduleResult.value);
-  }
-
-  // If any diagnostics from IR building, fail the build
-  if (diagnostics.length > 0) {
-    return error(diagnostics);
-  }
-
-  // Sort modules by relative path for deterministic output
-  modules.sort((a, b) => a.filePath.localeCompare(b.filePath));
-
-  // Entry module is the first one (after sorting, it should be the entry file)
-  // But let's find it by matching the entry file path
-  const entryRelative = relative(sourceRootAbs, entryAbs).replace(/\\/g, "/");
-  const entryModule =
-    modules.find((m) => m.filePath === entryRelative) ?? modules[0]!;
-
-  return ok({
-    modules,
-    entryModule,
-  });
-};

package/src/program/diagnostics.ts

@@ -1,103 +0,0 @@
-/**
- * TypeScript diagnostics collection and conversion
- */
-
-import * as ts from "typescript";
-import {
-  Diagnostic,
-  DiagnosticsCollector,
-  createDiagnosticsCollector,
-  addDiagnostic,
-  createDiagnostic,
-} from "../types/diagnostic.js";
-
-/**
- * Collect all TypeScript diagnostics from a program
- */
-export const collectTsDiagnostics = (
-  program: ts.Program
-): DiagnosticsCollector => {
-  const tsDiagnostics = [
-    ...program.getConfigFileParsingDiagnostics(),
-    ...program.getOptionsDiagnostics(),
-    ...program.getSyntacticDiagnostics(),
-    ...program.getGlobalDiagnostics(),
-    ...program.getSemanticDiagnostics(),
-  ];
-
-  return tsDiagnostics.reduce((collector, tsDiag) => {
-    const diagnostic = convertTsDiagnostic(tsDiag);
-    return diagnostic ? addDiagnostic(collector, diagnostic) : collector;
-  }, createDiagnosticsCollector());
-};
-
-/**
- * Convert TypeScript diagnostic to Tsonic diagnostic
- */
-export const convertTsDiagnostic = (
-  tsDiag: ts.Diagnostic
-): Diagnostic | null => {
-  if (tsDiag.category === ts.DiagnosticCategory.Suggestion) {
-    return null; // Ignore suggestions
-  }
-
-  const message = ts.flattenDiagnosticMessageText(tsDiag.messageText, "\n");
-
-  // Ignore "type used as value" errors for .NET types
-  // These are handled by the Tsonic compiler
-  if (
-    message.includes("only refers to a type, but is being used as a value") &&
-    tsDiag.file
-  ) {
-    // Check if this is a .NET import
-    const sourceText = tsDiag.file.getText();
-    if (
-      sourceText.includes('from "System') ||
-      sourceText.includes('from "Microsoft') ||
-      sourceText.includes('from "Windows')
-    ) {
-      return null; // Ignore - will be handled by Tsonic
-    }
-  }
-
-  const severity =
-    tsDiag.category === ts.DiagnosticCategory.Error
-      ? "error"
-      : tsDiag.category === ts.DiagnosticCategory.Warning
-        ? "warning"
-        : "info";
-
-  const location =
-    tsDiag.file && tsDiag.start !== undefined
-      ? getSourceLocation(tsDiag.file, tsDiag.start, tsDiag.length ?? 1)
-      : undefined;
-
-  return createDiagnostic(
-    "TSN2001", // Generic TypeScript error
-    severity,
-    message,
-    location
-  );
-};
-
-/**
- * Get source location information from TypeScript source file
- */
-export const getSourceLocation = (
-  file: ts.SourceFile,
-  start: number,
-  length: number
-): {
-  readonly file: string;
-  readonly line: number;
-  readonly column: number;
-  readonly length: number;
-} => {
-  const { line, character } = file.getLineAndCharacterOfPosition(start);
-  return {
-    file: file.fileName,
-    line: line + 1,
-    column: character + 1,
-    length,
-  };
-};

package/src/program/metadata.ts

@@ -1,68 +0,0 @@
-/**
- * .NET metadata file loading
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import {
-  DotnetMetadataRegistry,
-  DotnetMetadataFile,
-} from "../dotnet-metadata.js";
-
-/**
- * Recursively scan a directory for .d.ts files
- */
-const scanForDeclarationFiles = (dir: string): readonly string[] => {
-  if (!fs.existsSync(dir)) {
-    return [];
-  }
-
-  const results: string[] = [];
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...scanForDeclarationFiles(fullPath));
-    } else if (entry.name.endsWith(".d.ts")) {
-      results.push(fullPath);
-    }
-  }
-
-  return results;
-};
-
-/**
- * Load .NET metadata files from configured type roots
- * Looks for *.metadata.json files alongside .d.ts files
- */
-export const loadDotnetMetadata = (
-  typeRoots: readonly string[]
-): DotnetMetadataRegistry => {
-  const registry = new DotnetMetadataRegistry();
-
-  // Scan all type roots for .d.ts files
-  for (const typeRoot of typeRoots) {
-    const absoluteRoot = path.resolve(typeRoot);
-    const declFiles = scanForDeclarationFiles(absoluteRoot);
-
-    for (const declPath of declFiles) {
-      // Look for corresponding .metadata.json file
-      const metadataPath = declPath.replace(/\.d\.ts$/, ".metadata.json");
-
-      try {
-        if (fs.existsSync(metadataPath)) {
-          const content = fs.readFileSync(metadataPath, "utf-8");
-          const metadataFile = JSON.parse(content) as DotnetMetadataFile;
-          registry.loadMetadataFile(metadataPath, metadataFile);
-        }
-      } catch (err) {
-        // Silently skip files that can't be read or parsed
-        // In production, we might want to emit a warning diagnostic
-        console.warn(`Failed to load metadata from ${metadataPath}:`, err);
-      }
-    }
-  }
-
-  return registry;
-};

package/src/program/queries.ts

@@ -1,18 +0,0 @@
-/**
- * Program query functions
- */
-
-import * as ts from "typescript";
-import * as path from "node:path";
-import { TsonicProgram } from "./types.js";
-
-/**
- * Get a source file from the program by file path
- */
-export const getSourceFile = (
-  program: TsonicProgram,
-  filePath: string
-): ts.SourceFile | null => {
-  const absolutePath = path.resolve(filePath);
-  return program.program.getSourceFile(absolutePath) ?? null;
-};

package/src/program/types.ts

@@ -1,38 +0,0 @@
-/**
- * Program type definitions
- */
-
-import * as ts from "typescript";
-import { DotnetMetadataRegistry } from "../dotnet-metadata.js";
-import { BindingRegistry } from "./bindings.js";
-import { DotNetImportResolver } from "../resolver/dotnet-import-resolver.js";
-
-export type RuntimeMode = "js" | "dotnet";
-
-export type CompilerOptions = {
-  readonly sourceRoot: string;
-  readonly rootNamespace: string;
-  readonly strict?: boolean;
-  readonly typeRoots?: readonly string[];
-  readonly verbose?: boolean;
-  /** Use TypeScript standard lib (Array, Promise, etc.) instead of noLib mode */
-  readonly useStandardLib?: boolean;
-  /**
-   * Runtime mode:
-   * - "js": JS built-ins available via Tsonic.JSRuntime
-   * - "dotnet": Pure .NET mode, JS built-ins forbidden
-   * Defaults to "js"
-   */
-  readonly runtime?: RuntimeMode;
-};
-
-export type TsonicProgram = {
-  readonly program: ts.Program;
-  readonly checker: ts.TypeChecker;
-  readonly options: CompilerOptions;
-  readonly sourceFiles: readonly ts.SourceFile[];
-  readonly metadata: DotnetMetadataRegistry;
-  readonly bindings: BindingRegistry;
-  /** Resolver for .NET namespace imports (import-driven discovery) */
-  readonly dotnetResolver: DotNetImportResolver;
-};

package/src/resolver/dotnet-import-resolver.ts

@@ -1,226 +0,0 @@
-/**
- * Import-driven .NET namespace resolution
- *
- * Determines if an import specifier refers to a CLR namespace by checking
- * if bindings.json exists in the package's namespace directory.
- *
- * This is the ONLY mechanism for detecting .NET imports - no heuristics,
- * no special-casing for @tsonic/dotnet or any other package.
- */
-
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { createRequire } from "node:module";
-
-/**
- * Result of resolving a .NET import
- */
-export type ResolvedDotNetImport =
-  | {
-      readonly isDotNet: true;
-      readonly packageName: string;
-      readonly resolvedNamespace: string;
-      readonly bindingsPath: string;
-      readonly metadataPath: string | undefined;
-    }
-  | {
-      readonly isDotNet: false;
-    };
-
-/**
- * Parsed module specifier
- */
-type ParsedSpecifier = {
-  readonly packageName: string;
-  readonly subpath: string;
-};
-
-/**
- * Resolver for .NET namespace imports
- *
- * An import is a CLR namespace import iff:
- * - It's a package import with a subpath (e.g., @scope/pkg/Namespace)
- * - The package contains bindings.json in that subpath directory
- *
- * This works for any bindings provider package, not just @tsonic/dotnet.
- */
-export class DotNetImportResolver {
-  // Cache: packageName -> packageRoot (or null if not found)
-  private readonly pkgRootCache = new Map<string, string | null>();
-
-  // Cache: absolute bindingsPath -> exists
-  private readonly bindingsExistsCache = new Map<string, boolean>();
-
-  // require function for Node resolution from the base directory
-  private readonly require: NodeRequire;
-
-  constructor(baseDir: string) {
-    // Create a require function that resolves relative to baseDir
-    this.require = createRequire(join(baseDir, "package.json"));
-  }
-
-  /**
-   * Resolve an import specifier to determine if it's a CLR namespace import
-   */
-  resolve(moduleSpecifier: string): ResolvedDotNetImport {
-    // Skip local imports
-    if (moduleSpecifier.startsWith(".") || moduleSpecifier.startsWith("/")) {
-      return { isDotNet: false };
-    }
-
-    // Parse the specifier into package name and subpath
-    const parsed = this.parseModuleSpecifier(moduleSpecifier);
-    if (!parsed) {
-      return { isDotNet: false };
-    }
-
-    const { packageName, subpath } = parsed;
-
-    // No subpath means it's not a namespace import (e.g., just "@tsonic/dotnet")
-    if (!subpath) {
-      return { isDotNet: false };
-    }
-
-    // Resolve package root using Node resolution
-    const pkgRoot = this.resolvePkgRoot(packageName);
-    if (!pkgRoot) {
-      return { isDotNet: false };
-    }
-
-    // Check if bindings.json exists in the namespace directory
-    const bindingsPath = join(pkgRoot, subpath, "bindings.json");
-    if (!this.hasBindings(bindingsPath)) {
-      return { isDotNet: false };
-    }
-
-    // Check for optional metadata.json
-    const metadataPath = join(pkgRoot, subpath, "internal", "metadata.json");
-    const hasMetadata = this.fileExists(metadataPath);
-
-    return {
-      isDotNet: true,
-      packageName,
-      resolvedNamespace: subpath,
-      bindingsPath,
-      metadataPath: hasMetadata ? metadataPath : undefined,
-    };
-  }
-
-  /**
-   * Parse a module specifier into package name and subpath
-   *
-   * Examples:
-   * - "@tsonic/dotnet/System.IO" -> { packageName: "@tsonic/dotnet", subpath: "System.IO" }
-   * - "lodash/fp" -> { packageName: "lodash", subpath: "fp" }
-   * - "@tsonic/dotnet" -> null (no subpath)
-   * - "lodash" -> null (no subpath)
-   */
-  private parseModuleSpecifier(spec: string): ParsedSpecifier | null {
-    if (spec.startsWith("@")) {
-      // Scoped package: @scope/pkg/subpath
-      const match = spec.match(/^(@[^/]+\/[^/]+)(?:\/(.+))?$/);
-      if (!match) return null;
-      const packageName = match[1];
-      const subpath = match[2];
-      if (!packageName || !subpath) return null;
-      return { packageName, subpath };
-    } else {
-      // Regular package: pkg/subpath
-      const slashIdx = spec.indexOf("/");
-      if (slashIdx === -1) return null;
-      return {
-        packageName: spec.slice(0, slashIdx),
-        subpath: spec.slice(slashIdx + 1),
-      };
-    }
-  }
-
-  /**
-   * Resolve package root directory using Node resolution
-   *
-   * Uses require.resolve to find the package's package.json,
-   * then returns the directory containing it.
-   */
-  private resolvePkgRoot(packageName: string): string | null {
-    const cached = this.pkgRootCache.get(packageName);
-    if (cached !== undefined) {
-      return cached;
-    }
-
-    try {
-      // Try to resolve the package's package.json directly
-      const pkgJsonPath = this.require.resolve(`${packageName}/package.json`);
-      const pkgRoot = dirname(pkgJsonPath);
-      this.pkgRootCache.set(packageName, pkgRoot);
-      return pkgRoot;
-    } catch {
-      // package.json might not be exported - try finding package root via node_modules path
-      // This works by looking for node_modules/<package-name> in the require paths
-      try {
-        const paths = this.require.resolve.paths(packageName);
-        if (paths) {
-          for (const searchPath of paths) {
-            // For scoped packages, the path structure is node_modules/@scope/name
-            const pkgDir = packageName.startsWith("@")
-              ? join(searchPath, packageName)
-              : join(searchPath, packageName);
-
-            // Check if package.json exists at this location
-            if (existsSync(join(pkgDir, "package.json"))) {
-              this.pkgRootCache.set(packageName, pkgDir);
-              return pkgDir;
-            }
-          }
-        }
-      } catch {
-        // Fallback failed
-      }
-
-      this.pkgRootCache.set(packageName, null);
-      return null;
-    }
-  }
-
-  /**
-   * Check if bindings.json exists at the given path (cached)
-   */
-  private hasBindings(bindingsPath: string): boolean {
-    const cached = this.bindingsExistsCache.get(bindingsPath);
-    if (cached !== undefined) {
-      return cached;
-    }
-
-    const exists = existsSync(bindingsPath);
-    this.bindingsExistsCache.set(bindingsPath, exists);
-    return exists;
-  }
-
-  /**
-   * Check if a file exists (not cached - used for optional files)
-   */
-  private fileExists(filePath: string): boolean {
-    return existsSync(filePath);
-  }
-
-  /**
-   * Get all discovered binding paths (for loading)
-   */
-  getDiscoveredBindingPaths(): ReadonlySet<string> {
-    const paths = new Set<string>();
-    for (const [path, exists] of this.bindingsExistsCache) {
-      if (exists) {
-        paths.add(path);
-      }
-    }
-    return paths;
-  }
-}
-
-/**
- * Create a resolver instance for a given source root
- */
-export const createDotNetImportResolver = (
-  sourceRoot: string
-): DotNetImportResolver => {
-  return new DotNetImportResolver(sourceRoot);
-};