@tsonic/frontend 0.0.1 → 0.0.4

package/src/ir/builder/imports.ts

@@ -1,153 +0,0 @@
-/**
- * Import extraction from TypeScript source
- */
-
-import * as ts from "typescript";
-import { IrImport, IrImportSpecifier } from "../types.js";
-import { getBindingRegistry } from "../converters/statements/declarations/registry.js";
-import { getParameterModifierRegistry } from "../../types/parameter-modifiers.js";
-import { DotNetImportResolver } from "../../resolver/dotnet-import-resolver.js";
-
-/**
- * Extract import declarations from source file.
- * Uses TypeChecker to determine if each import is a type or value.
- * Uses DotNetImportResolver to detect CLR namespace imports.
- */
-export const extractImports = (
-  sourceFile: ts.SourceFile,
-  checker: ts.TypeChecker,
-  dotnetResolver: DotNetImportResolver
-): readonly IrImport[] => {
-  const imports: IrImport[] = [];
-
-  const visitor = (node: ts.Node): void => {
-    if (
-      ts.isImportDeclaration(node) &&
-      ts.isStringLiteral(node.moduleSpecifier)
-    ) {
-      const source = node.moduleSpecifier.text;
-      const isLocal = source.startsWith(".") || source.startsWith("/");
-
-      // Use import-driven resolution to detect .NET imports
-      // This works for any package that provides bindings.json
-      const dotnetResolution = dotnetResolver.resolve(source);
-      const isDotNet = dotnetResolution.isDotNet;
-      const resolvedNamespace = dotnetResolution.isDotNet
-        ? dotnetResolution.resolvedNamespace
-        : undefined;
-
-      const specifiers = extractImportSpecifiers(node, checker);
-
-      // Check for module binding (Node.js API, etc.)
-      const binding = getBindingRegistry().getBinding(source);
-      const hasModuleBinding = binding?.kind === "module";
-
-      // Track ref/out/In imports from @tsonic/types
-      if (source === "@tsonic/types") {
-        getParameterModifierRegistry().processImport(node);
-      }
-
-      imports.push({
-        kind: "import",
-        source,
-        isLocal,
-        isDotNet,
-        specifiers,
-        resolvedNamespace,
-        resolvedClrType: hasModuleBinding ? binding.type : undefined,
-        resolvedAssembly: hasModuleBinding ? binding.assembly : undefined,
-      });
-    }
-    ts.forEachChild(node, visitor);
-  };
-
-  visitor(sourceFile);
-  return imports;
-};
-
-/**
- * Extract import specifiers from an import declaration.
- * Uses TypeChecker to determine if each named import is a type or value.
- */
-export const extractImportSpecifiers = (
-  node: ts.ImportDeclaration,
-  checker: ts.TypeChecker
-): readonly IrImportSpecifier[] => {
-  const specifiers: IrImportSpecifier[] = [];
-
-  if (node.importClause) {
-    // Default import
-    if (node.importClause.name) {
-      specifiers.push({
-        kind: "default",
-        localName: node.importClause.name.text,
-      });
-    }
-
-    // Named or namespace imports
-    if (node.importClause.namedBindings) {
-      if (ts.isNamespaceImport(node.importClause.namedBindings)) {
-        specifiers.push({
-          kind: "namespace",
-          localName: node.importClause.namedBindings.name.text,
-        });
-      } else if (ts.isNamedImports(node.importClause.namedBindings)) {
-        node.importClause.namedBindings.elements.forEach((spec) => {
-          const isType = isTypeImport(spec, checker);
-          specifiers.push({
-            kind: "named",
-            name: (spec.propertyName ?? spec.name).text,
-            localName: spec.name.text,
-            isType,
-          });
-        });
-      }
-    }
-  }
-
-  return specifiers;
-};
-
-/**
- * Determine if an import specifier refers to a type (interface, class, type alias, enum).
- * Uses TypeChecker to resolve the symbol and check its declaration kind.
- */
-const isTypeImport = (
-  spec: ts.ImportSpecifier,
-  checker: ts.TypeChecker
-): boolean => {
-  try {
-    // TypeScript's isTypeOnly flag on the specifier itself (for `import { type Foo }`)
-    if (spec.isTypeOnly) {
-      return true;
-    }
-
-    // Get the symbol for this import specifier
-    const symbol = checker.getSymbolAtLocation(spec.name);
-    if (!symbol) {
-      return false;
-    }
-
-    // Follow aliases to get the actual symbol
-    const resolvedSymbol =
-      symbol.flags & ts.SymbolFlags.Alias
-        ? checker.getAliasedSymbol(symbol)
-        : symbol;
-
-    if (!resolvedSymbol) {
-      return false;
-    }
-
-    // Check if the symbol is a type
-    const flags = resolvedSymbol.flags;
-    return !!(
-      flags & ts.SymbolFlags.Interface ||
-      flags & ts.SymbolFlags.Class ||
-      flags & ts.SymbolFlags.TypeAlias ||
-      flags & ts.SymbolFlags.Enum ||
-      flags & ts.SymbolFlags.TypeParameter
-    );
-  } catch {
-    return false;
-  }
-};

package/src/ir/builder/orchestrator.ts

@@ -1,178 +0,0 @@
-/**
- * IR Builder orchestration - Main module building logic
- */
-
-import * as ts from "typescript";
-import { relative } from "path";
-import { IrModule } from "../types.js";
-import { TsonicProgram } from "../../program.js";
-import { getNamespaceFromPath, getClassNameFromPath } from "../../resolver.js";
-import { Result, ok, error } from "../../types/result.js";
-import { Diagnostic, createDiagnostic } from "../../types/diagnostic.js";
-import {
-  setMetadataRegistry,
-  setBindingRegistry,
-} from "../statement-converter.js";
-import { IrBuildOptions } from "./types.js";
-import { extractImports } from "./imports.js";
-import { extractExports } from "./exports.js";
-import { extractStatements, isExecutableStatement } from "./statements.js";
-import { validateClassImplements } from "./validation.js";
-
-/**
- * Build IR module from TypeScript source file
- */
-export const buildIrModule = (
-  sourceFile: ts.SourceFile,
-  program: TsonicProgram,
-  options: IrBuildOptions
-): Result<IrModule, Diagnostic> => {
-  try {
-    // Set the metadata registry for this compilation
-    setMetadataRegistry(program.metadata);
-
-    // Set the binding registry for this compilation
-    setBindingRegistry(program.bindings);
-
-    const namespace = getNamespaceFromPath(
-      sourceFile.fileName,
-      options.sourceRoot,
-      options.rootNamespace
-    );
-    const className = getClassNameFromPath(sourceFile.fileName);
-
-    const imports = extractImports(
-      sourceFile,
-      program.checker,
-      program.dotnetResolver
-    );
-    const exports = extractExports(sourceFile, program.checker);
-    const statements = extractStatements(sourceFile, program.checker);
-
-    // Check for file name / export name collision (Issue #4)
-    // When file name matches an exported function/variable name, C# will have illegal code
-    // Example: main.ts exporting function main() → class main { void main() } ❌
-    // Note: Classes are allowed to match file name (Person.ts → class Person) - that's the normal pattern
-    const collisionExport = exports.find((exp) => {
-      if (exp.kind === "declaration") {
-        const decl = exp.declaration;
-        // Only check functions and variables, NOT classes (classes matching filename is normal)
-        if (decl.kind === "functionDeclaration") {
-          return decl.name === className;
-        } else if (decl.kind === "variableDeclaration") {
-          // Check if any of the variable declarators has a matching name
-          return decl.declarations.some((declarator) => {
-            if (declarator.name.kind === "identifierPattern") {
-              return declarator.name.name === className;
-            }
-            return false;
-          });
-        }
-      } else if (exp.kind === "named") {
-        // For named exports, we need to check what's being exported
-        // This is more complex because we'd need to look it up in statements
-        // For now, skip named exports (they're usually re-exports)
-        return false;
-      }
-      return false;
-    });
-
-    if (collisionExport) {
-      return error(
-        createDiagnostic(
-          "TSN2003",
-          "error",
-          `File name '${className}' conflicts with exported member name. In C#, a type cannot contain a member with the same name as the enclosing type. Consider renaming the file or the exported member.`,
-          {
-            file: sourceFile.fileName,
-            line: 1,
-            column: 1,
-            length: className.length,
-          }
-        )
-      );
-    }
-
-    // Validate class implements patterns
-    // TypeScript interfaces are nominalized to C# classes, so "implements" is invalid
-    const implementsDiagnostics = validateClassImplements(
-      sourceFile,
-      program.checker
-    );
-    const firstImplementsDiagnostic = implementsDiagnostics[0];
-    if (firstImplementsDiagnostic) {
-      return error(firstImplementsDiagnostic);
-    }
-
-    // Determine if this should be a static container
-    // Per spec: Files with a class matching the filename should NOT be static containers
-    // Static containers are for top-level functions and constants
-    const hasClassMatchingFilename = statements.some(
-      (stmt) => stmt.kind === "classDeclaration" && stmt.name === className
-    );
-
-    const hasTopLevelCode = statements.some(isExecutableStatement);
-    const isStaticContainer =
-      !hasClassMatchingFilename && !hasTopLevelCode && exports.length > 0;
-
-    // Compute relative file path from source root
-    // Normalize to forward slashes for cross-platform consistency
-    const relativePath = relative(
-      options.sourceRoot,
-      sourceFile.fileName
-    ).replace(/\\/g, "/");
-
-    const module: IrModule = {
-      kind: "module",
-      filePath: relativePath, // Now stores relative path instead of absolute
-      namespace,
-      className,
-      isStaticContainer,
-      imports,
-      body: statements,
-      exports,
-    };
-
-    return ok(module);
-  } catch (err) {
-    return error(
-      createDiagnostic(
-        "TSN6001",
-        "error",
-        `Failed to build IR: ${err instanceof Error ? err.message : String(err)}`,
-        {
-          file: sourceFile.fileName,
-          line: 1,
-          column: 1,
-          length: 1,
-        }
-      )
-    );
-  }
-};
-
-/**
- * Build IR for all source files in the program
- */
-export const buildIr = (
-  program: TsonicProgram,
-  options: IrBuildOptions
-): Result<readonly IrModule[], readonly Diagnostic[]> => {
-  const modules: IrModule[] = [];
-  const diagnostics: Diagnostic[] = [];
-
-  for (const sourceFile of program.sourceFiles) {
-    const result = buildIrModule(sourceFile, program, options);
-    if (result.ok) {
-      modules.push(result.value);
-    } else {
-      diagnostics.push(result.error);
-    }
-  }
-
-  if (diagnostics.length > 0) {
-    return error(diagnostics);
-  }
-
-  return ok(modules);
-};

package/src/ir/builder/statements.ts

@@ -1,55 +0,0 @@
-/**
- * Statement extraction from TypeScript source
- */
-
-import * as ts from "typescript";
-import { IrStatement } from "../types.js";
-import { convertStatement } from "../statement-converter.js";
-
-/**
- * Extract statements from source file
- */
-export const extractStatements = (
-  sourceFile: ts.SourceFile,
-  checker: ts.TypeChecker
-): readonly IrStatement[] => {
-  const statements: IrStatement[] = [];
-
-  sourceFile.statements.forEach((stmt) => {
-    // Skip imports and exports (handled separately)
-    if (
-      !ts.isImportDeclaration(stmt) &&
-      !ts.isExportDeclaration(stmt) &&
-      !ts.isExportAssignment(stmt)
-    ) {
-      const converted = convertStatement(stmt, checker);
-      if (converted) {
-        statements.push(converted);
-      }
-    }
-  });
-
-  return statements;
-};
-
-/**
- * Check if a statement is executable (not a declaration)
- */
-export const isExecutableStatement = (stmt: IrStatement): boolean => {
-  // Declarations are not executable - they become static members in the container
-  const declarationKinds = [
-    "functionDeclaration",
-    "classDeclaration",
-    "interfaceDeclaration",
-    "typeAliasDeclaration",
-    "enumDeclaration",
-    "variableDeclaration", // Added: variable declarations become static fields
-  ];
-
-  // Empty statements are not executable
-  if (stmt.kind === "emptyStatement") {
-    return false;
-  }
-
-  return !declarationKinds.includes(stmt.kind);
-};

package/src/ir/builder/types.ts

@@ -1,8 +0,0 @@
-/**
- * IR Builder types
- */
-
-export type IrBuildOptions = {
-  readonly sourceRoot: string;
-  readonly rootNamespace: string;
-};

package/src/ir/builder/validation.ts

@@ -1,129 +0,0 @@
-/**
- * IR builder validation - checks for unsupported patterns
- */
-
-import * as ts from "typescript";
-import { Diagnostic, createDiagnostic } from "../../types/diagnostic.js";
-import { getSourceLocation } from "../../program/diagnostics.js";
-
-/**
- * Check if a type reference is the struct marker
- * (used to mark types as C# value types)
- */
-const isStructMarker = (
-  typeRef: ts.ExpressionWithTypeArguments,
-  checker: ts.TypeChecker
-): boolean => {
-  const symbol = checker.getSymbolAtLocation(typeRef.expression);
-  return symbol?.escapedName === "struct" || symbol?.escapedName === "Struct";
-};
-
-/**
- * Check if a symbol represents a TypeScript interface
- * (which Tsonic nominalizes to a C# class)
- */
-const isNominalizedInterface = (
-  symbol: ts.Symbol | undefined,
-  _checker: ts.TypeChecker
-): boolean => {
-  if (!symbol) return false;
-
-  const declarations = symbol.getDeclarations();
-  if (!declarations || declarations.length === 0) return false;
-
-  // Check if any declaration is an interface
-  return declarations.some((decl) => ts.isInterfaceDeclaration(decl));
-};
-
-/**
- * Check if a symbol represents a type alias for an object type
- * (which Tsonic nominalizes to a C# class)
- */
-const isNominalizedTypeAlias = (
-  symbol: ts.Symbol | undefined,
-  _checker: ts.TypeChecker
-): boolean => {
-  if (!symbol) return false;
-
-  const declarations = symbol.getDeclarations();
-  if (!declarations || declarations.length === 0) return false;
-
-  // Check if declaration is a type alias with object literal type
-  return declarations.some((decl) => {
-    if (!ts.isTypeAliasDeclaration(decl)) return false;
-    // Type aliases for object shapes are nominalized
-    return ts.isTypeLiteralNode(decl.type);
-  });
-};
-
-/**
- * Validate a class declaration for implements clause issues
- */
-const validateClassDeclaration = (
-  node: ts.ClassDeclaration,
-  checker: ts.TypeChecker
-): readonly Diagnostic[] => {
-  const diagnostics: Diagnostic[] = [];
-
-  const implementsClause = node.heritageClauses?.find(
-    (h) => h.token === ts.SyntaxKind.ImplementsKeyword
-  );
-
-  if (!implementsClause) return [];
-
-  for (const typeRef of implementsClause.types) {
-    // Skip the struct marker - it's a special pattern for value types
-    if (isStructMarker(typeRef, checker)) {
-      continue;
-    }
-
-    // Get the symbol for the identifier (not the resolved type)
-    // This preserves type alias identity
-    const identifierSymbol = checker.getSymbolAtLocation(typeRef.expression);
-
-    // Check if it's a nominalized interface or type alias
-    if (
-      isNominalizedInterface(identifierSymbol, checker) ||
-      isNominalizedTypeAlias(identifierSymbol, checker)
-    ) {
-      const typeName = typeRef.expression.getText();
-      const location = getSourceLocation(
-        node.getSourceFile(),
-        typeRef.getStart(),
-        typeRef.getWidth()
-      );
-
-      diagnostics.push(
-        createDiagnostic(
-          "TSN7301",
-          "error",
-          `Class cannot implement '${typeName}': TypeScript interfaces are nominalized to C# classes in Tsonic. Use 'extends' instead, or refactor to composition.`,
-          location,
-          "In Tsonic, interfaces become classes for object initializer support. C# classes cannot implement other classes."
-        )
-      );
-    }
-  }
-
-  return diagnostics;
-};
-
-/**
- * Validate all class declarations in a source file
- */
-export const validateClassImplements = (
-  sourceFile: ts.SourceFile,
-  checker: ts.TypeChecker
-): readonly Diagnostic[] => {
-  const diagnostics: Diagnostic[] = [];
-
-  const visit = (node: ts.Node): void => {
-    if (ts.isClassDeclaration(node)) {
-      diagnostics.push(...validateClassDeclaration(node, checker));
-    }
-    ts.forEachChild(node, visit);
-  };
-
-  visit(sourceFile);
-  return diagnostics;
-};