mathjslab

import type { NodeArgumentValidation, NodeExpr, NodeFunctionDefinition, NodeInput } from './AST'; type ThrowSyntaxError = (message: string) => never; type ThrowEvalError = (message: string) => never; type ArgumentSizeDimension = number | { type: 'symbol'; name: string; } | { type: 'any'; }; type ArgumentValidatorSpec = { name: string; value?: NodeExpr; bounds?: NodeExpr[]; custom?: 'implicit' | 'explicit'; expression?: NodeExpr; }; type ValidationEntry = { node?: NodeInput; }; type ArgumentValidationCallbacks = { resolveEntry: (validation: NodeArgumentValidation, localNamesOnly: boolean) => ValidationEntry | undefined; evaluate: (expr: NodeExpr) => NodeInput; throwEvalError: ThrowEvalError; throwSyntaxError: ThrowSyntaxError; }; type RepeatingArgumentValidationCallbacks = Omit<ArgumentValidationCallbacks, 'resolveEntry'> & { validateRepeatingValue: (validation: NodeArgumentValidation, validationName: string, value: NodeInput, displayName: string, symbolicDimensions: Map<string, number>) => void; }; /** * Parser-independent support for MATLAB-like `arguments` blocks. * * The parser produces `NodeArgumentValidation` records. This module interprets * those records for: * * - input/output/repeating argument blocks, * - literal and symbolic size declarations, * - supported class declarations, * - built-in and user-defined `mustBe*` validators, * - default values for input parameters, * - name-value option declarations such as `opts.Field`, * - call splitting for positional and name-value arguments. * * It deliberately receives callbacks for lookup, evaluation, and error * construction so validation rules remain independent from `Interpreter.ts`. */ declare class FunctionArguments { /** * Classes currently supported by the function infrastructure. * * A future class-system implementation can expand this list without * changing the parser representation of `arguments` blocks. */ private static readonly supportedArgumentClasses; /** * Render one argument-size dimension for diagnostics. */ private static argumentSizeDimensionDisplay; /** * Render a size declaration in a MATLAB-like diagnostic form. */ static argumentSizeDisplay(dimensions: ArgumentSizeDimension[]): string; /** * Return the declared argument name, rejecting non-identifier declarations. */ static validationName(validation: NodeArgumentValidation, throwSyntaxError: ThrowSyntaxError): string; /** * Decode a name-value declaration target. * * `arguments` declarations of the form `opts.Name` are represented as field * access nodes. The returned pair identifies the parameter object and the * option field. */ static nameValueTarget(validation: NodeArgumentValidation, throwSyntaxError: ThrowSyntaxError): { parameter: string; field: string; } | undefined; /** * Return the diagnostic display name for ordinary or name-value declarations. */ static validationDisplayName(validation: NodeArgumentValidation, throwSyntaxError: ThrowSyntaxError): string; /** * Convert a size declaration to literal/symbolic dimensions. * * Numeric dimensions are fixed. Identifiers are symbolic dimensions shared * within one validation pass. `:` accepts any actual dimension. */ static literalArgumentSize(validation: NodeArgumentValidation, throwSyntaxError: ThrowSyntaxError): ArgumentSizeDimension[] | undefined; /** * Return all supported class names declared for one argument. */ static argumentClassNames(validation: NodeArgumentValidation, throwSyntaxError: ThrowSyntaxError): string[] | undefined; /** * Return a single class name when exactly one class is declared. */ static argumentClassName(validation: NodeArgumentValidation, throwSyntaxError: ThrowSyntaxError): string | undefined; /** * Format a list of class names for diagnostics. */ static argumentClassDisplay(classNames: string[]): string; /** * Parse function validators from an `arguments` declaration. * * Built-in validators are normalized to `ArgumentValidatorSpec` objects. * Unknown bare validators are treated as implicit user validators and called * with the argument value. Unknown indexed validators are treated as explicit * validator expressions and evaluated as written. */ static argumentValidators(validation: NodeArgumentValidation, throwSyntaxError: ThrowSyntaxError): ArgumentValidatorSpec[]; /** * Return the MATLAB-like size of a value. */ static valueSize(value: NodeInput): number[]; /** * Validate one built-in `mustBe*` function against an evaluated value. */ static validateArgumentFunction(name: string, value: NodeInput, validator: string, bounds: NodeInput[], throwEvalError: ThrowEvalError, throwSyntaxError: ThrowSyntaxError): void; /** * Validate one declaration against the current function workspace. * * `symbolicDimensions` is shared by declarations in the same block pass so * `(n,1)` style declarations bind `n` once and require later uses to match. * `localNamesOnly` is used for output validation so inherited names cannot * accidentally satisfy a declared but unassigned return variable. */ static validateArgumentValidation(validation: NodeArgumentValidation, symbolicDimensions: Map<string, number>, callbacks: ArgumentValidationCallbacks, localNamesOnly?: boolean, displayName?: string): void; /** * Validate all declarations for one block attribute (`Input` or `Output`). */ static validateFunctionArguments(func: NodeFunctionDefinition, targetAttribute: 'Input' | 'Output', callbacks: ArgumentValidationCallbacks, namesToValidate?: Set<string>, localNamesOnly?: boolean): void; /** * Validate `arguments (Repeating)` values grouped across `varargin`. */ static validateRepeatingArguments(func: NodeFunctionDefinition, values: NodeInput[], callbacks: RepeatingArgumentValidationCallbacks): void; /** * Validate the static consistency of all `arguments` blocks in a function. * * This is run when a function definition is registered, before any call, so * malformed declarations fail early and subsequent call-time validation can * assume the block structure is coherent. */ static validateBlocks(func: NodeFunctionDefinition, throwSyntaxError: ThrowSyntaxError): void; /** * Return parameter names that are backed by name-value declarations. */ static nameValueParameters(func: NodeFunctionDefinition, throwSyntaxError: ThrowSyntaxError): Set<string>; /** * Return name-value declarations grouped by their parameter object. */ static nameValueDeclarations(func: NodeFunctionDefinition, throwSyntaxError: ThrowSyntaxError): Map<string, Map<string, NodeArgumentValidation>>; /** * Return ordinary input-parameter default expressions. */ static inputArgumentDefaults(func: NodeFunctionDefinition, throwSyntaxError: ThrowSyntaxError): Map<string, NodeExpr>; /** * Split call arguments into positional and name-value maps. * * Supported MATLAB-like forms include `Name=value` and `'Name', value`. * Matching is case-insensitive and accepts unambiguous prefixes. Once a * name-value argument is seen, later positional arguments are rejected. */ static splitCallNameValueArguments(func: NodeFunctionDefinition, args: NodeExpr[], throwEvalError: ThrowEvalError, throwSyntaxError: ThrowSyntaxError): { positional: NodeExpr[]; named: Map<string, NodeExpr>; }; /** * Determine which declared output names must be validated. * * Only requested fixed outputs are checked. This preserves the MATLAB-like * behavior where requesting fewer outputs does not require later return * variables to be assigned. */ static outputNamesToValidate(func: NodeFunctionDefinition, requestedOutputCount: number): Set<string> | undefined; } export type { ArgumentValidatorSpec }; export { FunctionArguments }; declare const _default: { FunctionArguments: typeof FunctionArguments; }; export default _default;