codexivo 0.0.0-stage → 0.2.0

package/src/runtime/suggest.ts

@@ -0,0 +1,33 @@
+const distance = (a: string, b: string): number => {
+  const previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = previous[0]!;
+    previous[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = previous[j]!;
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      previous[j] = Math.min(previous[j]! + 1, previous[j - 1]! + 1, diagonal + cost);
+      diagonal = above;
+    }
+  }
+  return previous[b.length]!;
+};
+
+const fold = (text: string): string => text.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+
+/** El nombre más parecido a `name` entre `candidates`, si hay uno razonablemente cerca. */
+export const suggestName = (name: string, candidates: Iterable<string>): string | undefined => {
+  const target = fold(name);
+  const limit = target.length <= 3 ? 1 : 2;
+  let best: string | undefined;
+  let bestDistance = Infinity;
+  for (const candidate of new Set(candidates)) {
+    if (candidate === name) continue;
+    const current = distance(target, fold(candidate));
+    if (current <= limit && current < bestDistance) {
+      best = candidate;
+      bestDistance = current;
+    }
+  }
+  return best;
+};

package/src/runtime/values.ts

@@ -0,0 +1,140 @@
+import type { CodexivoError } from '../errors';
+import type { Chunk } from './compiler';
+
+/**
+ * Valores en tiempo de ejecución. Números, textos, lógicos y `nulo` son primitivos de JavaScript;
+ * listas y procedimientos son objetos con un `id` para poder dibujar cuándo dos variables
+ * comparten el mismo valor.
+ */
+export type Value = number | string | boolean | null | ListValue | ProcedureValue | NativeValue;
+
+export interface ListValue {
+  kind: 'lista';
+  id: number;
+  items: Value[];
+}
+
+export interface ProcedureValue {
+  kind: 'procedimiento';
+  id: number;
+  name?: string;
+  chunk: Chunk;
+  closure: Scope;
+}
+
+/** Contexto que la máquina le da a los procedimientos nativos. */
+export interface NativeContext {
+  write(text: string): void;
+  /** Siguiente línea de entrada, `null` si ya no hay, o `WAIT_FOR_INPUT` si hay que pedirla. */
+  readLine(): string | null | typeof WAIT_FOR_INPUT;
+  newList(items: Value[]): ListValue;
+  /** Error de ejecución ubicado en la llamada actual. */
+  fail(code: string, message: string, hint?: string): CodexivoError;
+}
+
+export const WAIT_FOR_INPUT: unique symbol = Symbol('esperar-entrada');
+
+export interface NativeValue {
+  kind: 'nativo';
+  name: string;
+  /** Cantidad de argumentos: exacta, o `[mínimo, máximo]` (`máximo` puede ser `Infinity`). */
+  arity: number | [number, number];
+  call(args: Value[], context: NativeContext): Value | typeof WAIT_FOR_INPUT;
+}
+
+export type TypeName = 'número' | 'texto' | 'lógico' | 'nulo' | 'lista' | 'procedimiento';
+
+export const typeOf = (value: Value): TypeName => {
+  if (value === null) return 'nulo';
+  switch (typeof value) {
+    case 'number':
+      return 'número';
+    case 'string':
+      return 'texto';
+    case 'boolean':
+      return 'lógico';
+    default:
+      return value.kind === 'lista' ? 'lista' : 'procedimiento';
+  }
+};
+
+/** "un número", "una lista"… para mensajes. */
+export const describeType = (type: TypeName): string => {
+  switch (type) {
+    case 'lista':
+      return 'una lista';
+    case 'nulo':
+      return '`nulo`';
+    default:
+      return `un ${type}`;
+  }
+};
+
+export const isList = (value: Value): value is ListValue =>
+  typeof value === 'object' && value !== null && value.kind === 'lista';
+
+export const isCallable = (value: Value): value is ProcedureValue | NativeValue =>
+  typeof value === 'object' && value !== null && (value.kind === 'procedimiento' || value.kind === 'nativo');
+
+const formatNumber = (value: number): string => {
+  if (Object.is(value, -0)) return '0';
+  if (value === Infinity) return 'infinito';
+  if (value === -Infinity) return '-infinito';
+  return String(value);
+};
+
+/** Representación como se escribiría en código: los textos van entre comillas. */
+export const repr = (value: Value, seen: Set<ListValue> = new Set()): string => {
+  if (value === null) return 'nulo';
+  switch (typeof value) {
+    case 'number':
+      return formatNumber(value);
+    case 'string':
+      return JSON.stringify(value);
+    case 'boolean':
+      return value ? 'verdadero' : 'falso';
+  }
+  if (value.kind === 'lista') {
+    if (seen.has(value)) return '[…]';
+    seen.add(value);
+    const inner = value.items.map(item => repr(item, seen)).join(', ');
+    seen.delete(value);
+    return `[${inner}]`;
+  }
+  return value.name ? `procedimiento ${value.name}` : 'procedimiento';
+};
+
+/** Como lo muestra `imprimir`: los textos sin comillas. */
+export const show = (value: Value): string => (typeof value === 'string' ? value : repr(value));
+
+/** Igualdad por valor: dos listas son iguales si tienen los mismos elementos en el mismo orden. */
+export const equals = (a: Value, b: Value, seen: Array<[ListValue, ListValue]> = []): boolean => {
+  if (a === b) return true;
+  if (isList(a) && isList(b)) {
+    if (a.items.length !== b.items.length) return false;
+    if (seen.some(([x, y]) => x === a && y === b)) return true;
+    seen.push([a, b]);
+    const result = a.items.every((item, index) => equals(item, b.items[index]!, seen));
+    seen.pop();
+    return result;
+  }
+  return false;
+};
+
+/**
+ * Un alcance: las variables de un bloque. `parent` apunta al alcance que lo contiene.
+ */
+export class Scope {
+  readonly variables = new Map<string, Value>();
+
+  constructor(readonly parent?: Scope) {}
+
+  lookup(name: string): Scope | undefined {
+    let scope: Scope | undefined = this;
+    while (scope) {
+      if (scope.variables.has(name)) return scope;
+      scope = scope.parent;
+    }
+    return undefined;
+  }
+}

package/src/syntax/ast.ts

@@ -0,0 +1,230 @@
+import type { Span } from './token';
+
+/**
+ * El AST está hecho de objetos planos: se puede serializar, enviar a un Web Worker y dibujar sin
+ * perder información. Cada nodo tiene un `id` único dentro de su programa y su rango en el código.
+ */
+interface BaseNode {
+  id: number;
+  span: Span;
+}
+
+export type BinaryOperator = '+' | '-' | '*' | '/' | '==' | '!=' | '<' | '>' | '<=' | '>=';
+export type LogicalOperator = 'y' | 'o';
+export type UnaryOperator = '-' | 'no';
+export type AssignmentOperator = '=' | '+=' | '-=' | '*=' | '/=';
+
+// ── expresiones ──────────────────────────────────────────────────────────────
+
+export interface NumberLiteral extends BaseNode {
+  kind: 'NumberLiteral';
+  value: number;
+}
+
+export interface StringLiteral extends BaseNode {
+  kind: 'StringLiteral';
+  value: string;
+}
+
+export interface BooleanLiteral extends BaseNode {
+  kind: 'BooleanLiteral';
+  value: boolean;
+}
+
+export interface NullLiteral extends BaseNode {
+  kind: 'NullLiteral';
+}
+
+export interface ListLiteral extends BaseNode {
+  kind: 'ListLiteral';
+  elements: Expression[];
+}
+
+export interface Identifier extends BaseNode {
+  kind: 'Identifier';
+  name: string;
+}
+
+export interface Unary extends BaseNode {
+  kind: 'Unary';
+  operator: UnaryOperator;
+  operand: Expression;
+}
+
+export interface Binary extends BaseNode {
+  kind: 'Binary';
+  operator: BinaryOperator;
+  left: Expression;
+  right: Expression;
+}
+
+/** `y` / `o`: se evalúan en cortocircuito, por eso no son un `Binary`. */
+export interface Logical extends BaseNode {
+  kind: 'Logical';
+  operator: LogicalOperator;
+  left: Expression;
+  right: Expression;
+}
+
+export interface Call extends BaseNode {
+  kind: 'Call';
+  callee: Expression;
+  args: Expression[];
+}
+
+export interface Index extends BaseNode {
+  kind: 'Index';
+  object: Expression;
+  index: Expression;
+}
+
+export interface FunctionLiteral extends BaseNode {
+  kind: 'FunctionLiteral';
+  /** Nombre con el que se declaró, si se conoce (`variable doble = procedimiento…` → `doble`). */
+  name?: string;
+  params: Identifier[];
+  body: Block;
+}
+
+export type Expression =
+  | NumberLiteral
+  | StringLiteral
+  | BooleanLiteral
+  | NullLiteral
+  | ListLiteral
+  | Identifier
+  | Unary
+  | Binary
+  | Logical
+  | Call
+  | Index
+  | FunctionLiteral;
+
+// ── sentencias ───────────────────────────────────────────────────────────────
+
+export interface VariableDeclaration extends BaseNode {
+  kind: 'VariableDeclaration';
+  name: Identifier;
+  value: Expression;
+}
+
+export interface Assignment extends BaseNode {
+  kind: 'Assignment';
+  target: Identifier;
+  operator: AssignmentOperator;
+  value: Expression;
+}
+
+export interface ExpressionStatement extends BaseNode {
+  kind: 'ExpressionStatement';
+  expression: Expression;
+}
+
+export interface Return extends BaseNode {
+  kind: 'Return';
+  value?: Expression;
+}
+
+export interface Block extends BaseNode {
+  kind: 'Block';
+  statements: Statement[];
+}
+
+export interface IfBranch {
+  /** Rango de la rama completa: desde `si` / `pero_si` hasta su `}`. */
+  span: Span;
+  condition: Expression;
+  body: Block;
+}
+
+/** `si … pero_si … si_no`: las ramas se guardan en orden, no anidadas. */
+export interface If extends BaseNode {
+  kind: 'If';
+  branches: IfBranch[];
+  alternative?: Block;
+}
+
+export interface While extends BaseNode {
+  kind: 'While';
+  condition: Expression;
+  body: Block;
+}
+
+/** `hacer { … } hasta_que (condición)`: repite el cuerpo hasta que la condición sea verdadera. */
+export interface DoUntil extends BaseNode {
+  kind: 'DoUntil';
+  body: Block;
+  condition: Expression;
+}
+
+export interface For extends BaseNode {
+  kind: 'For';
+  init?: VariableDeclaration | Assignment | ExpressionStatement;
+  condition?: Expression;
+  update?: Assignment | ExpressionStatement;
+  body: Block;
+}
+
+export type Statement =
+  VariableDeclaration | Assignment | ExpressionStatement | Return | Block | If | While | DoUntil | For;
+
+export interface Program extends BaseNode {
+  kind: 'Program';
+  statements: Statement[];
+}
+
+export type Node = Program | Statement | Expression;
+
+/** Hijos directos de un nodo, en el orden en que aparecen en el código. */
+export const childrenOf = (node: Node): Node[] => {
+  switch (node.kind) {
+    case 'Program':
+    case 'Block':
+      return node.statements;
+    case 'ListLiteral':
+      return node.elements;
+    case 'Unary':
+      return [node.operand];
+    case 'Binary':
+    case 'Logical':
+      return [node.left, node.right];
+    case 'Call':
+      return [node.callee, ...node.args];
+    case 'Index':
+      return [node.object, node.index];
+    case 'FunctionLiteral':
+      return [...node.params, node.body];
+    case 'VariableDeclaration':
+      return [node.name, node.value];
+    case 'Assignment':
+      return [node.target, node.value];
+    case 'ExpressionStatement':
+      return [node.expression];
+    case 'Return':
+      return node.value ? [node.value] : [];
+    case 'If':
+      return [
+        ...node.branches.flatMap(branch => [branch.condition, branch.body]),
+        ...(node.alternative ? [node.alternative] : []),
+      ];
+    case 'While':
+      return [node.condition, node.body];
+    case 'DoUntil':
+      return [node.body, node.condition];
+    case 'For':
+      return [
+        ...(node.init ? [node.init] : []),
+        ...(node.condition ? [node.condition] : []),
+        ...(node.update ? [node.update] : []),
+        node.body,
+      ];
+    default:
+      return [];
+  }
+};
+
+/** Recorre el árbol en profundidad, del padre a los hijos. */
+export const walk = (node: Node, visit: (node: Node, parent?: Node) => void, parent?: Node): void => {
+  visit(node, parent);
+  for (const child of childrenOf(node)) walk(child, visit, node);
+};

package/src/syntax/lexer.ts

@@ -0,0 +1,232 @@
+import { CodexivoError } from '../errors';
+import { KEYWORDS, TokenType } from './token';
+import type { Position, Span, Token } from './token';
+
+export interface LexResult {
+  tokens: Token[];
+  errors: CodexivoError[];
+}
+
+const LETTER = /[A-Za-z_À-ÖØ-öø-ÿ]/;
+const DIGIT = /[0-9]/;
+const WHITESPACE = /\s/;
+
+const TWO_CHAR_OPERATORS: Readonly<Record<string, TokenType>> = {
+  '==': TokenType.EQ,
+  '!=': TokenType.NEQ,
+  '<=': TokenType.LTE,
+  '>=': TokenType.GTE,
+  '+=': TokenType.PLUS_ASSIGN,
+  '-=': TokenType.MINUS_ASSIGN,
+  '*=': TokenType.STAR_ASSIGN,
+  '/=': TokenType.SLASH_ASSIGN,
+};
+
+const ONE_CHAR_OPERATORS: Readonly<Record<string, TokenType>> = {
+  '=': TokenType.ASSIGN,
+  '+': TokenType.PLUS,
+  '-': TokenType.MINUS,
+  '*': TokenType.STAR,
+  '/': TokenType.SLASH,
+  '!': TokenType.BANG,
+  '<': TokenType.LT,
+  '>': TokenType.GT,
+  ',': TokenType.COMMA,
+  ';': TokenType.SEMICOLON,
+  '(': TokenType.LPAREN,
+  ')': TokenType.RPAREN,
+  '{': TokenType.LBRACE,
+  '}': TokenType.RBRACE,
+  '[': TokenType.LBRACKET,
+  ']': TokenType.RBRACKET,
+};
+
+const ESCAPES: Readonly<Record<string, string>> = {
+  n: '\n',
+  t: '\t',
+  '\\': '\\',
+  '"': '"',
+  "'": "'",
+};
+
+const ILLEGAL_HINTS: Readonly<Record<string, string>> = {
+  '&': 'Para el «y» lógico escribe la palabra `y`.',
+  '|': 'Para el «o» lógico escribe la palabra `o`.',
+  '“': 'Parece una comilla tipográfica; usa comillas rectas `"`.',
+  '”': 'Parece una comilla tipográfica; usa comillas rectas `"`.',
+  '‘': "Parece una comilla tipográfica; usa comillas rectas `'`.",
+  '’': "Parece una comilla tipográfica; usa comillas rectas `'`.",
+};
+
+/** Convierte código fuente en tokens. Nunca lanza: los problemas se reportan en `errors`. */
+export const tokenize = (source: string): LexResult => {
+  const tokens: Token[] = [];
+  const errors: CodexivoError[] = [];
+
+  let offset = 0;
+  let line = 1;
+  let column = 1;
+
+  const position = (): Position => ({ line, column, offset });
+  const peek = (ahead = 0): string => source[offset + ahead] ?? '';
+  const advance = (): string => {
+    const character = source[offset] ?? '';
+    offset += 1;
+    if (character === '\n') {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+    return character;
+  };
+
+  const push = (type: TokenType, start: Position, value?: number | string): Token => {
+    const token: Token = { type, lexeme: source.slice(start.offset, offset), span: { start, end: position() } };
+    if (value !== undefined) token.value = value;
+    tokens.push(token);
+    return token;
+  };
+
+  const lexicalError = (code: string, message: string, span: Span, hint?: string) => {
+    errors.push(new CodexivoError({ kind: 'léxico', code, message, hint, span }));
+  };
+
+  while (offset < source.length) {
+    const character = peek();
+
+    if (WHITESPACE.test(character)) {
+      advance();
+      continue;
+    }
+
+    const start = position();
+
+    // comentarios
+    if (character === '/' && peek(1) === '/') {
+      while (offset < source.length && peek() !== '\n') advance();
+      continue;
+    }
+    if (character === '/' && peek(1) === '*') {
+      advance();
+      advance();
+      while (offset < source.length && !(peek() === '*' && peek(1) === '/')) advance();
+      if (offset >= source.length) {
+        lexicalError(
+          'COMENTARIO_SIN_CERRAR',
+          'El comentario que empieza aquí no se cerró.',
+          {
+            start,
+            end: { line: start.line, column: start.column + 2, offset: start.offset + 2 },
+          },
+          'Cierra el comentario con `*/`.',
+        );
+      } else {
+        advance();
+        advance();
+      }
+      continue;
+    }
+
+    // números
+    if (DIGIT.test(character) || (character === '.' && DIGIT.test(peek(1)))) {
+      while (DIGIT.test(peek())) advance();
+      if (peek() === '.' && DIGIT.test(peek(1))) {
+        advance();
+        while (DIGIT.test(peek())) advance();
+      }
+      if (LETTER.test(peek())) {
+        while (LETTER.test(peek()) || DIGIT.test(peek())) advance();
+        const token = push(TokenType.ILLEGAL, start);
+        lexicalError(
+          'NOMBRE_EMPIEZA_CON_NÚMERO',
+          `\`${token.lexeme}\` no es un número ni un nombre válido.`,
+          token.span,
+          'Los nombres no pueden empezar con un dígito. Si es una multiplicación, escribe el operador: `2 * x`.',
+        );
+        continue;
+      }
+      push(TokenType.NUMBER, start, Number(source.slice(start.offset, offset)));
+      continue;
+    }
+
+    // nombres y palabras reservadas
+    if (LETTER.test(character)) {
+      while (LETTER.test(peek()) || DIGIT.test(peek())) advance();
+      const word = source.slice(start.offset, offset);
+      push(KEYWORDS[word] ?? TokenType.IDENT, start);
+      continue;
+    }
+
+    // textos
+    if (character === '"' || character === "'") {
+      const quote = advance();
+      let value = '';
+      let closed = false;
+      while (offset < source.length && peek() !== '\n') {
+        const current = advance();
+        if (current === quote) {
+          closed = true;
+          break;
+        }
+        if (current === '\\') {
+          const escapeStart = { line, column: column - 1, offset: offset - 1 };
+          const escaped = advance();
+          const replacement = ESCAPES[escaped];
+          if (replacement === undefined) {
+            lexicalError(
+              'ESCAPE_DESCONOCIDO',
+              `\`\\${escaped}\` no es una secuencia de escape válida.`,
+              { start: escapeStart, end: position() },
+              'Las secuencias válidas son `\\n`, `\\t`, `\\\\`, `\\"` y `\\\'`.',
+            );
+            value += escaped;
+          } else {
+            value += replacement;
+          }
+          continue;
+        }
+        value += current;
+      }
+      const token = push(TokenType.STRING, start, value);
+      if (!closed) {
+        lexicalError(
+          'TEXTO_SIN_CERRAR',
+          'El texto que empieza aquí no se cerró.',
+          token.span,
+          `Agrega la comilla \`${quote}\` al final. Un texto no puede ocupar varias líneas; usa \`\\n\` para un salto de línea.`,
+        );
+      }
+      continue;
+    }
+
+    // operadores y delimitadores
+    const pair = character + peek(1);
+    const twoChar = TWO_CHAR_OPERATORS[pair];
+    if (twoChar) {
+      advance();
+      advance();
+      push(twoChar, start);
+      continue;
+    }
+    const oneChar = ONE_CHAR_OPERATORS[character];
+    if (oneChar) {
+      advance();
+      push(oneChar, start);
+      continue;
+    }
+
+    advance();
+    const token = push(TokenType.ILLEGAL, start);
+    lexicalError(
+      'CARÁCTER_DESCONOCIDO',
+      `Codexivo no reconoce el carácter \`${character}\`.`,
+      token.span,
+      ILLEGAL_HINTS[character],
+    );
+  }
+
+  const end = position();
+  tokens.push({ type: TokenType.EOF, lexeme: '', span: { start: end, end } });
+  return { tokens, errors };
+};