xanascript 2.0.0

package/src/lsp.js

@@ -0,0 +1,304 @@
+import fs from "fs";
+import { lex } from "./lexer.js";
+import { parse } from "./parser.js";
+import { setSource, XSError, formatError } from "./errors.js";
+
+const KEYWORDS = [
+  "PARTIU", "ACABOU", "CRIA", "SE", "LIGA", "SO", "SENAO",
+  "REPETE", "NA", "MORAL", "CHAMA", "ESSE", "CARA", "VOLTA",
+  "IMPORTA", "EXPORTA", "SOLTA", "O", "GRITO", "FALA", "BAIXO",
+  "AGORA", "VAI", "ESPERA", "AI", "SORTEIA", "PARSEIA", "OUVE",
+  "AQUI", "VERDADEIRO", "FALSO", "NULO", "TENTA", "PEGA", "ERRO",
+  "ASSINCRONO", "VOA", "CONTINUA", "CLASSE", "HERDA", "CONSTRUTOR",
+  "ISTO", "NOVA", "METODO", "ESCOLHE", "CASO", "PADRAO", "COMBINA",
+  "CRIA", "SERVIDOR", "PARA", "TAMANHO", "DIVIDE", "TEXTO",
+  "ENCONTRA", "DECODIFICA", "URL", "JUNTAR", "TESTE", "AFIRMA",
+  "ASSUNTO", "TAREFA", "MACRO",
+];
+
+const BUILTIN_FUNCTIONS = [
+  { name: "SOLTA_O_GRITO", params: "...args", doc: "console.log()" },
+  { name: "FALA_BAIXO", params: "...args", doc: "console.warn()" },
+  { name: "AGORA_VAI", params: "url", doc: "HTTP GET request" },
+  { name: "ESPERA_AI", params: "ms", doc: "setTimeout()" },
+  { name: "SORTEIA", params: "min, max", doc: "Random integer" },
+  { name: "PARSEIA", params: "json", doc: "JSON.parse()" },
+  { name: "OUVE_AQUI", params: "chave", doc: "ENV variable" },
+  { name: "TAMANHO", params: "valor", doc: "Length of array/string" },
+  { name: "DIVIDE_TEXTO", params: "texto, separador", doc: "String split" },
+  { name: "ENCONTRA", params: "texto, regex", doc: "Regex match" },
+  { name: "DECODIFICA_URL", params: "url", doc: "URL decode" },
+  { name: "JUNTAR", params: "array, separador", doc: "Array join" },
+  { name: "AGORA", params: "", doc: "Date.now()" },
+  { name: "AFIRMA", params: "condicao", doc: "Assert truthy" },
+  { name: "ASSUNTO", params: "a, b", doc: "Assert equal" },
+  { name: "CRIA_SERVIDOR", params: "porta, handler", doc: "Create HTTP server" },
+  { name: "PARA_SERVIDOR", params: "server", doc: "Stop HTTP server" },
+];
+
+let documents = new Map();
+let requestId = 0;
+
+export async function startLSPServer() {
+  process.stdin.setEncoding("utf-8");
+  let buffer = "";
+
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    const parts = buffer.split("\r\n\r\n");
+    if (parts.length < 2) return;
+
+    const header = parts[0];
+    const contentLength = parseInt(header.match(/Content-Length: (\d+)/)?.[1] || "0");
+    const bodyStart = header.length + 4;
+
+    if (buffer.length < bodyStart + contentLength) return;
+
+    const body = buffer.slice(bodyStart, bodyStart + contentLength);
+    buffer = buffer.slice(bodyStart + contentLength);
+
+    try {
+      const msg = JSON.parse(body);
+      handleMessage(msg);
+    } catch (e) {
+
+    }
+  });
+
+  process.stdin.on("end", () => process.exit(0));
+}
+
+function sendMessage(msg) {
+  const body = JSON.stringify(msg);
+  const header = `Content-Length: ${Buffer.byteLength(body, "utf-8")}\r\nContent-Type: application/vscode-jsonrpc;charset=utf-8\r\n\r\n`;
+  process.stdout.write(header + body);
+}
+
+function handleMessage(msg) {
+  const { method, id, params } = msg;
+
+  switch (method) {
+    case "initialize":
+      sendMessage({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          capabilities: {
+            textDocumentSync: { openClose: true, change: 1 },
+            completionProvider: { triggerCharacters: [".", "(", " "] },
+            hoverProvider: true,
+            definitionProvider: true,
+            diagnosticProvider: true,
+          },
+          serverInfo: { name: "xanascript-lsp", version: "2.0.0" },
+        },
+      });
+      break;
+
+    case "initialized":
+      sendMessage({ jsonrpc: "2.0", method: "window/logMessage", params: { type: 3, message: "XanaScript LSP iniciado" } });
+      break;
+
+    case "textDocument/didOpen":
+    case "textDocument/didChange": {
+      const uri = params.textDocument?.uri || params.textDocument?.uri;
+      const text = params.textDocument?.text || params.contentChanges?.[0]?.text;
+      if (uri && text) {
+        documents.set(uri, text);
+        validateDocument(uri, text);
+      }
+      break;
+    }
+
+    case "textDocument/didClose": {
+      const uri = params.textDocument?.uri;
+      if (uri) documents.delete(uri);
+      break;
+    }
+
+    case "textDocument/completion": {
+      const uri = params.textDocument?.uri;
+      const line = params.position?.line || 0;
+      const col = params.position?.character || 0;
+      const text = documents.get(uri);
+      if (text) {
+        const items = getCompletions(text, line, col);
+        sendMessage({ jsonrpc: "2.0", id, result: { isIncomplete: false, items } });
+      }
+      break;
+    }
+
+    case "textDocument/hover": {
+      const uri = params.textDocument?.uri;
+      const line = params.position?.line || 0;
+      const col = params.position?.character || 0;
+      const text = documents.get(uri);
+      if (text) {
+        const hover = getHover(text, line, col);
+        sendMessage({ jsonrpc: "2.0", id, result: hover });
+      }
+      break;
+    }
+
+    case "textDocument/definition": {
+      const uri = params.textDocument?.uri;
+      const line = params.position?.line || 0;
+      const col = params.position?.character || 0;
+      const text = documents.get(uri);
+      if (text) {
+        const def = getDefinition(text, line, col);
+        sendMessage({ jsonrpc: "2.0", id, result: def });
+      }
+      break;
+    }
+
+    case "shutdown":
+      sendMessage({ jsonrpc: "2.0", id, result: null });
+      break;
+
+    case "exit":
+      process.exit(0);
+      break;
+  }
+}
+
+function validateDocument(uri, text) {
+  setSource(text, uri);
+  const diagnostics = [];
+
+  try {
+    const tokens = lex(text);
+    parse(tokens);
+  } catch (e) {
+    const loc = e.loc || { line: 1, column: 1 };
+    diagnostics.push({
+      range: {
+        start: { line: loc.line - 1, character: (loc.column || 1) - 1 },
+        end: { line: loc.line - 1, character: (loc.column || 1) + 10 },
+      },
+      severity: 1,
+      message: e.message,
+      source: "xanascript",
+    });
+  }
+
+  sendMessage({
+    jsonrpc: "2.0",
+    method: "textDocument/publishDiagnostics",
+    params: { uri, diagnostics },
+  });
+}
+
+function getCompletions(text, line, col) {
+  const items = [];
+
+  for (const kw of KEYWORDS) {
+    items.push({
+      label: kw,
+      kind: 14,
+      detail: "keyword",
+      insertText: kw,
+    });
+  }
+
+  for (const fn of BUILTIN_FUNCTIONS) {
+    items.push({
+      label: fn.name,
+      kind: 3,
+      detail: `fn(${fn.params})`,
+      documentation: fn.doc,
+      insertText: fn.name + "($1)",
+      insertTextFormat: 2,
+    });
+  }
+
+  const words = text.split(/[^a-zA-Z0-9_]/).filter(Boolean);
+  const seen = new Set();
+  for (const w of words) {
+    if (!seen.has(w) && w.length > 1 && !KEYWORDS.includes(w.toUpperCase())) {
+      seen.add(w);
+      items.push({
+        label: w,
+        kind: 6,
+        insertText: w,
+      });
+    }
+  }
+
+  return items;
+}
+
+function getHover(text, line, col) {
+  const word = getWordAt(text, line, col);
+  if (!word) return null;
+
+  const fn = BUILTIN_FUNCTIONS.find(f => f.name === word);
+  if (fn) {
+    return {
+      contents: {
+        kind: "markdown",
+        value: `\`\`\`xs\n${fn.name}(${fn.params})\n\`\`\`\n\n${fn.doc}`,
+      },
+    };
+  }
+
+  if (KEYWORDS.includes(word.toUpperCase())) {
+    return {
+      contents: {
+        kind: "markdown",
+        value: `\`\`\`xs\n${word}\n\`\`\`\n\nPalavra-chave XanaScript`,
+      },
+    };
+  }
+
+  return null;
+}
+
+function getDefinition(text, line, col) {
+  const word = getWordAt(text, line, col);
+  if (!word) return null;
+
+  const patterns = [
+    new RegExp(`CHAMA\\s+ESSE\\s+CARA\\s+${word}\\b`),
+    new RegExp(`CRIA\\s+${word}\\b`),
+    new RegExp(`CLASSE\\s+${word}\\b`),
+    new RegExp(`TAREFA\\s+${word}\\b`),
+  ];
+
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    for (const pat of patterns) {
+      const match = lines[i].match(pat);
+      if (match) {
+        const colIdx = match.index + match[0].indexOf(word);
+        return {
+          uri: "",
+          range: {
+            start: { line: i, character: colIdx },
+            end: { line: i, character: colIdx + word.length },
+          },
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+function getWordAt(text, line, col) {
+  const lines = text.split("\n");
+  if (line >= lines.length) return null;
+  const lineText = lines[line];
+  if (col >= lineText.length) return null;
+
+  let start = col;
+  let end = col;
+  while (start > 0 && /[a-zA-Z0-9_]/.test(lineText[start - 1])) start--;
+  while (end < lineText.length && /[a-zA-Z0-9_]/.test(lineText[end])) end++;
+
+  return start < end ? lineText.slice(start, end) : null;
+}
+
+export function startLSP() {
+  startLSPServer().catch(console.error);
+}

package/src/macros.js

@@ -0,0 +1,132 @@
+import { lex } from "./lexer.js";
+import { parse } from "./parser.js";
+import * as A from "./ast.js";
+
+export function expandMacros(node, macros) {
+  if (!node || typeof node !== "object") return node;
+  if (!macros || macros.size === 0) return node;
+
+  switch (node.type) {
+    case "Program": {
+
+      const collected = new Map();
+      for (const stmt of node.body) {
+        if (stmt.type === "MacroDecl") {
+          collected.set(stmt.name, stmt);
+        }
+      }
+
+      return expandInNode({ ...node, body: node.body.map(stmt => {
+        if (stmt.type === "MacroDecl") return null;
+        return expandInNode(stmt, collected);
+      }).filter(Boolean) }, collected);
+    }
+
+    case "Block": {
+      return { ...node, body: node.body.map(s => expandInNode(s, macros)).filter(Boolean) };
+    }
+
+    case "VarDecl": {
+      return { ...node, init: expandInNode(node.init, macros) };
+    }
+
+    case "Call": {
+
+      if (node.callee.type === "Ident") {
+        const macro = macros.get(node.callee.name);
+        if (macro) {
+          return expandMacroCall(macro, node.args, macros);
+        }
+      }
+      return { ...node, callee: expandInNode(node.callee, macros), args: node.args.map(a => expandInNode(a, macros)) };
+    }
+
+    case "Binary":
+      return { ...node, left: expandInNode(node.left, macros), right: expandInNode(node.right, macros) };
+
+    case "Unary":
+      return { ...node, arg: expandInNode(node.arg, macros) };
+
+    case "Assign":
+      return { ...node, right: expandInNode(node.right, macros) };
+
+    case "IfStmt":
+      return { ...node, test: expandInNode(node.test, macros), cons: expandInNode(node.cons, macros), alt: node.alt ? expandInNode(node.alt, macros) : null };
+
+    case "ForStmt":
+      return { ...node, init: node.init ? expandInNode(node.init, macros) : null, test: expandInNode(node.test, macros), update: node.update ? expandInNode(node.update, macros) : null, body: expandInNode(node.body, macros) };
+
+    case "WhileStmt":
+      return { ...node, test: expandInNode(node.test, macros), body: expandInNode(node.body, macros) };
+
+    case "FunctionDecl":
+      return { ...node, body: expandInNode(node.body, macros) };
+
+    case "ReturnStmt":
+      return { ...node, arg: node.arg ? expandInNode(node.arg, macros) : null };
+
+    case "Ternary":
+      return { ...node, test: expandInNode(node.test, macros), cons: expandInNode(node.cons, macros), alt: expandInNode(node.alt, macros) };
+
+    case "ArrayExpr":
+      return { ...node, items: node.items.map(i => expandInNode(i, macros)) };
+
+    case "ObjectExpr":
+      return { ...node, props: node.props.map(p => ({ ...p, value: expandInNode(p.value, macros) })) };
+
+    case "Member":
+      return { ...node, obj: expandInNode(node.obj, macros) };
+
+    case "IndexExpr":
+      return { ...node, obj: expandInNode(node.obj, macros), index: expandInNode(node.index, macros) };
+
+    default:
+      return node;
+  }
+}
+
+function expandInNode(node, macros) {
+  if (!node || typeof node !== "object") return node;
+  return expandMacros(node, macros);
+}
+
+function expandMacroCall(macro, args, macros) {
+  const paramScope = {};
+  macro.params.forEach((p, i) => {
+    paramScope[p] = args[i] || A.Nil();
+  });
+
+  let expandedBody = replaceIdents(macro.body, paramScope);
+
+  if (expandedBody.type === "Block" && expandedBody.body?.length === 1) {
+    expandedBody = expandedBody.body[0];
+  }
+
+  return expandMacros(expandedBody, macros);
+}
+
+function replaceIdents(node, scope) {
+  if (!node || typeof node !== "object") return node;
+
+  if (node.type === "Ident") {
+    if (scope[node.name] !== undefined) {
+      return scope[node.name];
+    }
+    return node;
+  }
+
+  if (Array.isArray(node.body)) {
+    return { ...node, body: node.body.map(s => replaceIdents(s, scope)) };
+  }
+
+  const result = { ...node };
+  for (const [key, val] of Object.entries(node)) {
+    if (key === "type" || key === "loc") continue;
+    if (Array.isArray(val)) {
+      result[key] = val.map(v => replaceIdents(v, scope));
+    } else if (typeof val === "object" && val !== null) {
+      result[key] = replaceIdents(val, scope);
+    }
+  }
+  return result;
+}

package/src/optimizer.js

@@ -0,0 +1,175 @@
+import { expandMacros } from "./macros.js";
+
+function collectMacros(node) {
+  const macros = new Map();
+  if (!node || node.type !== "Program") return macros;
+  for (const stmt of node.body) {
+    if (stmt.type === "MacroDecl") {
+      macros.set(stmt.name, stmt);
+    }
+  }
+  return macros;
+}
+
+export function optimize(node) {
+
+  const macros = collectMacros(node);
+
+  if (macros.size > 0) {
+    node = expandMacros(node, macros);
+  }
+
+  if (!node || typeof node !== "object") return node;
+
+  switch (node.type) {
+
+    case "Program": {
+      node.body = node.body.map(s => optimize(s)).filter(Boolean);
+      return node;
+    }
+
+    case "Block": {
+      node.body = node.body.map(s => optimize(s)).filter(Boolean);
+      return node;
+    }
+
+    case "VarDecl": {
+      if (node.init) node.init = optimize(node.init);
+      return node;
+    }
+
+    case "Assign": {
+      node.right = optimize(node.right);
+      return node;
+    }
+
+    case "IfStmt": {
+      node.test = optimize(node.test);
+      node.cons = optimize(node.cons);
+      if (node.alt) node.alt = optimize(node.alt);
+      if (node.test.type === "Bool") {
+        if (node.test.value === true) return node.cons;
+        if (node.test.value === false) return node.alt || { type: "Nil" };
+      }
+      return node;
+    }
+
+    case "ForStmt": {
+      if (node.init) node.init = optimize(node.init);
+      node.test = optimize(node.test);
+      if (node.update) node.update = optimize(node.update);
+      node.body = optimize(node.body);
+      return node;
+    }
+
+    case "WhileStmt": {
+      node.test = optimize(node.test);
+      node.body = optimize(node.body);
+      return node;
+    }
+
+    case "FunctionDecl": {
+      node.body = optimize(node.body);
+      return node;
+    }
+
+    case "ReturnStmt": {
+      if (node.arg) node.arg = optimize(node.arg);
+      return node;
+    }
+
+    case "Ternary": {
+      node.test = optimize(node.test);
+      node.cons = optimize(node.cons);
+      node.alt = optimize(node.alt);
+      if (node.test.type === "Bool") {
+        return node.test.value ? node.cons : node.alt;
+      }
+      return node;
+    }
+
+    case "Call": {
+      node.callee = optimize(node.callee);
+      node.args = node.args.map(a => optimize(a));
+      return node;
+    }
+
+    case "Unary": {
+      node.arg = optimize(node.arg);
+      if (node.arg.type === "Num" && node.op === "-") {
+        return { type: "Num", value: -node.arg.value };
+      }
+      if (node.arg.type === "Bool" && node.op === "!") {
+        return { type: "Bool", value: !node.arg.value };
+      }
+      return node;
+    }
+
+    case "Binary": {
+      node.left = optimize(node.left);
+      node.right = optimize(node.right);
+
+      const isBothNum = node.left.type === "Num" && node.right.type === "Num";
+      const isBothBool = node.left.type === "Bool" && node.right.type === "Bool";
+
+      if (isBothNum) {
+        switch (node.op) {
+          case "+": return { type: "Num", value: node.left.value + node.right.value };
+          case "-": return { type: "Num", value: node.left.value - node.right.value };
+          case "*": return { type: "Num", value: node.left.value * node.right.value };
+          case "/": return { type: "Num", value: node.left.value / node.right.value };
+          case "%": return { type: "Num", value: node.left.value % node.right.value };
+          case "==": return { type: "Bool", value: node.left.value === node.right.value };
+          case "!=": return { type: "Bool", value: node.left.value !== node.right.value };
+          case ">": return { type: "Bool", value: node.left.value > node.right.value };
+          case "<": return { type: "Bool", value: node.left.value < node.right.value };
+          case ">=": return { type: "Bool", value: node.left.value >= node.right.value };
+          case "<=": return { type: "Bool", value: node.left.value <= node.right.value };
+        }
+      }
+
+      if (isBothBool) {
+        switch (node.op) {
+          case "==": return { type: "Bool", value: node.left.value === node.right.value };
+          case "!=": return { type: "Bool", value: node.left.value !== node.right.value };
+          case "&&": return { type: "Bool", value: node.left.value && node.right.value };
+          case "||": return { type: "Bool", value: node.left.value || node.right.value };
+        }
+      }
+
+      if (node.op === "+" && node.right.type === "Num" && node.right.value === 0) return node.left;
+      if (node.op === "+" && node.left.type === "Num" && node.left.value === 0) return node.right;
+      if (node.op === "*" && node.right.type === "Num" && node.right.value === 1) return node.left;
+      if (node.op === "*" && node.left.type === "Num" && node.left.value === 1) return node.right;
+      if (node.op === "*" && (node.right.type === "Num" && node.right.value === 0)) return { type: "Num", value: 0 };
+      if (node.op === "*" && (node.left.type === "Num" && node.left.value === 0)) return { type: "Num", value: 0 };
+
+      return node;
+    }
+
+    case "Member":
+    case "IndexExpr": {
+      node.obj = optimize(node.obj);
+      if (node.index) node.index = optimize(node.index);
+      return node;
+    }
+
+    case "ArrayExpr": {
+      node.items = node.items.map(i => optimize(i));
+      return node;
+    }
+
+    case "ObjectExpr": {
+      node.props = node.props.map(p => ({ key: p.key, value: optimize(p.value) }));
+      return node;
+    }
+
+    case "TryCatchStmt": {
+      node.tryBlock = optimize(node.tryBlock);
+      node.catchBlock = optimize(node.catchBlock);
+      return node;
+    }
+
+    default: return node;
+  }
+}