@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/try-catch-validation.d.ts

@@ -0,0 +1,26 @@
+import type { Diagnostic } from '../types.js';
+import type { BoardConstants } from './board-resolver.js';
+import type { StatementIR } from '../api/index.js';
+import type { PlatformStrategy } from '../api/shared/index.js';
+/**
+ * Validate that try/catch and throw statements are not used on
+ * architectures without C++ exception support.
+ *
+ * @param program - The program IR to validate
+ * @param boardConstants - Board constants containing architecture info
+ * @returns Array of error diagnostics for try/catch/throw usage
+ */
+export declare function validateTryCatch(program: {
+    topLevelStatements: StatementIR[];
+    functions: Array<{
+        statements: StatementIR[];
+    }>;
+    classes: Array<{
+        methods: Array<{
+            statements: StatementIR[];
+        }>;
+        constructor?: {
+            statements: StatementIR[];
+        };
+    }>;
+}, boardConstants: BoardConstants | undefined, strategy?: PlatformStrategy): Diagnostic[];

package/dist/ir/try-catch-validation.js

@@ -0,0 +1,128 @@
+// ---------------------------------------------------------------------------
+// Try/Catch Validation
+//
+// Validates that try/catch and throw statements are not used on architectures
+// that do not support C++ exceptions. The platform strategy determines which
+// architectures have exceptions disabled (e.g. AVR-GCC with -fno-exceptions).
+// ---------------------------------------------------------------------------
+/**
+ * Validate that try/catch and throw statements are not used on
+ * architectures without C++ exception support.
+ *
+ * @param program - The program IR to validate
+ * @param boardConstants - Board constants containing architecture info
+ * @returns Array of error diagnostics for try/catch/throw usage
+ */
+export function validateTryCatch(program, boardConstants, strategy) {
+    const diagnostics = [];
+    const arch = boardConstants?.get('architecture');
+    if (!arch || !strategy?.isExceptionSupportDisabled?.(arch)) {
+        return diagnostics;
+    }
+    // Scan all statements for try/catch and throw
+    const scanStatements = (stmts) => {
+        for (const stmt of stmts) {
+            scanStatement(stmt);
+        }
+    };
+    const scanStatement = (stmt) => {
+        if (!stmt || typeof stmt !== 'object')
+            return;
+        if (stmt.kind === 'try') {
+            const tryStmt = stmt;
+            diagnostics.push({
+                severity: 'error',
+                code: 'try-catch-unsupported',
+                message: `try/catch is not supported on ${arch.toUpperCase()} targets. ` +
+                    `AVR-GCC disables C++ exceptions (-fno-exceptions) and the generated ` +
+                    `code will not compile. Use return-code error checking instead.`,
+                hint: `function readSensor(): number | null {\n  const data = sensor.read();\n  if (!data) return null;  // error path\n  return data.value;       // success path\n}`,
+                line: stmt.sourceSpan?.startLine,
+                column: stmt.sourceSpan?.startColumn,
+                source: 'try-catch-validation',
+            });
+            // Still recurse into nested blocks to find other try/catch
+            scanStatements(tryStmt.tryBlock ?? []);
+            scanStatements(tryStmt.catchBlock ?? []);
+            scanStatements(tryStmt.finallyBlock ?? []);
+            return;
+        }
+        if (stmt.kind === 'throw') {
+            diagnostics.push({
+                severity: 'error',
+                code: 'try-catch-unsupported',
+                message: `throw is not supported on ${arch.toUpperCase()} targets. ` +
+                    `AVR-GCC disables C++ exceptions (-fno-exceptions). ` +
+                    `Use return codes or error flags instead.`,
+                hint: `return null;  // or return an error code`,
+                line: stmt.sourceSpan?.startLine,
+                column: stmt.sourceSpan?.startColumn,
+                source: 'try-catch-validation',
+            });
+            return;
+        }
+        // Recurse into nested statement containers
+        scanNested(stmt, scanStatement);
+    };
+    // Scan top-level statements
+    scanStatements(program.topLevelStatements);
+    // Scan function bodies
+    for (const fn of program.functions) {
+        scanStatements(fn.statements);
+    }
+    // Scan class methods and constructors
+    for (const cls of program.classes) {
+        for (const method of cls.methods) {
+            scanStatements(method.statements);
+        }
+        if (cls.constructor) {
+            scanStatements(cls.constructor.statements);
+        }
+    }
+    return diagnostics;
+}
+/**
+ * Recurse into nested statement containers of a given statement.
+ * Calls the visitor for each nested statement found.
+ */
+function scanNested(stmt, visitor) {
+    const s = stmt;
+    // if
+    if (s.thenBranch) {
+        for (const child of s.thenBranch)
+            visitor(child);
+    }
+    if (s.elseBranch) {
+        for (const child of s.elseBranch)
+            visitor(child);
+    }
+    // while, do_while
+    if (s.body && Array.isArray(s.body)) {
+        for (const child of s.body)
+            visitor(child);
+    }
+    // for, for_of, for_in
+    if (s.body && Array.isArray(s.body)) {
+        for (const child of s.body)
+            visitor(child);
+    }
+    // switch
+    if (s.cases && Array.isArray(s.cases)) {
+        for (const c of s.cases) {
+            if (c.body && Array.isArray(c.body)) {
+                for (const child of c.body)
+                    visitor(child);
+            }
+        }
+    }
+    // block
+    if (s.statements && Array.isArray(s.statements) && stmt.kind === 'block') {
+        for (const child of s.statements)
+            visitor(child);
+    }
+    // labeled
+    if (s.body && Array.isArray(s.body) && stmt.kind === 'labeled') {
+        for (const child of s.body)
+            visitor(child);
+    }
+}

package/dist/ir/type-resolution.d.ts

@@ -0,0 +1,31 @@
+import ts from "typescript";
+import { CppType } from "../api/index.js";
+export type CppTypeHint = "int" | "long long" | "unsigned long long" | "float" | "double" | "bool" | "auto" | "void" | "long" | "std::string" | "unsigned int" | "__tc_str_ptr" | `std::vector<${string}>` | `std::set<${string}>` | `std::map<${string}, ${string}>` | `std::function<${string}>` | `${string}*`;
+interface FunctionTypeSignature {
+    parameterTypes: CppTypeHint[];
+    returnType: CppTypeHint;
+}
+export interface ResolvedDeclarationType {
+    explicitType: CppTypeHint;
+    inferredType: CppTypeHint;
+    resolvedType: CppTypeHint;
+    canLowerFromStructuredInitializer: boolean;
+    isKnownCompileTimeType: boolean;
+    shouldWarnUnmappedType: boolean;
+}
+export declare function resolveAliasedTypeNode(node: ts.TypeNode | undefined, typeAliases?: Map<string, ts.TypeNode>, visited?: Set<string>): ts.TypeNode | undefined;
+export declare function getDirectCppType(typeName: string): CppTypeHint | undefined;
+export declare function typeNodeToCppType(node: ts.TypeNode | undefined, typeAliases?: Map<string, ts.TypeNode>, typeParametersInScope?: Set<string>): CppTypeHint;
+export declare function resolveFunctionTypeSignature(typeNode: ts.TypeNode | undefined, typeAliases?: Map<string, ts.TypeNode>): FunctionTypeSignature | undefined;
+export declare function inferExprCppType(expr: ts.Expression, functionReturnTypes: Map<string, CppTypeHint>, localVariableTypes: Map<string, CppTypeHint>, sourceText?: string): CppTypeHint;
+export declare function resolveDeclarationType(typeNode: ts.TypeNode | undefined, initializer: ts.Expression | undefined, functionReturnTypes: Map<string, CppTypeHint>, localVariableTypes: Map<string, CppTypeHint>, typeAliases?: Map<string, ts.TypeNode>, sourceText?: string): ResolvedDeclarationType;
+export declare function collectReturns(block: ts.Block): ts.ReturnStatement[];
+export declare function buildFunctionReturnTypeMap(source: ts.SourceFile): Map<string, CppTypeHint>;
+export declare function resolveFunctionReturnType(name: string, functionReturnTypes: Map<string, CppTypeHint>): CppType;
+/**
+ * Extract the ownership kind from a TypeScript type node.
+ * Detects Shared<T>, Mutable<T>, and Owned<T> wrapper types.
+ * Returns undefined if no ownership wrapper is found.
+ */
+export declare function extractOwnershipKindFromTypeNode(node: ts.TypeNode | undefined, typeAliases?: Map<string, ts.TypeNode>): 'owned' | 'shared' | 'mutable' | undefined;
+export {};