gradient-script 0.1.0 → 0.2.0

package/dist/dsl/CodeGen.js

@@ -3,15 +3,31 @@
  * Generates TypeScript/JavaScript code with gradient functions
  */
 import { simplifyGradients } from './Simplify.js';
+import { ExpressionTransformer } from './ExpressionTransformer.js';
 import { eliminateCommonSubexpressionsStructured } from './CSE.js';
 import { CodeGenError } from './Errors.js';
+import { serializeExpression } from './ExpressionUtils.js';
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function shouldTrackForForwardReuse(expr) {
+    switch (expr.kind) {
+        case 'number':
+        case 'variable':
+            return false;
+        default:
+            return true;
+    }
+}
 /**
  * Code generator for expressions
  */
 export class ExpressionCodeGen {
     format;
-    constructor(format = 'typescript') {
+    csharpFloatType;
+    constructor(format = 'typescript', csharpFloatType = 'float') {
         this.format = format;
+        this.csharpFloatType = csharpFloatType;
     }
     /**
      * Generate code for an expression
@@ -47,7 +63,7 @@ export class ExpressionCodeGen {
         if (this.format === 'python' && (op === '^' || op === '**')) {
             op = '**'; // Python uses **
         }
-        else if ((this.format === 'typescript' || this.format === 'javascript') && (op === '^' || op === '**')) {
+        else if ((this.format === 'typescript' || this.format === 'javascript' || this.format === 'csharp') && (op === '^' || op === '**')) {
             // Optimize: x^2 -> x*x, x^3 -> x*x*x (faster than Math.pow)
             // Only for simple expressions (variables, component access)
             const isSimple = expr.left.kind === 'variable' ||
@@ -70,8 +86,14 @@ export class ExpressionCodeGen {
                     }
                 }
             }
-            // Fall back to Math.pow for complex expressions or larger exponents
-            return `Math.pow(${left}, ${right})`;
+            // Fall back to Math.pow / MathF.Pow for complex expressions or larger exponents
+            if (this.format === 'csharp') {
+                const mathClass = this.csharpFloatType === 'float' ? 'MathF' : 'Math';
+                return `${mathClass}.Pow(${left}, ${right})`;
+            }
+            else {
+                return `Math.pow(${left}, ${right})`;
+            }
         }
         return `${left} ${op} ${right}`;
     }
@@ -160,6 +182,10 @@ export class ExpressionCodeGen {
             else if (this.format === 'python') {
                 return `max(${min}, min(${max}, ${x}))`;
             }
+            else if (this.format === 'csharp') {
+                const mathClass = this.csharpFloatType === 'float' ? 'MathF' : 'Math';
+                return `${mathClass}.Max(${min}, ${mathClass}.Min(${max}, ${x}))`;
+            }
         }
         // Map function names for different formats
         const funcName = this.mapFunctionName(expr.name);
@@ -167,63 +193,91 @@ export class ExpressionCodeGen {
     }
     genComponent(expr) {
         const obj = this.generate(expr.object);
+        if (this.format === 'csharp') {
+            // C# uses PascalCase for properties
+            return `${obj}.${capitalize(expr.component)}`;
+        }
         return `${obj}.${expr.component}`;
     }
+    // Math functions that should be mapped across all formats
+    static MATH_FUNCTIONS = [
+        'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2',
+        'exp', 'log', 'sqrt', 'abs', 'pow', 'min', 'max'
+    ];
+    // Python built-in functions that don't need the math. prefix
+    static PYTHON_BUILTINS = ['abs', 'pow', 'min', 'max'];
     mapFunctionName(name) {
-        if (this.format === 'typescript' || this.format === 'javascript') {
-            const mathFuncs = {
-                'sin': 'Math.sin',
-                'cos': 'Math.cos',
-                'tan': 'Math.tan',
-                'asin': 'Math.asin',
-                'acos': 'Math.acos',
-                'atan': 'Math.atan',
-                'atan2': 'Math.atan2',
-                'exp': 'Math.exp',
-                'log': 'Math.log',
-                'sqrt': 'Math.sqrt',
-                'abs': 'Math.abs',
-                'pow': 'Math.pow',
-                'min': 'Math.min',
-                'max': 'Math.max'
-            };
-            return mathFuncs[name] || name;
-        }
-        else if (this.format === 'python') {
-            const mathFuncs = {
-                'atan2': 'math.atan2',
-                'sin': 'math.sin',
-                'cos': 'math.cos',
-                'tan': 'math.tan',
-                'asin': 'math.asin',
-                'acos': 'math.acos',
-                'atan': 'math.atan',
-                'exp': 'math.exp',
-                'log': 'math.log',
-                'sqrt': 'math.sqrt',
-                'abs': 'abs',
-                'pow': 'pow',
-                'min': 'min',
-                'max': 'max'
-            };
-            return mathFuncs[name] || name;
+        // Check if this is a known math function
+        if (!ExpressionCodeGen.MATH_FUNCTIONS.includes(name)) {
+            return name;
         }
-        return name;
+        // Define format-specific mappers
+        const mappers = {
+            typescript: (fn) => `Math.${fn}`,
+            javascript: (fn) => `Math.${fn}`,
+            python: (fn) => ExpressionCodeGen.PYTHON_BUILTINS.includes(fn) ? fn : `math.${fn}`,
+            csharp: (fn) => {
+                const mathClass = this.csharpFloatType === 'float' ? 'MathF' : 'Math';
+                const capitalized = fn.charAt(0).toUpperCase() + fn.slice(1);
+                return `${mathClass}.${capitalized}`;
+            }
+        };
+        const mapper = mappers[this.format];
+        return mapper ? mapper(name) : name;
     }
 }
+/**
+ * Generate C# struct for gradient return type
+ */
+function generateCSharpGradientStruct(func, gradients, floatType) {
+    const lines = [];
+    const structName = `${capitalize(func.name)}GradResult`;
+    lines.push(`public struct ${structName}`);
+    lines.push('{');
+    lines.push(`    public ${floatType} Value;`);
+    for (const [paramName, gradient] of gradients.gradients.entries()) {
+        const propName = capitalize(`d${paramName}`);
+        if (isStructuredGradient(gradient)) {
+            // Generate a nested struct type for structured gradients
+            const components = Array.from(gradient.components.keys());
+            lines.push(`    public ${capitalize(paramName)}Grad ${propName};`);
+        }
+        else {
+            lines.push(`    public ${floatType} ${propName};`);
+        }
+    }
+    lines.push('}');
+    // Generate nested struct types for structured gradients
+    for (const [paramName, gradient] of gradients.gradients.entries()) {
+        if (isStructuredGradient(gradient)) {
+            lines.push('');
+            lines.push(`public struct ${capitalize(paramName)}Grad`);
+            lines.push('{');
+            for (const comp of gradient.components.keys()) {
+                lines.push(`    public ${floatType} ${capitalize(comp)};`);
+            }
+            lines.push('}');
+        }
+    }
+    return lines;
+}
 /**
  * Generate complete gradient function code
  */
 export function generateGradientFunction(func, gradients, env, options = {}) {
     const format = options.format || 'typescript';
+    const csharpFloatType = options.csharpFloatType || 'float';
     const includeComments = options.includeComments !== false;
     const shouldSimplify = options.simplify !== false; // Default to true
-    // Simplify gradients if requested
-    const gradientsToUse = shouldSimplify
-        ? { gradients: simplifyGradients(gradients.gradients) }
-        : gradients;
-    const codegen = new ExpressionCodeGen(format);
+    // Note: We don't simplify here yet - we'll do it after forward expression substitution
+    const gradientsToUse = gradients;
+    const codegen = new ExpressionCodeGen(format, csharpFloatType);
     const lines = [];
+    // For C#, we need to generate a struct for the return type first
+    if (format === 'csharp') {
+        lines.push(...generateCSharpGradientStruct(func, gradientsToUse, csharpFloatType));
+        lines.push('');
+    }
     // Function signature
     const paramNames = func.parameters.map(p => p.name).join(', ');
     if (format === 'typescript' || format === 'javascript') {
@@ -232,44 +286,85 @@ export function generateGradientFunction(func, gradients, env, options = {}) {
     else if (format === 'python') {
         lines.push(`def ${func.name}_grad(${paramNames}):`);
     }
+    else if (format === 'csharp') {
+        const params = func.parameters.map(p => {
+            if (p.paramType && p.paramType.components) {
+                return `${capitalize(p.name)}Struct ${p.name}`;
+            }
+            return `${csharpFloatType} ${p.name}`;
+        }).join(', ');
+        const returnType = `${capitalize(func.name)}GradResult`;
+        lines.push(`public static ${returnType} ${capitalize(func.name)}_Grad(${params})`);
+        lines.push('{');
+    }
     // Forward pass - compute intermediate variables
     // Track which expressions are already computed for CSE reuse
-    const forwardPassVars = new Map();
+    const forwardExpressionMap = new Map();
     for (const stmt of func.body) {
         if (stmt.kind === 'assignment') {
             const varName = stmt.variable;
-            const expr = codegen.generate(stmt.expression);
-            // Track this for CSE reuse (store expression -> variable name mapping)
-            forwardPassVars.set(expr, varName);
+            const generatedExpr = codegen.generate(stmt.expression);
+            if (shouldTrackForForwardReuse(stmt.expression)) {
+                const exprKey = serializeExpression(stmt.expression);
+                if (!forwardExpressionMap.has(exprKey)) {
+                    forwardExpressionMap.set(exprKey, varName);
+                }
+            }
             if (format === 'typescript' || format === 'javascript') {
-                lines.push(`  const ${varName} = ${expr};`);
+                lines.push(`  const ${varName} = ${generatedExpr};`);
             }
-            else {
-                lines.push(`  ${varName} = ${expr}`);
+            else if (format === 'python') {
+                lines.push(`  ${varName} = ${generatedExpr}`);
+            }
+            else if (format === 'csharp') {
+                lines.push(`    ${csharpFloatType} ${varName} = ${generatedExpr};`);
             }
         }
     }
     // Compute output value - reuse forward pass variables if possible
-    let valueExpr = func.returnExpr;
+    const valueExpr = func.returnExpr;
+    const valueKey = serializeExpression(valueExpr);
+    const existingVar = forwardExpressionMap.get(valueKey);
     const valueCode = codegen.generate(valueExpr);
-    const existingVar = forwardPassVars.get(valueCode);
     if (existingVar) {
         // Reuse existing variable
         if (format === 'typescript' || format === 'javascript') {
             lines.push(`  const value = ${existingVar};`);
         }
-        else {
+        else if (format === 'python') {
             lines.push(`  value = ${existingVar}`);
         }
+        else if (format === 'csharp') {
+            lines.push(`    ${csharpFloatType} value = ${existingVar};`);
+        }
     }
     else {
         // Compute new value
         if (format === 'typescript' || format === 'javascript') {
             lines.push(`  const value = ${valueCode};`);
         }
-        else {
+        else if (format === 'python') {
             lines.push(`  value = ${valueCode}`);
         }
+        else if (format === 'csharp') {
+            lines.push(`    ${csharpFloatType} value = ${valueCode};`);
+        }
+        if (shouldTrackForForwardReuse(valueExpr) && !forwardExpressionMap.has(valueKey)) {
+            forwardExpressionMap.set(valueKey, 'value');
+        }
+    }
+    // Apply forward expression substitution multiple times until no more changes
+    // This handles nested expressions like sqrt(dx*dx + dy*dy) where dx = pix - pjx
+    reuseForwardExpressionsInGradients(gradientsToUse.gradients, forwardExpressionMap);
+    reuseForwardExpressionsInGradients(gradientsToUse.gradients, forwardExpressionMap);
+    reuseForwardExpressionsInGradients(gradientsToUse.gradients, forwardExpressionMap);
+    // Simplify gradients after forward expression substitution
+    if (shouldSimplify) {
+        const simplified = simplifyGradients(gradientsToUse.gradients);
+        gradientsToUse.gradients.clear();
+        for (const [key, value] of simplified.entries()) {
+            gradientsToUse.gradients.set(key, value);
+        }
     }
     lines.push('');
     // Generate gradients
@@ -312,9 +407,12 @@ export function generateGradientFunction(func, gradients, env, options = {}) {
                 if (format === 'typescript' || format === 'javascript') {
                     lines.push(`  const ${varName} = ${code};`);
                 }
-                else {
+                else if (format === 'python') {
                     lines.push(`  ${varName} = ${code}`);
                 }
+                else if (format === 'csharp') {
+                    lines.push(`    ${csharpFloatType} ${varName} = ${code};`);
+                }
             }
             // Emit epsilon guard if needed
             if (shouldEmitGuards && denominatorVars.size > 0) {
@@ -366,7 +464,7 @@ export function generateGradientFunction(func, gradients, env, options = {}) {
                 }
                 lines.push(`  };`);
             }
-            else {
+            else if (format === 'python') {
                 lines.push(`  ${gradName} = {`);
                 for (const comp of components) {
                     const [key, value] = comp.split(': ');
@@ -374,6 +472,15 @@ export function generateGradientFunction(func, gradients, env, options = {}) {
                 }
                 lines.push(`  }`);
             }
+            else if (format === 'csharp') {
+                lines.push(`    var ${gradName} = new ${capitalize(paramName)}Grad`);
+                lines.push(`    {`);
+                for (const comp of components) {
+                    const [key, value] = comp.split(': ');
+                    lines.push(`        ${capitalize(key)} = ${value},`);
+                }
+                lines.push(`    };`);
+            }
         }
         else {
             // Scalar gradient
@@ -381,9 +488,12 @@ export function generateGradientFunction(func, gradients, env, options = {}) {
             if (format === 'typescript' || format === 'javascript') {
                 lines.push(`  const ${gradName} = ${code};`);
             }
-            else {
+            else if (format === 'python') {
                 lines.push(`  ${gradName} = ${code}`);
             }
+            else if (format === 'csharp') {
+                lines.push(`    ${csharpFloatType} ${gradName} = ${code};`);
+            }
         }
     }
     lines.push('');
@@ -399,7 +509,7 @@ export function generateGradientFunction(func, gradients, env, options = {}) {
         lines.push(`  };`);
         lines.push('}');
     }
-    else {
+    else if (format === 'python') {
         lines.push(`  return {`);
         lines.push(`    "value": value,`);
         for (const gradName of gradNames) {
@@ -407,6 +517,16 @@ export function generateGradientFunction(func, gradients, env, options = {}) {
         }
         lines.push(`  }`);
     }
+    else if (format === 'csharp') {
+        lines.push(`    return new ${capitalize(func.name)}GradResult`);
+        lines.push(`    {`);
+        lines.push(`        Value = value,`);
+        for (const gradName of gradNames) {
+            lines.push(`        ${capitalize(gradName)} = ${gradName},`);
+        }
+        lines.push(`    };`);
+        lines.push('}');
+    }
     return lines.join('\n');
 }
 /**
@@ -414,16 +534,30 @@ export function generateGradientFunction(func, gradients, env, options = {}) {
  */
 export function generateForwardFunction(func, options = {}) {
     const format = options.format || 'typescript';
-    const codegen = new ExpressionCodeGen(format);
+    const csharpFloatType = options.csharpFloatType || 'float';
+    const codegen = new ExpressionCodeGen(format, csharpFloatType);
     const lines = [];
     // Function signature
     const paramNames = func.parameters.map(p => p.name).join(', ');
     if (format === 'typescript' || format === 'javascript') {
         lines.push(`function ${func.name}(${paramNames}) {`);
     }
-    else {
+    else if (format === 'python') {
         lines.push(`def ${func.name}(${paramNames}):`);
     }
+    else if (format === 'csharp') {
+        const floatType = csharpFloatType;
+        const params = func.parameters.map(p => {
+            if (p.paramType && p.paramType.components) {
+                // Structured parameter - create a struct type name
+                return `${capitalize(p.name)}Struct ${p.name}`;
+            }
+            return `${floatType} ${p.name}`;
+        }).join(', ');
+        // Generate struct definitions for structured parameters first (we'll prepend them later)
+        lines.push(`public static ${floatType} ${capitalize(func.name)}(${params})`);
+        lines.push('{');
+    }
     // Body
     for (const stmt of func.body) {
         if (stmt.kind === 'assignment') {
@@ -432,9 +566,12 @@ export function generateForwardFunction(func, options = {}) {
             if (format === 'typescript' || format === 'javascript') {
                 lines.push(`  const ${varName} = ${expr};`);
             }
-            else {
+            else if (format === 'python') {
                 lines.push(`  ${varName} = ${expr}`);
             }
+            else if (format === 'csharp') {
+                lines.push(`    ${csharpFloatType} ${varName} = ${expr};`);
+            }
         }
     }
     // Return
@@ -443,9 +580,31 @@ export function generateForwardFunction(func, options = {}) {
         lines.push(`  return ${returnExpr};`);
         lines.push('}');
     }
-    else {
+    else if (format === 'python') {
         lines.push(`  return ${returnExpr}`);
     }
+    else if (format === 'csharp') {
+        lines.push(`    return ${returnExpr};`);
+        lines.push('}');
+    }
+    // For C#, prepend struct definitions
+    if (format === 'csharp') {
+        const structLines = [];
+        for (const param of func.parameters) {
+            if (param.paramType && param.paramType.components) {
+                structLines.push(`public struct ${capitalize(param.name)}Struct`);
+                structLines.push('{');
+                for (const comp of param.paramType.components) {
+                    structLines.push(`    public ${csharpFloatType} ${capitalize(comp)};`);
+                }
+                structLines.push('}');
+                structLines.push('');
+            }
+        }
+        if (structLines.length > 0) {
+            return structLines.join('\n') + lines.join('\n');
+        }
+    }
     return lines.join('\n');
 }
 /**
@@ -466,6 +625,40 @@ export function generateComplete(func, gradients, env, options = {}) {
     lines.push(generateGradientFunction(func, gradients, env, options));
     return lines.join('\n');
 }
+class ForwardExpressionSubstituter extends ExpressionTransformer {
+    forwardExpressions;
+    constructor(forwardExpressions) {
+        super();
+        this.forwardExpressions = forwardExpressions;
+    }
+    transform(expr) {
+        const key = serializeExpression(expr);
+        const varName = this.forwardExpressions.get(key);
+        if (varName) {
+            return {
+                kind: 'variable',
+                name: varName
+            };
+        }
+        return super.transform(expr);
+    }
+}
+function reuseForwardExpressionsInGradients(gradients, forwardExpressions) {
+    if (forwardExpressions.size === 0) {
+        return;
+    }
+    const substituter = new ForwardExpressionSubstituter(forwardExpressions);
+    for (const [paramName, gradient] of gradients.entries()) {
+        if (isStructuredGradient(gradient)) {
+            for (const [component, expr] of gradient.components.entries()) {
+                gradient.components.set(component, substituter.transform(expr));
+            }
+        }
+        else {
+            gradients.set(paramName, substituter.transform(gradient));
+        }
+    }
+}
 /**
  * Type guard for StructuredGradient
  */

package/dist/dsl/Errors.d.ts

@@ -2,8 +2,13 @@ export declare class ParseError extends Error {
     line: number;
     column: number;
     token?: string | undefined;
-    constructor(message: string, line: number, column: number, token?: string | undefined);
+    sourceContext?: string | undefined;
+    constructor(message: string, line: number, column: number, token?: string | undefined, sourceContext?: string | undefined);
 }
+/**
+ * Format a user-friendly error message with source context
+ */
+export declare function formatParseError(error: ParseError, sourceCode: string, verbose?: boolean): string;
 export declare class TypeError extends Error {
     expression: string;
     expectedType?: string | undefined;

package/dist/dsl/Errors.js

@@ -2,14 +2,83 @@ export class ParseError extends Error {
     line;
     column;
     token;
-    constructor(message, line, column, token) {
+    sourceContext;
+    constructor(message, line, column, token, sourceContext) {
         super(`Parse error at ${line}:${column}: ${message}`);
         this.line = line;
         this.column = column;
         this.token = token;
+        this.sourceContext = sourceContext;
         this.name = 'ParseError';
     }
 }
+/**
+ * Format a user-friendly error message with source context
+ */
+export function formatParseError(error, sourceCode, verbose = false) {
+    const lines = sourceCode.split('\n');
+    const errorLine = lines[error.line - 1];
+    let output = `Error: ${error.message.replace(/^Parse error at \d+:\d+: /, '')}\n`;
+    // Show the source line with the error
+    if (errorLine) {
+        output += `\n  ${errorLine}\n`;
+        // Add caret pointing to error position
+        const caretPos = Math.max(0, error.column - 1);
+        output += `  ${' '.repeat(caretPos)}^\n`;
+    }
+    // Add helpful tips based on the error
+    output += formatErrorGuidance(error);
+    // Only show stack trace in verbose mode
+    if (verbose && error.stack) {
+        output += '\n\nStack trace:\n' + error.stack;
+    }
+    return output;
+}
+/**
+ * Provide contextual guidance based on error patterns
+ */
+function formatErrorGuidance(error) {
+    const msg = error.message.toLowerCase();
+    const token = error.token;
+    // Semicolon error
+    if (token === ';') {
+        return `
+Semicolons are not part of gradient-script syntax.
+Each statement should be on its own line.
+
+Correct syntax:
+  function example(x∇, y∇) {
+    result = x + y
+    return result
+  }
+
+💡 Tip: gradient-script uses newline-delimited statements (like Python),
+        not semicolons (like JavaScript/C#).
+`;
+    }
+    // Missing colon in type annotation
+    if (msg.includes("expected ':'")) {
+        return `
+Type annotations require a colon before the type.
+
+Correct syntax:
+  function distance(point∇: {x, y}) {
+                          ^
+
+💡 Tip: Parameters marked with ∇ need type annotations to specify structure.
+`;
+    }
+    // Missing gradient marker suggestion
+    if (msg.includes('expected parameter name') || msg.includes('unexpected')) {
+        return `
+💡 Tip: Make sure all parameters are properly formatted.
+        Variables that need gradients must be marked with ∇.
+
+        Example: function f(a∇: {x, y}, b) { ... }
+`;
+    }
+    return '';
+}
 export class TypeError extends Error {
     expression;
     expectedType;

package/dist/dsl/Expander.js

@@ -2,6 +2,7 @@
  * Expander for GradientScript DSL
  * Expands built-in functions and struct operations into scalar operations
  */
+import { DifferentiationError } from './Errors.js';
 /**
  * Expand built-in function calls to scalar expressions
  */
@@ -15,13 +16,15 @@ export function expandBuiltIn(call) {
         case 'magnitude2d':
             return expandMagnitude2d(args[0]);
         case 'normalize2d':
-            throw new Error('normalize2d not yet supported in differentiation');
+            throw new DifferentiationError('normalize2d not yet supported', 'normalize2d', 'Vector normalization requires special handling for zero-length vectors. ' +
+                'Use magnitude2d() and division for now.');
         case 'distance2d':
             return expandDistance2d(args[0], args[1]);
         case 'dot3d':
             return expandDot3d(args[0], args[1]);
         case 'cross3d':
-            throw new Error('cross3d returns vector - not yet supported');
+            throw new DifferentiationError('cross3d returns vector - not yet supported', 'cross3d', 'Cross product returns a 3D vector, which requires structured gradient support. ' +
+                'This feature is not yet implemented.');
         case 'magnitude3d':
             return expandMagnitude3d(args[0]);
         default:

package/dist/dsl/ExpressionUtils.d.ts

@@ -53,3 +53,11 @@ export declare function containsVariable(expr: Expression, varName: string): boo
  * Calculate the maximum nesting depth of an expression
  */
 export declare function expressionDepth(expr: Expression): number;
+/**
+ * Serializes an expression to canonical string representation.
+ * Used for expression comparison and hashing (CSE, CodeGen forward reuse).
+ *
+ * This ensures consistent string representation of expressions across different
+ * parts of the codebase.
+ */
+export declare function serializeExpression(expr: Expression): string;

package/dist/dsl/ExpressionUtils.js

@@ -173,3 +173,27 @@ export function expressionDepth(expr) {
             return 1 + expressionDepth(expr.object);
     }
 }
+/**
+ * Serializes an expression to canonical string representation.
+ * Used for expression comparison and hashing (CSE, CodeGen forward reuse).
+ *
+ * This ensures consistent string representation of expressions across different
+ * parts of the codebase.
+ */
+export function serializeExpression(expr) {
+    switch (expr.kind) {
+        case 'number':
+            return `num(${expr.value})`;
+        case 'variable':
+            return `var(${expr.name})`;
+        case 'binary':
+            return `bin(${expr.operator},${serializeExpression(expr.left)},${serializeExpression(expr.right)})`;
+        case 'unary':
+            return `un(${expr.operator},${serializeExpression(expr.operand)})`;
+        case 'call':
+            const args = expr.args.map(arg => serializeExpression(arg)).join(',');
+            return `call(${expr.name},${args})`;
+        case 'component':
+            return `comp(${serializeExpression(expr.object)},${expr.component})`;
+    }
+}

package/dist/dsl/Guards.d.ts

@@ -8,6 +8,8 @@ export interface Guard {
     expression: Expression;
     description: string;
     suggestion: string;
+    variableName?: string;
+    line?: number;
 }
 export interface GuardAnalysisResult {
     guards: Guard[];