@tsonic/frontend 0.0.1

package/src/validation/helpers.ts

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

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

@@ -0,0 +1,11 @@
+/**
+ * Validation - Public API
+ */
+
+export { validateProgram, validateSourceFile } from "./orchestrator.js";
+export { validateImports, validateImportDeclaration } from "./imports.js";
+export { validateExports } from "./exports.js";
+export { validateUnsupportedFeatures } from "./features.js";
+export { validateGenerics } from "./generics.js";
+export { validateStaticSafety } from "./static-safety.js";
+export { hasExportModifier, getNodeLocation } from "./helpers.js";

package/src/validation/orchestrator.ts

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

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