@designliquido/delegua 1.26.1 → 1.26.2

package/tradutores/x64/lowering.js

@@ -0,0 +1,904 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoweringX64 = void 0;
+const construtos_1 = require("../../construtos");
+const declaracoes_1 = require("../../declaracoes");
+const tipos_x64_1 = require("./tipos-x64");
+const ir_1 = require("./ir");
+const OPERADORES_BINARIOS = new Set(['+', '-', '*', '/', '%', '<', '>', '<=', '>=', '==', '!=']);
+/**
+ * Percorre a AST (declarações e construtos) chamando `visitante` em pré-ordem.
+ * `visitante` retorna `false` para podar a recursão num nó (usado para não descer em
+ * corpos de função aninhada, que têm escopo próprio e não são suportados aqui).
+ */
+function percorrer(no, visitante) {
+    if (!no || typeof no !== 'object')
+        return;
+    if (Array.isArray(no)) {
+        for (const item of no)
+            percorrer(item, visitante);
+        return;
+    }
+    if (!visitante(no))
+        return;
+    const objeto = no;
+    const nome = objeto.constructor?.name;
+    switch (nome) {
+        case 'Bloco':
+            percorrer(objeto.declaracoes, visitante);
+            break;
+        case 'Se': {
+            const se = objeto;
+            percorrer(se.condicao, visitante);
+            percorrer(se.caminhoEntao, visitante);
+            if (se.caminhosSeSenao) {
+                for (const caminho of se.caminhosSeSenao) {
+                    percorrer(caminho.condicao, visitante);
+                    percorrer(caminho.caminho, visitante);
+                }
+            }
+            if (se.caminhoSenao)
+                percorrer(se.caminhoSenao, visitante);
+            break;
+        }
+        case 'Enquanto': {
+            const enquanto = objeto;
+            percorrer(enquanto.condicao, visitante);
+            percorrer(enquanto.corpo, visitante);
+            break;
+        }
+        case 'Para': {
+            const para = objeto;
+            if (para.inicializador)
+                percorrer(para.inicializador, visitante);
+            percorrer(para.condicao, visitante);
+            percorrer(para.incrementar, visitante);
+            percorrer(para.corpo, visitante);
+            break;
+        }
+        case 'ParaCada': {
+            const paraCada = objeto;
+            percorrer(paraCada.vetorOuDicionario, visitante);
+            percorrer(paraCada.corpo, visitante);
+            break;
+        }
+        case 'Fazer': {
+            const fazer = objeto;
+            percorrer(fazer.caminhoFazer, visitante);
+            percorrer(fazer.condicaoEnquanto, visitante);
+            break;
+        }
+        case 'Retorna':
+            if (objeto.valor)
+                percorrer(objeto.valor, visitante);
+            break;
+        case 'Expressao':
+            percorrer(objeto.expressao, visitante);
+            break;
+        case 'Var':
+            if (objeto.inicializador)
+                percorrer(objeto.inicializador, visitante);
+            break;
+        case 'Const':
+            percorrer(objeto.inicializador, visitante);
+            break;
+        case 'Escreva':
+            percorrer(objeto.argumentos, visitante);
+            break;
+        case 'Escolha': {
+            const escolha = objeto;
+            percorrer(escolha.identificadorOuLiteral, visitante);
+            for (const caminho of escolha.caminhos ?? []) {
+                percorrer(caminho.condicoes, visitante);
+                percorrer(caminho.declaracoes, visitante);
+            }
+            if (escolha.caminhoPadrao)
+                percorrer(escolha.caminhoPadrao.declaracoes, visitante);
+            break;
+        }
+        case 'Falhar':
+            if (objeto.explicacao)
+                percorrer(objeto.explicacao, visitante);
+            break;
+        case 'Variavel':
+        case 'Literal':
+        case 'Importar':
+        case 'Classe':
+        case 'Tente':
+        case 'FuncaoConstruto':
+        case 'FuncaoDeclaracao':
+            break;
+        case 'Binario': {
+            const binario = objeto;
+            percorrer(binario.esquerda, visitante);
+            percorrer(binario.direita, visitante);
+            break;
+        }
+        case 'Unario':
+            percorrer(objeto.operando, visitante);
+            break;
+        case 'Logico': {
+            const logico = objeto;
+            percorrer(logico.esquerda, visitante);
+            percorrer(logico.direita, visitante);
+            break;
+        }
+        case 'Vetor':
+            percorrer(objeto.elementos, visitante);
+            break;
+        case 'Chamada': {
+            const chamada = objeto;
+            percorrer(chamada.entidadeChamada, visitante);
+            percorrer(chamada.argumentos, visitante);
+            break;
+        }
+        case 'AcessoIndiceVariavel': {
+            const acesso = objeto;
+            percorrer(acesso.entidadeChamada, visitante);
+            percorrer(acesso.indice, visitante);
+            break;
+        }
+        case 'AtribuicaoPorIndice': {
+            const atribuicao = objeto;
+            percorrer(atribuicao.objeto, visitante);
+            percorrer(atribuicao.indice, visitante);
+            percorrer(atribuicao.valor, visitante);
+            break;
+        }
+        case 'Atribuir': {
+            const atribuir = objeto;
+            percorrer(atribuir.alvo, visitante);
+            if (atribuir.indice)
+                percorrer(atribuir.indice, visitante);
+            percorrer(atribuir.valor, visitante);
+            break;
+        }
+        case 'Agrupamento':
+            percorrer(objeto.expressao, visitante);
+            break;
+        case 'DefinirValor': {
+            const definirValor = objeto;
+            percorrer(definirValor.objeto, visitante);
+            percorrer(definirValor.valor, visitante);
+            break;
+        }
+        case 'AcessoMetodo':
+            percorrer(objeto.objeto, visitante);
+            break;
+        case 'TipoDe':
+            percorrer(objeto.valor, visitante);
+            break;
+        case 'Leia':
+            percorrer(objeto.argumentos, visitante);
+            break;
+        default:
+            break;
+    }
+}
+function coletarReferenciasEDeclaracoes(corpo) {
+    const referenciadas = new Set();
+    const declaradas = new Set();
+    percorrer(corpo, (no) => {
+        const objeto = no;
+        const nomeClasse = objeto.constructor?.name;
+        if (nomeClasse === 'Variavel') {
+            referenciadas.add(no.simbolo.lexema);
+        }
+        else if (nomeClasse === 'Var' || nomeClasse === 'Const') {
+            declaradas.add(no.simbolo.lexema);
+        }
+        if (nomeClasse === 'FuncaoConstruto' || nomeClasse === 'FuncaoDeclaracao')
+            return false;
+        return true;
+    });
+    return { referenciadas, declaradas };
+}
+function inferirTipoRetorno(corpo) {
+    let encontrado;
+    percorrer(corpo, (no) => {
+        const objeto = no;
+        const nomeClasse = objeto.constructor?.name;
+        if (nomeClasse === 'Retorna' && !encontrado) {
+            const retorna = no;
+            if (retorna.valor?.tipo)
+                encontrado = retorna.valor.tipo;
+        }
+        if (nomeClasse === 'FuncaoConstruto' || nomeClasse === 'FuncaoDeclaracao')
+            return false;
+        return true;
+    });
+    return encontrado;
+}
+/** Constrói o IR de uma única função (ou do "principal" implícito) mantendo o bloco atual. */
+class ConstrutorFuncao {
+    constructor(nome, ehImplicitaTopo, programa, assinaturas) {
+        this.programa = programa;
+        this.assinaturas = assinaturas;
+        this.encerrado = false;
+        this.contadorTemp = 0;
+        this.contadorBloco = 0;
+        this.locais = new Map();
+        this.funcao = (0, ir_1.novaFuncao)(nome, ehImplicitaTopo);
+        const entrada = (0, ir_1.novoBloco)('entrada');
+        this.funcao.blocos.set('entrada', entrada);
+        this.funcao.ordemBlocos.push('entrada');
+        this.funcao.blocoEntrada = 'entrada';
+        this.blocoAtualId = 'entrada';
+    }
+    declararLocalEscalar(nome, tipo) {
+        this.locais.set(nome, { classe: 'escalar', tipo });
+    }
+    declararLocalArray(nome, info) {
+        this.locais.set(nome, { classe: 'array', tipo: info.tipoElemento });
+        this.funcao.arranjosLocais.set(nome, info);
+    }
+    blocoAtual() {
+        return this.funcao.blocos.get(this.blocoAtualId);
+    }
+    emitir(instrucao) {
+        if (this.encerrado)
+            return;
+        this.blocoAtual().instrucoes.push(instrucao);
+    }
+    novoTemp() {
+        return `%t${this.contadorTemp++}`;
+    }
+    novoBlocoId() {
+        return `bloco_${this.contadorBloco++}`;
+    }
+    criarBloco() {
+        const id = this.novoBlocoId();
+        this.funcao.blocos.set(id, (0, ir_1.novoBloco)(id));
+        this.funcao.ordemBlocos.push(id);
+        return id;
+    }
+    irPara(id) {
+        this.blocoAtualId = id;
+        this.encerrado = false;
+    }
+    terminarCom(terminador) {
+        if (this.encerrado)
+            return;
+        this.blocoAtual().terminador = terminador;
+        this.encerrado = true;
+    }
+    finalizar() {
+        if (!this.encerrado) {
+            this.terminarCom({ op: 'retorno' });
+        }
+    }
+    resolverEscalar(nome) {
+        const local = this.locais.get(nome);
+        if (local)
+            return local;
+        if (this.programa.globaisEscalares.has(nome)) {
+            return { classe: 'escalar', tipo: this.programa.globaisEscalares.get(nome) };
+        }
+        if (this.programa.globaisArranjos.has(nome)) {
+            const info = this.programa.globaisArranjos.get(nome);
+            return { classe: 'array', tipo: info.tipoElemento };
+        }
+        return undefined;
+    }
+    resolverArranjoInfo(nome) {
+        const local = this.funcao.arranjosLocais.get(nome);
+        if (local)
+            return local;
+        const global = this.programa.globaisArranjos.get(nome);
+        if (global)
+            return global;
+        throw new Error(`Vetor '${nome}' não declarado.`);
+    }
+    ehLocalEscalar(nome) {
+        const local = this.locais.get(nome);
+        return !!local && local.classe === 'escalar';
+    }
+    lerEscalar(nome) {
+        const info = this.resolverEscalar(nome);
+        if (!info) {
+            throw new Error(`Variável '${nome}' não declarada, não é parâmetro/local desta função, nem uma ` +
+                `variável global (do escopo principal) referenciada por alguma função — o ` +
+                `tradutor para x64 não suporta capturar variáveis locais de outras funções.`);
+        }
+        if (info.classe === 'array') {
+            throw new Error(`'${nome}' é um vetor; use acesso por índice.`);
+        }
+        if (this.locais.has(nome)) {
+            return (0, ir_1.valorRegistrador)(nome);
+        }
+        const temp = this.novoTemp();
+        this.emitir({ op: 'carregarGlobal', dst: temp, rotulo: nome });
+        return (0, ir_1.valorRegistrador)(temp);
+    }
+    escreverEscalar(nome, valor) {
+        const info = this.resolverEscalar(nome);
+        if (!info) {
+            throw new Error(`Variável '${nome}' não declarada.`);
+        }
+        if (this.locais.has(nome)) {
+            this.emitir({ op: 'copia', dst: nome, src: valor });
+        }
+        else {
+            this.emitir({ op: 'armazenarGlobal', rotulo: nome, valor });
+        }
+    }
+    assinaturaDe(nomeFuncao) {
+        const assinatura = this.assinaturas.get(nomeFuncao);
+        if (!assinatura) {
+            throw new Error(`Função '${nomeFuncao}' não declarada — o tradutor para x64 não suporta chamadas indiretas.`);
+        }
+        return assinatura;
+    }
+    literalTexto(valor) {
+        for (const [rotulo, texto] of this.programa.literaisTexto) {
+            if (texto === valor)
+                return rotulo;
+        }
+        const rotulo = `str_${this.programa.literaisTexto.size}`;
+        this.programa.literaisTexto.set(rotulo, valor);
+        return rotulo;
+    }
+    // --- Declarações ---
+    lowerBloco(declaracoes) {
+        for (const declaracao of declaracoes)
+            this.lowerDeclaracao(declaracao);
+    }
+    lowerDeclaracao(declaracao) {
+        const nomeClasse = declaracao.constructor.name;
+        switch (nomeClasse) {
+            case 'Bloco':
+                this.lowerBloco(declaracao.declaracoes);
+                return;
+            case 'Expressao':
+                this.lowerConstruto(declaracao.expressao);
+                return;
+            case 'Var':
+                this.lowerVarOuConst(declaracao, false);
+                return;
+            case 'Const':
+                this.lowerVarOuConst(declaracao, true);
+                return;
+            case 'Escreva':
+                this.lowerEscreva(declaracao);
+                return;
+            case 'Se':
+                this.lowerSe(declaracao);
+                return;
+            case 'Enquanto':
+                this.lowerEnquanto(declaracao);
+                return;
+            case 'Para':
+                this.lowerPara(declaracao);
+                return;
+            case 'ParaCada':
+                this.lowerParaCada(declaracao);
+                return;
+            case 'Fazer':
+                this.lowerFazer(declaracao);
+                return;
+            case 'Escolha':
+                this.lowerEscolha(declaracao);
+                return;
+            case 'Retorna':
+                this.lowerRetorna(declaracao);
+                return;
+            case 'Importar':
+                return;
+            case 'Classe':
+                throw new Error('Classes não são suportadas pelo tradutor para x64.');
+            case 'Tente':
+                throw new Error('Tente/pegue não é suportado pelo tradutor para x64.');
+            case 'Falhar':
+                throw new Error('Falhar não é suportado pelo tradutor para x64.');
+            default:
+                throw new Error(`Declaração '${nomeClasse}' não suportada pelo tradutor para x64.`);
+        }
+    }
+    /**
+     * Uma `var`/`const` de topo referenciada por alguma função já foi pré-registrada como
+     * global (ver LoweringX64.lowerPrograma passo 1) — aqui só emitimos a inicialização
+     * apontando para ela, sem criar um slot local/SSA.
+     */
+    lowerVarOuConst(declaracao, ehConst) {
+        const nome = declaracao.simbolo.lexema;
+        const contexto = `${ehConst ? 'Constante' : 'Variável'} '${nome}'`;
+        const ehGlobalPromovida = this.programa.globaisEscalares.has(nome) || this.programa.globaisArranjos.has(nome);
+        if (declaracao.inicializador instanceof construtos_1.Vetor) {
+            const elementos = declaracao.inicializador.elementos;
+            let info;
+            if (ehGlobalPromovida) {
+                info = this.programa.globaisArranjos.get(nome);
+            }
+            else {
+                const tipoElemento = (0, tipos_x64_1.resolverTipoElementoVetor)(declaracao.tipo, contexto);
+                info = { id: nome, tamanho: elementos.length, tipoElemento };
+                this.declararLocalArray(nome, info);
+            }
+            elementos.forEach((elemento, indice) => {
+                const valor = this.lowerConstruto(elemento);
+                this.emitir({ op: 'indiceEscrever', arranjo: nome, indice: (0, ir_1.valorConstante)(indice), valor });
+            });
+            return;
+        }
+        if (!ehGlobalPromovida) {
+            const tipo = (0, tipos_x64_1.resolverTipoEscalar)(declaracao.tipo, contexto);
+            this.declararLocalEscalar(nome, tipo);
+        }
+        const valorInicial = declaracao.inicializador ? this.lowerConstruto(declaracao.inicializador) : (0, ir_1.valorConstante)(0);
+        this.escreverEscalar(nome, valorInicial);
+    }
+    lowerEscreva(declaracao) {
+        const argumento = declaracao.argumentos[0];
+        if (argumento instanceof construtos_1.Literal && argumento.tipo === 'texto') {
+            const rotulo = this.literalTexto(String(argumento.valor));
+            this.emitir({ op: 'imprimirTexto', rotulo });
+            return;
+        }
+        const valor = this.lowerConstruto(argumento);
+        this.emitir({ op: 'imprimirNumero', valor });
+    }
+    lowerCondicao(condicao) {
+        return this.lowerConstruto(condicao);
+    }
+    lowerSe(declaracao) {
+        const blocoFim = this.criarBloco();
+        const pares = [
+            { condicao: declaracao.condicao, caminho: declaracao.caminhoEntao },
+            ...(declaracao.caminhosSeSenao ?? []).map((c) => ({ condicao: c.condicao, caminho: c.caminho })),
+        ];
+        const lowerCadeia = (indice) => {
+            if (indice >= pares.length) {
+                if (declaracao.caminhoSenao)
+                    this.lowerDeclaracao(declaracao.caminhoSenao);
+                this.terminarCom({ op: 'salto', alvo: blocoFim });
+                return;
+            }
+            const condicaoValor = this.lowerCondicao(pares[indice].condicao);
+            const blocoEntao = this.criarBloco();
+            const blocoProximo = this.criarBloco();
+            this.terminarCom({ op: 'saltoCondicional', condicao: condicaoValor, verdadeiro: blocoEntao, falso: blocoProximo });
+            this.irPara(blocoEntao);
+            this.lowerDeclaracao(pares[indice].caminho);
+            this.terminarCom({ op: 'salto', alvo: blocoFim });
+            this.irPara(blocoProximo);
+            lowerCadeia(indice + 1);
+        };
+        lowerCadeia(0);
+        this.irPara(blocoFim);
+    }
+    lowerEnquanto(declaracao) {
+        const blocoCondicao = this.criarBloco();
+        const blocoCorpo = this.criarBloco();
+        const blocoFim = this.criarBloco();
+        this.terminarCom({ op: 'salto', alvo: blocoCondicao });
+        this.irPara(blocoCondicao);
+        const condicaoValor = this.lowerCondicao(declaracao.condicao);
+        this.terminarCom({ op: 'saltoCondicional', condicao: condicaoValor, verdadeiro: blocoCorpo, falso: blocoFim });
+        this.irPara(blocoCorpo);
+        this.lowerDeclaracao(declaracao.corpo);
+        this.terminarCom({ op: 'salto', alvo: blocoCondicao });
+        this.irPara(blocoFim);
+    }
+    lowerPara(declaracao) {
+        if (declaracao.inicializador) {
+            if (Array.isArray(declaracao.inicializador)) {
+                for (const decl of declaracao.inicializador)
+                    this.lowerDeclaracao(decl);
+            }
+            else {
+                this.lowerDeclaracao(declaracao.inicializador);
+            }
+        }
+        const blocoCondicao = this.criarBloco();
+        const blocoCorpo = this.criarBloco();
+        const blocoIncremento = this.criarBloco();
+        const blocoFim = this.criarBloco();
+        this.terminarCom({ op: 'salto', alvo: blocoCondicao });
+        this.irPara(blocoCondicao);
+        const condicaoValor = declaracao.condicao ? this.lowerCondicao(declaracao.condicao) : (0, ir_1.valorConstante)(true);
+        this.terminarCom({ op: 'saltoCondicional', condicao: condicaoValor, verdadeiro: blocoCorpo, falso: blocoFim });
+        this.irPara(blocoCorpo);
+        this.lowerDeclaracao(declaracao.corpo);
+        this.terminarCom({ op: 'salto', alvo: blocoIncremento });
+        this.irPara(blocoIncremento);
+        if (declaracao.incrementar)
+            this.lowerConstruto(declaracao.incrementar);
+        this.terminarCom({ op: 'salto', alvo: blocoCondicao });
+        this.irPara(blocoFim);
+    }
+    lowerParaCada(declaracao) {
+        if (!(declaracao.vetorOuDicionario instanceof construtos_1.Vetor) && !(declaracao.vetorOuDicionario instanceof construtos_1.Variavel)) {
+            throw new Error('para-cada só é suportado sobre um vetor literal ou uma variável de vetor de tamanho fixo.');
+        }
+        if (!(declaracao.variavelIteracao instanceof construtos_1.Variavel)) {
+            throw new Error('para-cada requer uma única variável de iteração (dupla/dicionário não suportado).');
+        }
+        const nomeVetor = declaracao.vetorOuDicionario instanceof construtos_1.Variavel
+            ? declaracao.vetorOuDicionario.simbolo.lexema
+            : undefined;
+        if (!nomeVetor) {
+            throw new Error('para-cada só é suportado sobre uma variável de vetor já declarada.');
+        }
+        const info = this.resolverArranjoInfo(nomeVetor);
+        const nomeIteracao = declaracao.variavelIteracao.simbolo.lexema;
+        this.declararLocalEscalar(nomeIteracao, info.tipoElemento);
+        const nomeIndice = `__indice_${nomeIteracao}__`;
+        this.declararLocalEscalar(nomeIndice, 'inteiro');
+        this.emitir({ op: 'const', dst: nomeIndice, valor: 0 });
+        const blocoCondicao = this.criarBloco();
+        const blocoCorpo = this.criarBloco();
+        const blocoIncremento = this.criarBloco();
+        const blocoFim = this.criarBloco();
+        this.terminarCom({ op: 'salto', alvo: blocoCondicao });
+        this.irPara(blocoCondicao);
+        const tempCmp = this.novoTemp();
+        this.emitir({
+            op: 'bin',
+            dst: tempCmp,
+            operador: '<',
+            esquerda: (0, ir_1.valorRegistrador)(nomeIndice),
+            direita: (0, ir_1.valorConstante)(info.tamanho),
+        });
+        this.terminarCom({
+            op: 'saltoCondicional',
+            condicao: (0, ir_1.valorRegistrador)(tempCmp),
+            verdadeiro: blocoCorpo,
+            falso: blocoFim,
+        });
+        this.irPara(blocoCorpo);
+        const tempElemento = this.novoTemp();
+        this.emitir({ op: 'indiceLer', dst: tempElemento, arranjo: nomeVetor, indice: (0, ir_1.valorRegistrador)(nomeIndice) });
+        this.emitir({ op: 'copia', dst: nomeIteracao, src: (0, ir_1.valorRegistrador)(tempElemento) });
+        this.lowerDeclaracao(declaracao.corpo);
+        this.terminarCom({ op: 'salto', alvo: blocoIncremento });
+        this.irPara(blocoIncremento);
+        const tempIndiceNovo = this.novoTemp();
+        this.emitir({
+            op: 'bin',
+            dst: tempIndiceNovo,
+            operador: '+',
+            esquerda: (0, ir_1.valorRegistrador)(nomeIndice),
+            direita: (0, ir_1.valorConstante)(1),
+        });
+        this.emitir({ op: 'copia', dst: nomeIndice, src: (0, ir_1.valorRegistrador)(tempIndiceNovo) });
+        this.terminarCom({ op: 'salto', alvo: blocoCondicao });
+        this.irPara(blocoFim);
+    }
+    lowerFazer(declaracao) {
+        const blocoCorpo = this.criarBloco();
+        const blocoFim = this.criarBloco();
+        this.terminarCom({ op: 'salto', alvo: blocoCorpo });
+        this.irPara(blocoCorpo);
+        this.lowerDeclaracao(declaracao.caminhoFazer);
+        const condicaoValor = this.lowerCondicao(declaracao.condicaoEnquanto);
+        this.terminarCom({ op: 'saltoCondicional', condicao: condicaoValor, verdadeiro: blocoCorpo, falso: blocoFim });
+        this.irPara(blocoFim);
+    }
+    lowerEscolha(declaracao) {
+        const valorEscolha = this.lowerConstruto(declaracao.identificadorOuLiteral);
+        const blocoFim = this.criarBloco();
+        const lowerCaminhos = (indice) => {
+            if (indice >= declaracao.caminhos.length) {
+                if (declaracao.caminhoPadrao) {
+                    for (const decl of declaracao.caminhoPadrao.declaracoes)
+                        this.lowerDeclaracao(decl);
+                }
+                this.terminarCom({ op: 'salto', alvo: blocoFim });
+                return;
+            }
+            const caminho = declaracao.caminhos[indice];
+            const condicaoCaso = caminho.condicoes[0];
+            const valorCaso = this.lowerConstruto(condicaoCaso);
+            const tempCmp = this.novoTemp();
+            this.emitir({ op: 'bin', dst: tempCmp, operador: '==', esquerda: valorEscolha, direita: valorCaso });
+            const blocoCorpo = this.criarBloco();
+            const blocoProximo = this.criarBloco();
+            this.terminarCom({
+                op: 'saltoCondicional',
+                condicao: (0, ir_1.valorRegistrador)(tempCmp),
+                verdadeiro: blocoCorpo,
+                falso: blocoProximo,
+            });
+            this.irPara(blocoCorpo);
+            for (const decl of caminho.declaracoes)
+                this.lowerDeclaracao(decl);
+            this.terminarCom({ op: 'salto', alvo: blocoFim });
+            this.irPara(blocoProximo);
+            lowerCaminhos(indice + 1);
+        };
+        lowerCaminhos(0);
+        this.irPara(blocoFim);
+    }
+    lowerRetorna(declaracao) {
+        if (declaracao.valor) {
+            const valor = this.lowerConstruto(declaracao.valor);
+            this.terminarCom({ op: 'retorno', valor });
+        }
+        else {
+            this.terminarCom({ op: 'retorno' });
+        }
+    }
+    // --- Construtos (expressões) ---
+    lowerConstruto(construto) {
+        const nomeClasse = construto.constructor.name;
+        switch (nomeClasse) {
+            case 'Literal':
+                return this.lowerLiteral(construto);
+            case 'Variavel':
+                return this.lerEscalar(construto.simbolo.lexema);
+            case 'Agrupamento':
+                return this.lowerConstruto(construto.expressao);
+            case 'Binario':
+                return this.lowerBinario(construto);
+            case 'Logico':
+                return this.lowerLogico(construto);
+            case 'Unario':
+                return this.lowerUnario(construto);
+            case 'Atribuir':
+                return this.lowerAtribuir(construto);
+            case 'AtribuicaoPorIndice':
+                return this.lowerAtribuicaoPorIndice(construto);
+            case 'AcessoIndiceVariavel':
+                return this.lowerAcessoIndice(construto);
+            case 'Chamada':
+                return this.lowerChamada(construto);
+            case 'Leia':
+                throw new Error("'leia' não é suportado pelo tradutor para x64.");
+            case 'DefinirValor':
+            case 'AcessoMetodo':
+            case 'TipoDe':
+                throw new Error(`'${nomeClasse}' requer modelo de objetos e não é suportado pelo tradutor para x64.`);
+            default:
+                throw new Error(`Expressão '${nomeClasse}' não suportada pelo tradutor para x64.`);
+        }
+    }
+    lowerLiteral(construto) {
+        if (typeof construto.valor === 'number')
+            return (0, ir_1.valorConstante)(construto.valor);
+        if (typeof construto.valor === 'boolean')
+            return (0, ir_1.valorConstante)(construto.valor ? 1 : 0);
+        if (typeof construto.valor === 'bigint')
+            return (0, ir_1.valorConstante)(construto.valor);
+        if (typeof construto.valor === 'string') {
+            const rotulo = this.literalTexto(construto.valor);
+            const temp = this.novoTemp();
+            this.emitir({ op: 'enderecoRotulo', dst: temp, rotulo });
+            return (0, ir_1.valorRegistrador)(temp);
+        }
+        throw new Error(`Literal do tipo '${construto.tipo}' não suportado pelo tradutor para x64.`);
+    }
+    lowerBinario(construto) {
+        if (construto.esquerda.tipo === 'texto' || construto.direita.tipo === 'texto') {
+            throw new Error('Operações aritméticas sobre texto não são suportadas pelo tradutor para x64.');
+        }
+        const esquerda = this.lowerConstruto(construto.esquerda);
+        const direita = this.lowerConstruto(construto.direita);
+        const operador = construto.operador.lexema;
+        if (!OPERADORES_BINARIOS.has(operador)) {
+            throw new Error(`Operador '${operador}' não suportado pelo tradutor para x64.`);
+        }
+        const dst = this.novoTemp();
+        this.emitir({ op: 'bin', dst, operador: operador, esquerda, direita });
+        return (0, ir_1.valorRegistrador)(dst);
+    }
+    lowerLogico(construto) {
+        const ehE = construto.operador.lexema === 'e' || construto.operador.lexema === '&&';
+        const ehOu = construto.operador.lexema === 'ou' || construto.operador.lexema === '||';
+        if (!ehE && !ehOu) {
+            throw new Error(`Operador lógico '${construto.operador.lexema}' não suportado pelo tradutor para x64.`);
+        }
+        const nomeResultado = `%logico${this.novoTemp()}`;
+        this.declararLocalEscalar(nomeResultado, 'logico');
+        const blocoAvaliaDireita = this.criarBloco();
+        const blocoFim = this.criarBloco();
+        const esquerda = this.lowerConstruto(construto.esquerda);
+        this.emitir({ op: 'copia', dst: nomeResultado, src: esquerda });
+        if (ehE) {
+            const blocoCurto = this.criarBloco();
+            this.terminarCom({
+                op: 'saltoCondicional',
+                condicao: esquerda,
+                verdadeiro: blocoAvaliaDireita,
+                falso: blocoCurto,
+            });
+            this.irPara(blocoCurto);
+            this.terminarCom({ op: 'salto', alvo: blocoFim });
+        }
+        else {
+            const blocoCurto = this.criarBloco();
+            this.terminarCom({
+                op: 'saltoCondicional',
+                condicao: esquerda,
+                verdadeiro: blocoCurto,
+                falso: blocoAvaliaDireita,
+            });
+            this.irPara(blocoCurto);
+            this.terminarCom({ op: 'salto', alvo: blocoFim });
+        }
+        this.irPara(blocoAvaliaDireita);
+        const direita = this.lowerConstruto(construto.direita);
+        this.emitir({ op: 'copia', dst: nomeResultado, src: direita });
+        this.terminarCom({ op: 'salto', alvo: blocoFim });
+        this.irPara(blocoFim);
+        let resultado = (0, ir_1.valorRegistrador)(nomeResultado);
+        if (construto.negado) {
+            const negadoTemp = this.novoTemp();
+            this.emitir({ op: 'nao', dst: negadoTemp, src: resultado });
+            resultado = (0, ir_1.valorRegistrador)(negadoTemp);
+        }
+        return resultado;
+    }
+    lowerUnario(construto) {
+        const operador = construto.operador.lexema;
+        if (operador === '++' || operador === '--') {
+            if (!(construto.operando instanceof construtos_1.Variavel)) {
+                throw new Error('++/-- só são suportados sobre uma variável simples.');
+            }
+            const nome = construto.operando.simbolo.lexema;
+            const valorAntigo = this.lerEscalar(nome);
+            const novoValor = this.novoTemp();
+            this.emitir({
+                op: 'bin',
+                dst: novoValor,
+                operador: operador === '++' ? '+' : '-',
+                esquerda: valorAntigo,
+                direita: (0, ir_1.valorConstante)(1),
+            });
+            this.escreverEscalar(nome, (0, ir_1.valorRegistrador)(novoValor));
+            return construto.incidenciaOperador === 'DEPOIS' ? valorAntigo : (0, ir_1.valorRegistrador)(novoValor);
+        }
+        const operando = this.lowerConstruto(construto.operando);
+        const dst = this.novoTemp();
+        if (operador === '-') {
+            this.emitir({ op: 'neg', dst, src: operando });
+        }
+        else if (operador === '!' || operador === 'nao') {
+            this.emitir({ op: 'nao', dst, src: operando });
+        }
+        else {
+            throw new Error(`Operador unário '${operador}' não suportado pelo tradutor para x64.`);
+        }
+        return (0, ir_1.valorRegistrador)(dst);
+    }
+    lowerAtribuir(construto) {
+        if (construto.indice) {
+            throw new Error('Atribuição indexada deve usar AtribuicaoPorIndice.');
+        }
+        if (!(construto.alvo instanceof construtos_1.Variavel)) {
+            throw new Error('Atribuição só é suportada sobre uma variável simples.');
+        }
+        const nome = construto.alvo.simbolo.lexema;
+        let valor = this.lowerConstruto(construto.valor);
+        if (construto.simboloOperador) {
+            const operadorComposto = construto.simboloOperador.lexema.replace('=', '');
+            const atual = this.lerEscalar(nome);
+            const dst = this.novoTemp();
+            this.emitir({ op: 'bin', dst, operador: operadorComposto, esquerda: atual, direita: valor });
+            valor = (0, ir_1.valorRegistrador)(dst);
+        }
+        this.escreverEscalar(nome, valor);
+        return valor;
+    }
+    lowerAtribuicaoPorIndice(construto) {
+        if (!(construto.objeto instanceof construtos_1.Variavel)) {
+            throw new Error('Atribuição por índice só é suportada sobre uma variável de vetor.');
+        }
+        const nomeVetor = construto.objeto.simbolo.lexema;
+        this.resolverArranjoInfo(nomeVetor);
+        const indice = this.lowerConstruto(construto.indice);
+        const valor = this.lowerConstruto(construto.valor);
+        this.emitir({ op: 'indiceEscrever', arranjo: nomeVetor, indice, valor });
+        return valor;
+    }
+    lowerAcessoIndice(construto) {
+        if (!(construto.entidadeChamada instanceof construtos_1.Variavel)) {
+            throw new Error('Acesso por índice só é suportado sobre uma variável de vetor.');
+        }
+        const nomeVetor = construto.entidadeChamada.simbolo.lexema;
+        this.resolverArranjoInfo(nomeVetor);
+        const indice = this.lowerConstruto(construto.indice);
+        const dst = this.novoTemp();
+        this.emitir({ op: 'indiceLer', dst, arranjo: nomeVetor, indice });
+        return (0, ir_1.valorRegistrador)(dst);
+    }
+    lowerChamada(construto) {
+        if (!(construto.entidadeChamada instanceof construtos_1.Variavel)) {
+            throw new Error('Só são suportadas chamadas diretas a funções declaradas por nome.');
+        }
+        const nomeFuncao = construto.entidadeChamada.simbolo.lexema;
+        const assinatura = this.assinaturaDe(nomeFuncao);
+        if (construto.argumentos.length !== assinatura.parametros.length) {
+            throw new Error(`Função '${nomeFuncao}' espera ${assinatura.parametros.length} argumento(s), recebeu ${construto.argumentos.length}.`);
+        }
+        const argumentos = construto.argumentos.map((argumento) => this.lowerConstruto(argumento));
+        const dst = assinatura.tipoRetorno === 'vazio' ? null : this.novoTemp();
+        this.emitir({ op: 'chamada', dst, rotulo: nomeFuncao, argumentos });
+        return dst ? (0, ir_1.valorRegistrador)(dst) : (0, ir_1.valorConstante)(0);
+    }
+}
+/** Só variáveis/constantes declaradas diretamente no nível principal do programa podem virar globais. */
+function coletarDeclaracoesDeTopo(declaracoes) {
+    const resultado = [];
+    for (const declaracao of declaracoes) {
+        if (declaracao instanceof declaracoes_1.Var || declaracao instanceof declaracoes_1.Const)
+            resultado.push(declaracao);
+    }
+    return resultado;
+}
+class LoweringX64 {
+    lowerPrograma(declaracoes) {
+        const programa = {
+            funcoes: [],
+            globaisEscalares: new Map(),
+            globaisArranjos: new Map(),
+            literaisTexto: new Map(),
+        };
+        const declaracoesFuncao = declaracoes.filter((declaracao) => declaracao instanceof declaracoes_1.FuncaoDeclaracao);
+        const demais = declaracoes.filter((declaracao) => !(declaracao instanceof declaracoes_1.FuncaoDeclaracao));
+        // 1) Variáveis/constantes top-level referenciadas por alguma função viram globais.
+        const nomesTopo = coletarDeclaracoesDeTopo(demais);
+        const referenciadasPorFuncoes = new Set();
+        for (const decl of declaracoesFuncao) {
+            const { referenciadas } = coletarReferenciasEDeclaracoes(decl.funcao.corpo);
+            const nomesDeParametro = new Set(decl.funcao.parametros.map((p) => p.nome.lexema));
+            for (const nome of referenciadas) {
+                if (!nomesDeParametro.has(nome))
+                    referenciadasPorFuncoes.add(nome);
+            }
+        }
+        for (const decl of nomesTopo) {
+            const nome = decl.simbolo.lexema;
+            if (!referenciadasPorFuncoes.has(nome))
+                continue;
+            const contexto = `${decl instanceof declaracoes_1.Const ? 'Constante' : 'Variável'} global '${nome}'`;
+            if (decl.inicializador instanceof construtos_1.Vetor) {
+                const tipoElemento = (0, tipos_x64_1.resolverTipoElementoVetor)(decl.tipo, contexto);
+                programa.globaisArranjos.set(nome, {
+                    id: nome,
+                    tamanho: decl.inicializador.elementos.length,
+                    tipoElemento,
+                });
+            }
+            else {
+                programa.globaisEscalares.set(nome, (0, tipos_x64_1.resolverTipoEscalar)(decl.tipo, contexto));
+            }
+        }
+        // 2) Assinaturas de todas as funções antes de traduzir qualquer corpo (permite chamadas para frente).
+        const assinaturas = new Map();
+        for (const decl of declaracoesFuncao) {
+            const nomeFuncao = decl.simbolo.lexema;
+            const parametros = decl.funcao.parametros.map((parametro) => (0, tipos_x64_1.resolverTipoEscalar)(parametro.tipoDado, `Parâmetro '${parametro.nome.lexema}' da função '${nomeFuncao}'`));
+            const tipoRetornoTexto = decl.funcao.tipoExplicito ? decl.funcao.tipo : inferirTipoRetorno(decl.funcao.corpo);
+            const tipoRetorno = tipoRetornoTexto ? (0, tipos_x64_1.resolverTipoEscalar)(tipoRetornoTexto, `Retorno da função '${nomeFuncao}'`) : 'vazio';
+            assinaturas.set(nomeFuncao, { parametros, tipoRetorno });
+        }
+        // 3) Traduz cada função declarada.
+        for (const decl of declaracoesFuncao) {
+            programa.funcoes.push(this.lowerFuncaoDeclarada(decl, programa, assinaturas));
+        }
+        // 4) Traduz o programa principal (tudo que não é declaração de função).
+        const construtor = new ConstrutorFuncao('principal', true, programa, assinaturas);
+        construtor.lowerBloco(demais);
+        construtor.finalizar();
+        programa.funcoes.push(construtor.funcao);
+        return programa;
+    }
+    lowerFuncaoDeclarada(decl, programa, assinaturas) {
+        const nomeFuncao = decl.simbolo.lexema;
+        const assinatura = assinaturas.get(nomeFuncao);
+        const construtor = new ConstrutorFuncao(nomeFuncao, false, programa, assinaturas);
+        construtor.funcao.tipoRetorno = assinatura.tipoRetorno;
+        decl.funcao.parametros.forEach((parametro, indice) => {
+            const tipo = assinatura.parametros[indice];
+            const nome = parametro.nome.lexema;
+            construtor.declararLocalEscalar(nome, tipo);
+            construtor.funcao.parametros.push({ nome, registrador: nome, tipo });
+            construtor.emitir({ op: 'copia', dst: nome, src: (0, ir_1.valorArgumentoFisico)(indice) });
+        });
+        construtor.lowerBloco(decl.funcao.corpo);
+        construtor.finalizar();
+        return construtor.funcao;
+    }
+}
+exports.LoweringX64 = LoweringX64;
+//# sourceMappingURL=lowering.js.map