@tsonic/frontend 0.0.1 → 0.0.4

package/src/validation/features.ts

@@ -1,89 +0,0 @@
-/**
- * Unsupported feature validation
- */
-
-import * as ts from "typescript";
-import { TsonicProgram } from "../program.js";
-import {
-  DiagnosticsCollector,
-  addDiagnostic,
-  createDiagnostic,
-} from "../types/diagnostic.js";
-import { getNodeLocation } from "./helpers.js";
-
-/**
- * Validate that unsupported features are not used
- */
-export const validateUnsupportedFeatures = (
-  sourceFile: ts.SourceFile,
-  _program: TsonicProgram,
-  collector: DiagnosticsCollector
-): DiagnosticsCollector => {
-  const visitor = (node: ts.Node): void => {
-    // Check for features we don't support yet
-    if (ts.isWithStatement(node)) {
-      collector = addDiagnostic(
-        collector,
-        createDiagnostic(
-          "TSN2001",
-          "error",
-          "'with' statement not supported",
-          getNodeLocation(sourceFile, node)
-        )
-      );
-    }
-
-    if (ts.isMetaProperty(node)) {
-      collector = addDiagnostic(
-        collector,
-        createDiagnostic(
-          "TSN2001",
-          "error",
-          "Meta properties (import.meta) not supported",
-          getNodeLocation(sourceFile, node)
-        )
-      );
-    }
-
-    if (
-      ts.isCallExpression(node) &&
-      node.expression.kind === ts.SyntaxKind.ImportKeyword
-    ) {
-      collector = addDiagnostic(
-        collector,
-        createDiagnostic(
-          "TSN2001",
-          "error",
-          "Dynamic import() not supported",
-          getNodeLocation(sourceFile, node),
-          "Use static imports"
-        )
-      );
-    }
-
-    // Check for Promise.then/catch/finally chaining (not supported)
-    if (
-      ts.isCallExpression(node) &&
-      ts.isPropertyAccessExpression(node.expression)
-    ) {
-      const methodName = node.expression.name.text;
-      if (["then", "catch", "finally"].includes(methodName)) {
-        collector = addDiagnostic(
-          collector,
-          createDiagnostic(
-            "TSN3011",
-            "error",
-            `Promise.${methodName}() is not supported`,
-            getNodeLocation(sourceFile, node),
-            "Use async/await instead of Promise chaining"
-          )
-        );
-      }
-    }
-
-    ts.forEachChild(node, visitor);
-  };
-
-  visitor(sourceFile);
-  return collector;
-};

package/src/validation/generics.ts

@@ -1,40 +0,0 @@
-/**
- * Generic type validation
- */
-
-import * as ts from "typescript";
-import { TsonicProgram } from "../program.js";
-import { DiagnosticsCollector, addDiagnostic } from "../types/diagnostic.js";
-import { checkForSymbolIndexSignature } from "../ir/generic-validator.js";
-
-/**
- * Validate generic types and constraints
- */
-export const validateGenerics = (
-  sourceFile: ts.SourceFile,
-  _program: TsonicProgram,
-  collector: DiagnosticsCollector
-): DiagnosticsCollector => {
-  const visitor = (node: ts.Node): void => {
-    // Only check for truly unsupported features (no static C# mapping)
-    // Symbol index signatures - TSN7203
-    if (ts.isIndexSignatureDeclaration(node)) {
-      const symbolDiag = checkForSymbolIndexSignature(node, sourceFile);
-      if (symbolDiag) {
-        collector = addDiagnostic(collector, symbolDiag);
-      }
-    }
-
-    // Explicitly visit interface and type literal members
-    if (ts.isInterfaceDeclaration(node) || ts.isTypeLiteralNode(node)) {
-      for (const member of node.members) {
-        visitor(member);
-      }
-    }
-
-    ts.forEachChild(node, visitor);
-  };
-
-  visitor(sourceFile);
-  return collector;
-};

package/src/validation/helpers.ts

@@ -1,31 +0,0 @@
-/**
- * Validation helper functions
- */
-
-import * as ts from "typescript";
-
-// Re-export hasExportModifier from graph helpers to avoid duplication
-export { hasExportModifier } from "../graph/helpers.js";
-
-/**
- * Get location information for a node
- */
-export const getNodeLocation = (
-  sourceFile: ts.SourceFile,
-  node: ts.Node
-): {
-  readonly file: string;
-  readonly line: number;
-  readonly column: number;
-  readonly length: number;
-} => {
-  const { line, character } = sourceFile.getLineAndCharacterOfPosition(
-    node.getStart()
-  );
-  return {
-    file: sourceFile.fileName,
-    line: line + 1,
-    column: character + 1,
-    length: node.getWidth(),
-  };
-};

package/src/validation/imports.ts

@@ -1,97 +0,0 @@
-/**
- * Import validation
- */
-
-import * as ts from "typescript";
-import { TsonicProgram } from "../program.js";
-import {
-  DiagnosticsCollector,
-  addDiagnostic,
-  createDiagnostic,
-} from "../types/diagnostic.js";
-import { resolveImport } from "../resolver.js";
-import { getNodeLocation } from "./helpers.js";
-
-/**
- * Validate all imports in a source file
- */
-export const validateImports = (
-  sourceFile: ts.SourceFile,
-  program: TsonicProgram,
-  collector: DiagnosticsCollector
-): DiagnosticsCollector => {
-  const visitor = (node: ts.Node): DiagnosticsCollector => {
-    if (ts.isImportDeclaration(node)) {
-      return validateImportDeclaration(node, sourceFile, program, collector);
-    }
-
-    if (ts.isImportTypeNode(node)) {
-      return addDiagnostic(
-        collector,
-        createDiagnostic(
-          "TSN2001",
-          "error",
-          "Import type syntax not supported",
-          getNodeLocation(sourceFile, node),
-          "Use regular imports instead"
-        )
-      );
-    }
-
-    return ts.forEachChild(node, visitor) ?? collector;
-  };
-
-  return visitor(sourceFile);
-};
-
-/**
- * Validate a specific import declaration
- */
-export const validateImportDeclaration = (
-  node: ts.ImportDeclaration,
-  sourceFile: ts.SourceFile,
-  program: TsonicProgram,
-  collector: DiagnosticsCollector
-): DiagnosticsCollector => {
-  if (!ts.isStringLiteral(node.moduleSpecifier)) {
-    return addDiagnostic(
-      collector,
-      createDiagnostic(
-        "TSN2001",
-        "error",
-        "Dynamic imports not supported",
-        getNodeLocation(sourceFile, node),
-        "Use static import statements"
-      )
-    );
-  }
-
-  const importPath = node.moduleSpecifier.text;
-  const result = resolveImport(
-    importPath,
-    sourceFile.fileName,
-    program.options.sourceRoot,
-    program.dotnetResolver
-  );
-
-  if (!result.ok) {
-    const location = getNodeLocation(sourceFile, node.moduleSpecifier);
-    return addDiagnostic(collector, { ...result.error, location });
-  }
-
-  // Check for default imports from local modules (we might want to restrict this)
-  if (result.value.isLocal && node.importClause?.name) {
-    return addDiagnostic(
-      collector,
-      createDiagnostic(
-        "TSN2001",
-        "warning",
-        "Default imports from local modules may not work as expected",
-        getNodeLocation(sourceFile, node.importClause),
-        "Consider using named imports"
-      )
-    );
-  }
-
-  return collector;
-};

package/src/validation/orchestrator.ts

@@ -1,51 +0,0 @@
-/**
- * Validation orchestrator - coordinates all validation functions
- */
-
-import * as ts from "typescript";
-import { TsonicProgram } from "../program.js";
-import {
-  DiagnosticsCollector,
-  createDiagnosticsCollector,
-} from "../types/diagnostic.js";
-import { validateImports } from "./imports.js";
-import { validateExports } from "./exports.js";
-import { validateUnsupportedFeatures } from "./features.js";
-import { validateGenerics } from "./generics.js";
-import { validateStaticSafety } from "./static-safety.js";
-
-/**
- * Validate an entire Tsonic program
- */
-export const validateProgram = (
-  program: TsonicProgram
-): DiagnosticsCollector => {
-  const collector = createDiagnosticsCollector();
-
-  return program.sourceFiles.reduce(
-    (acc, sourceFile) => validateSourceFile(sourceFile, program, acc),
-    collector
-  );
-};
-
-/**
- * Validate a single source file
- */
-export const validateSourceFile = (
-  sourceFile: ts.SourceFile,
-  program: TsonicProgram,
-  collector: DiagnosticsCollector
-): DiagnosticsCollector => {
-  const validationFns = [
-    validateImports,
-    validateExports,
-    validateUnsupportedFeatures,
-    validateGenerics,
-    validateStaticSafety,
-  ];
-
-  return validationFns.reduce(
-    (acc, fn) => fn(sourceFile, program, acc),
-    collector
-  );
-};

package/src/validation/static-safety.ts

@@ -1,267 +0,0 @@
-/**
- * Static Safety Validation
- *
- * Detects patterns that violate static typing requirements:
- * - TSN7401: 'any' type usage
- * - TSN7403: Object literal without contextual nominal type
- * - TSN7405: Untyped function/arrow/lambda parameter
- * - TSN7413: Dictionary key must be string type
- *
- * This ensures NativeAOT-compatible, predictable-performance output.
- *
- * Note: We intentionally do NOT validate JS built-in usage (arr.map, str.length)
- * or dictionary dot-access patterns. These will fail naturally in C# if used
- * incorrectly, which is an acceptable failure mode.
- */
-
-import * as ts from "typescript";
-import { TsonicProgram } from "../program.js";
-import {
-  DiagnosticsCollector,
-  addDiagnostic,
-  createDiagnostic,
-} from "../types/diagnostic.js";
-import { getNodeLocation } from "./helpers.js";
-
-/**
- * Validate a source file for static safety violations.
- */
-export const validateStaticSafety = (
-  sourceFile: ts.SourceFile,
-  program: TsonicProgram,
-  collector: DiagnosticsCollector
-): DiagnosticsCollector => {
-  const checker = program.checker;
-
-  const visitor = (
-    node: ts.Node,
-    accCollector: DiagnosticsCollector
-  ): DiagnosticsCollector => {
-    let currentCollector = accCollector;
-
-    // TSN7401: Check for explicit 'any' type annotations
-    if (node.kind === ts.SyntaxKind.AnyKeyword) {
-      currentCollector = addDiagnostic(
-        currentCollector,
-        createDiagnostic(
-          "TSN7401",
-          "error",
-          "'any' type is not supported. Provide a concrete type, use 'unknown', or define a nominal type.",
-          getNodeLocation(sourceFile, node),
-          "Replace 'any' with a specific type like 'unknown', 'object', or a custom interface."
-        )
-      );
-    }
-
-    // TSN7401: Check for 'as any' type assertions
-    if (
-      ts.isAsExpression(node) &&
-      node.type.kind === ts.SyntaxKind.AnyKeyword
-    ) {
-      currentCollector = addDiagnostic(
-        currentCollector,
-        createDiagnostic(
-          "TSN7401",
-          "error",
-          "'as any' type assertion is not supported. Use a specific type assertion.",
-          getNodeLocation(sourceFile, node),
-          "Replace 'as any' with a specific type like 'as unknown' or 'as YourType'."
-        )
-      );
-    }
-
-    // TSN7405: Check for untyped function parameters
-    // Covers: function declarations, methods, constructors, arrow functions, function expressions
-    if (ts.isParameter(node) && !node.type) {
-      const parent = node.parent;
-      const isFunctionLike =
-        ts.isFunctionDeclaration(parent) ||
-        ts.isMethodDeclaration(parent) ||
-        ts.isConstructorDeclaration(parent) ||
-        ts.isArrowFunction(parent) ||
-        ts.isFunctionExpression(parent) ||
-        ts.isGetAccessorDeclaration(parent) ||
-        ts.isSetAccessorDeclaration(parent);
-
-      if (isFunctionLike) {
-        const paramName = ts.isIdentifier(node.name) ? node.name.text : "param";
-        currentCollector = addDiagnostic(
-          currentCollector,
-          createDiagnostic(
-            "TSN7405",
-            "error",
-            `Parameter '${paramName}' must have an explicit type annotation.`,
-            getNodeLocation(sourceFile, node),
-            "Add a type annotation to this parameter."
-          )
-        );
-      }
-    }
-
-    // TSN7403: Check for object literals without contextual nominal type
-    if (ts.isObjectLiteralExpression(node)) {
-      const contextualType = checker.getContextualType(node);
-
-      // Must have a contextual type that resolves to a nominal type or dictionary
-      if (
-        !contextualType ||
-        !isNominalOrDictionaryType(contextualType, checker)
-      ) {
-        currentCollector = addDiagnostic(
-          currentCollector,
-          createDiagnostic(
-            "TSN7403",
-            "error",
-            "Object literal requires a contextual nominal type (interface, type alias, or class). Anonymous object types are not supported.",
-            getNodeLocation(sourceFile, node),
-            "Add a type annotation like 'const x: MyInterface = { ... }' or define an interface/type alias."
-          )
-        );
-      }
-    }
-
-    // TSN7413: Check for non-string dictionary keys
-    // Record<K, V> where K is not string
-    if (ts.isTypeReferenceNode(node)) {
-      const typeName = node.typeName;
-      if (ts.isIdentifier(typeName) && typeName.text === "Record") {
-        const typeArgs = node.typeArguments;
-        if (typeArgs && typeArgs.length >= 1) {
-          const keyTypeNode = typeArgs[0]!;
-          if (!isStringKeyType(keyTypeNode)) {
-            currentCollector = addDiagnostic(
-              currentCollector,
-              createDiagnostic(
-                "TSN7413",
-                "error",
-                "Dictionary key type must be 'string'. Non-string key types are not supported for NativeAOT compatibility.",
-                getNodeLocation(sourceFile, keyTypeNode),
-                "Use Record<string, V> instead of Record<number, V> or other key types."
-              )
-            );
-          }
-        }
-      }
-    }
-
-    // TSN7413: Check for non-string index signatures
-    // { [k: number]: V } is not allowed
-    if (ts.isIndexSignatureDeclaration(node)) {
-      const keyParam = node.parameters[0];
-      if (keyParam?.type && !isStringKeyType(keyParam.type)) {
-        currentCollector = addDiagnostic(
-          currentCollector,
-          createDiagnostic(
-            "TSN7413",
-            "error",
-            "Index signature key type must be 'string'. Non-string key types are not supported for NativeAOT compatibility.",
-            getNodeLocation(sourceFile, keyParam.type),
-            "Use { [key: string]: V } instead of { [key: number]: V }."
-          )
-        );
-      }
-    }
-
-    // Continue visiting children
-    ts.forEachChild(node, (child) => {
-      currentCollector = visitor(child, currentCollector);
-    });
-
-    return currentCollector;
-  };
-
-  return visitor(sourceFile, collector);
-};
-
-/**
- * Check if a contextual type is a nominal type (interface, type alias, class)
- * or a dictionary type that we can emit.
- *
- * Returns false for anonymous object types like `{ x: number }` without a name.
- */
-const isNominalOrDictionaryType = (
-  type: ts.Type,
-  checker: ts.TypeChecker
-): boolean => {
-  // Check if it's a dictionary type (Record<K,V> or index signature)
-  if (isTsDictionaryType(type)) {
-    return true;
-  }
-
-  // Check if the type has a symbol with a declaration (named type)
-  const symbol = type.getSymbol() ?? type.aliasSymbol;
-  if (symbol) {
-    const declarations = symbol.getDeclarations();
-    if (declarations && declarations.length > 0) {
-      const decl = declarations[0]!;
-      // Accept: interface, type alias, class
-      if (
-        ts.isInterfaceDeclaration(decl) ||
-        ts.isTypeAliasDeclaration(decl) ||
-        ts.isClassDeclaration(decl)
-      ) {
-        return true;
-      }
-    }
-  }
-
-  // Check for primitive types (allowed)
-  if (
-    type.flags & ts.TypeFlags.String ||
-    type.flags & ts.TypeFlags.Number ||
-    type.flags & ts.TypeFlags.Boolean ||
-    type.flags & ts.TypeFlags.Null ||
-    type.flags & ts.TypeFlags.Undefined ||
-    type.flags & ts.TypeFlags.Void
-  ) {
-    return true;
-  }
-
-  // Check for array types (allowed)
-  if (checker.isArrayType(type) || checker.isTupleType(type)) {
-    return true;
-  }
-
-  return false;
-};
-
-/**
- * Check if a type is a TS dictionary type (Record<K,V> or index signature).
- *
- * TS dictionary types:
- * - Record<string, T> → has aliasSymbol named "Record"
- * - { [k: string]: T } → has string index signature
- */
-const isTsDictionaryType = (type: ts.Type): boolean => {
-  // Check for Record<K,V> utility type
-  if (type.aliasSymbol?.name === "Record") {
-    return true;
-  }
-
-  // Check for index signature type like { [k: string]: T }
-  const stringIndexType = type.getStringIndexType();
-  const numberIndexType = type.getNumberIndexType();
-
-  return !!(stringIndexType || numberIndexType);
-};
-
-/**
- * Check if a type node represents a string key type.
- * Only `string` keyword is allowed for dictionary keys.
- */
-const isStringKeyType = (typeNode: ts.TypeNode): boolean => {
-  // Direct string keyword
-  if (typeNode.kind === ts.SyntaxKind.StringKeyword) {
-    return true;
-  }
-
-  // Type reference to "string"
-  if (ts.isTypeReferenceNode(typeNode)) {
-    const typeName = typeNode.typeName;
-    if (ts.isIdentifier(typeName) && typeName.text === "string") {
-      return true;
-    }
-  }
-
-  return false;
-};