@tsonic/frontend 0.0.1

package/src/ir/builder/exports.ts

@@ -0,0 +1,78 @@
+/**
+ * Export extraction from TypeScript source
+ */
+
+import * as ts from "typescript";
+import { IrExport } from "../types.js";
+import { convertStatement } from "../statement-converter.js";
+import { convertExpression } from "../expression-converter.js";
+import { hasExportModifier, hasDefaultModifier } from "./helpers.js";
+
+/**
+ * Extract export declarations from source file
+ */
+export const extractExports = (
+  sourceFile: ts.SourceFile,
+  checker: ts.TypeChecker
+): readonly IrExport[] => {
+  const exports: IrExport[] = [];
+
+  const visitor = (node: ts.Node): void => {
+    if (ts.isExportDeclaration(node)) {
+      if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+        // Check if this is a re-export (has moduleSpecifier)
+        if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+          // Re-export: export { x } from "./other.ts"
+          const fromModule = node.moduleSpecifier.text;
+          node.exportClause.elements.forEach((spec) => {
+            exports.push({
+              kind: "reexport",
+              name: spec.name.text, // Exported name
+              originalName: (spec.propertyName ?? spec.name).text, // Name in source module
+              fromModule,
+            });
+          });
+        } else {
+          // Regular named export: export { x }
+          node.exportClause.elements.forEach((spec) => {
+            exports.push({
+              kind: "named",
+              name: spec.name.text,
+              localName: (spec.propertyName ?? spec.name).text,
+            });
+          });
+        }
+      }
+    } else if (ts.isExportAssignment(node)) {
+      exports.push({
+        kind: "default",
+        expression: convertExpression(node.expression, checker),
+      });
+    } else if (hasExportModifier(node)) {
+      const hasDefault = hasDefaultModifier(node);
+      if (hasDefault) {
+        // export default function/class/etc
+        const stmt = convertStatement(node, checker);
+        if (stmt) {
+          exports.push({
+            kind: "default",
+            expression: { kind: "identifier", name: "_default" }, // placeholder for now
+          });
+        }
+      } else {
+        // regular export
+        const stmt = convertStatement(node, checker);
+        if (stmt) {
+          exports.push({
+            kind: "declaration",
+            declaration: stmt,
+          });
+        }
+      }
+    }
+    ts.forEachChild(node, visitor);
+  };
+
+  visitor(sourceFile);
+  return exports;
+};

package/src/ir/builder/helpers.ts

@@ -0,0 +1,27 @@
+/**
+ * IR Builder helper functions
+ */
+
+import * as ts from "typescript";
+
+/**
+ * Check if a node has export modifier
+ */
+export const hasExportModifier = (node: ts.Node): boolean => {
+  if (!ts.canHaveModifiers(node)) return false;
+  const modifiers = ts.getModifiers(node);
+  return (
+    modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false
+  );
+};
+
+/**
+ * Check if a node has default modifier
+ */
+export const hasDefaultModifier = (node: ts.Node): boolean => {
+  if (!ts.canHaveModifiers(node)) return false;
+  const modifiers = ts.getModifiers(node);
+  return (
+    modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword) ?? false
+  );
+};

package/src/ir/builder/imports.ts

@@ -0,0 +1,153 @@
+/**
+ * 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/index.ts

@@ -0,0 +1,10 @@
+/**
+ * IR Builder - Public API
+ */
+
+export type { IrBuildOptions } from "./types.js";
+export { buildIrModule, buildIr } from "./orchestrator.js";
+export { extractImports, extractImportSpecifiers } from "./imports.js";
+export { extractExports } from "./exports.js";
+export { extractStatements, isExecutableStatement } from "./statements.js";
+export { hasExportModifier, hasDefaultModifier } from "./helpers.js";

package/src/ir/builder/orchestrator.ts

@@ -0,0 +1,178 @@
+/**
+ * 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

@@ -0,0 +1,55 @@
+/**
+ * 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

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

package/src/ir/builder/validation.ts

@@ -0,0 +1,129 @@
+/**
+ * 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;
+};