@yakuzaa/jade-compiler 0.1.0

package/dist/codegen/ir_generator.js

@@ -0,0 +1,691 @@
+export class IRGenerator {
+    module;
+    currentFunction = null;
+    currentBlock = null;
+    tempCounter = 0;
+    blockCounter = 0;
+    constructor(moduleName) {
+        this.module = {
+            name: moduleName,
+            typeDefinitions: [],
+            globals: [],
+            functions: []
+        };
+    }
+    generate(program) {
+        // Passo 1: registrar todos os tipos (entidades/classes)
+        for (const declaracao of program.declaracoes) {
+            if (declaracao.kind === 'Entidade') {
+                this.generateEntidade(declaracao);
+            }
+            else if (declaracao.kind === 'Classe') {
+                this.generateClasse(declaracao);
+            }
+        }
+        // Passo 2: gerar funções
+        for (const declaracao of program.declaracoes) {
+            if (declaracao.kind === 'Funcao') {
+                this.generateFuncao(declaracao);
+            }
+            else if (declaracao.kind === 'Servico') {
+                this.generateServico(declaracao);
+            }
+            else if (declaracao.kind === 'Tela') {
+                // Telas são tratadas pelo UIEngine em runtime — sem geração de IR
+            }
+        }
+        return this.module;
+    }
+    // ── Geradores de declaração ──────────────────────────────
+    generateEntidade(node) {
+        const fields = node.campos.map(campo => ({
+            name: campo.nome,
+            type: this.jadeTypeToIR(campo.tipo)
+        }));
+        this.module.typeDefinitions.push({
+            name: node.nome,
+            fields
+        });
+    }
+    generateClasse(node) {
+        const fields = node.campos.map(campo => ({
+            name: campo.nome,
+            type: this.jadeTypeToIR(campo.tipo)
+        }));
+        this.module.typeDefinitions.push({
+            name: node.nome,
+            fields
+        });
+    }
+    generateFuncao(node) {
+        const parameters = node.parametros.map(param => ({
+            name: '%' + param.nome,
+            type: this.jadeTypeToIR(param.tipo)
+        }));
+        const returnType = node.tipoRetorno ? this.jadeTypeToIR(node.tipoRetorno) : 'void';
+        const func = {
+            name: '@' + node.nome,
+            parameters,
+            returnType,
+            blocks: [],
+            locals: []
+        };
+        this.currentFunction = func;
+        this.module.functions.push(func);
+        // Criar bloco entry
+        const entryBlock = this.createBlock('entry');
+        this.switchToBlock(entryBlock);
+        // Gerar corpo da função
+        this.generateBloco(node.corpo);
+        // Garantir que o último bloco tem terminador
+        if (this.currentBlock && !this.currentBlock.terminator) {
+            this.setTerminator({ kind: 'Return' });
+        }
+        this.currentFunction = null;
+        this.currentBlock = null;
+    }
+    generateServico(node) {
+        // Gera cada método como função independente
+        // Nome: '@NomeServico_nomeFuncao'
+        for (const metodo of node.metodos) {
+            const parameters = metodo.parametros.map(param => ({
+                name: '%' + param.nome,
+                type: this.jadeTypeToIR(param.tipo)
+            }));
+            const returnType = metodo.tipoRetorno ? this.jadeTypeToIR(metodo.tipoRetorno) : 'void';
+            const func = {
+                name: '@' + node.nome + '_' + metodo.nome,
+                parameters,
+                returnType,
+                blocks: [],
+                locals: []
+            };
+            this.currentFunction = func;
+            this.module.functions.push(func);
+            // Criar bloco entry
+            const entryBlock = this.createBlock('entry');
+            this.switchToBlock(entryBlock);
+            // Gerar corpo do método
+            this.generateBloco(metodo.corpo);
+            // Garantir que o último bloco tem terminador
+            if (this.currentBlock && !this.currentBlock.terminator) {
+                this.setTerminator({ kind: 'Return' });
+            }
+            this.currentFunction = null;
+            this.currentBlock = null;
+        }
+    }
+    // ── Geradores de instrução ───────────────────────────────
+    generateBloco(node) {
+        for (const instrucao of node.instrucoes) {
+            this.generateInstrucao(instrucao);
+        }
+    }
+    generateInstrucao(node) {
+        switch (node.kind) {
+            case 'Variavel':
+                this.generateVariavel(node);
+                break;
+            case 'Atribuicao':
+                this.generateAtribuicao(node);
+                break;
+            case 'Condicional':
+                this.generateCondicional(node);
+                break;
+            case 'Enquanto':
+                this.generateEnquanto(node);
+                break;
+            case 'Para':
+                this.generatePara(node);
+                break;
+            case 'Retorno':
+                this.generateRetorno(node);
+                break;
+            case 'Erro':
+                this.generateErro(node);
+                break;
+            case 'EmissaoEvento':
+                this.generateEmissaoEvento(node);
+                break;
+            case 'ChamadaFuncao':
+                this.generateExpressao(node); // Chamada como instrução
+                break;
+        }
+    }
+    generateVariavel(node) {
+        const type = node.tipo ? this.jadeTypeToIR(node.tipo) : 'void';
+        if (node.inicializador) {
+            const value = this.generateExpressao(node.inicializador);
+            this.emit({
+                kind: 'Store',
+                target: '%' + node.nome,
+                value,
+                type
+            });
+        }
+        else {
+            // Se não tem inicializador: emite Store com valor zero do tipo
+            const zeroValue = {
+                kind: 'Constant',
+                type,
+                value: type === 'i1' ? false : type === 'f64' ? 0.0 : 0
+            };
+            this.emit({
+                kind: 'Store',
+                target: '%' + node.nome,
+                value: zeroValue,
+                type
+            });
+        }
+    }
+    generateAtribuicao(node) {
+        const value = this.generateExpressao(node.valor);
+        if (typeof node.alvo === 'string') {
+            // Se alvo é string: Store simples
+            this.emit({
+                kind: 'Store',
+                target: '%' + node.alvo,
+                value,
+                type: 'void' // Tipo será inferido do valor
+            });
+        }
+        else {
+            // Se alvo é AcessoMembro: SetField
+            const objeto = this.generateExpressao(node.alvo.objeto);
+            this.emit({
+                kind: 'SetField',
+                object: objeto,
+                field: node.alvo.membro,
+                value,
+                type: 'void'
+            });
+        }
+    }
+    generateCondicional(node) {
+        // Cria blocos: 'then_N', 'else_N', 'merge_N'
+        const thenBlock = this.createBlock(this.newBlockLabel('then'));
+        const elseBlock = this.createBlock(this.newBlockLabel('else'));
+        const mergeBlock = this.createBlock(this.newBlockLabel('merge'));
+        // Gera condição → CondBranch
+        const condition = this.generateExpressao(node.condicao);
+        this.setTerminator({
+            kind: 'CondBranch',
+            condition,
+            trueBlock: thenBlock.label,
+            falseBlock: node.senao ? elseBlock.label : mergeBlock.label
+        });
+        // Gera corpo then → Branch para merge
+        this.switchToBlock(thenBlock);
+        this.generateBloco(node.entao);
+        if (this.currentBlock && !this.currentBlock.terminator) {
+            this.setTerminator({ kind: 'Branch', target: mergeBlock.label });
+        }
+        // Gera corpo else (se houver) → Branch para merge
+        if (node.senao) {
+            this.switchToBlock(elseBlock);
+            this.generateBloco(node.senao);
+            if (this.currentBlock && !this.currentBlock.terminator) {
+                this.setTerminator({ kind: 'Branch', target: mergeBlock.label });
+            }
+        }
+        // Continua no bloco merge
+        this.switchToBlock(mergeBlock);
+    }
+    generateEnquanto(node) {
+        // Cria blocos: 'loop_header_N', 'loop_body_N', 'loop_exit_N'
+        const headerBlock = this.createBlock(this.newBlockLabel('loop_header'));
+        const bodyBlock = this.createBlock(this.newBlockLabel('loop_body'));
+        const exitBlock = this.createBlock(this.newBlockLabel('loop_exit'));
+        // Branch para header
+        this.setTerminator({ kind: 'Branch', target: headerBlock.label });
+        // Header: avalia condição → CondBranch body/exit
+        this.switchToBlock(headerBlock);
+        const condition = this.generateExpressao(node.condicao);
+        this.setTerminator({
+            kind: 'CondBranch',
+            condition,
+            trueBlock: bodyBlock.label,
+            falseBlock: exitBlock.label
+        });
+        // Body: gera instruções → Branch para header
+        this.switchToBlock(bodyBlock);
+        this.generateBloco(node.corpo);
+        if (this.currentBlock && !this.currentBlock.terminator) {
+            this.setTerminator({ kind: 'Branch', target: headerBlock.label });
+        }
+        // Continua no exit
+        this.switchToBlock(exitBlock);
+    }
+    generatePara(node) {
+        // 1. Obter a lista e seu tamanho
+        const lista = this.generateExpressao(node.iteravel);
+        const lenVar = this.newTemp();
+        this.emit({
+            kind: 'Call',
+            result: lenVar,
+            callee: '@jade_lista_tamanho',
+            args: [lista],
+            returnType: 'i32'
+        });
+        // 2. Inicializar contador %i = 0
+        const iVar = this.newTemp();
+        this.emit({
+            kind: 'Store',
+            target: iVar,
+            value: { kind: 'Constant', type: 'i32', value: 0 },
+            type: 'i32'
+        });
+        // 3. Criar blocos
+        const headerBlock = this.createBlock(this.newBlockLabel('loop_header'));
+        const bodyBlock = this.createBlock(this.newBlockLabel('loop_body'));
+        const exitBlock = this.createBlock(this.newBlockLabel('loop_exit'));
+        // Branch para header
+        this.setTerminator({ kind: 'Branch', target: headerBlock.label });
+        // 4. loop_header: condição %i < %len → body, senão → exit
+        this.switchToBlock(headerBlock);
+        const iLoadHeader = this.newTemp();
+        this.emit({
+            kind: 'Load',
+            result: iLoadHeader,
+            source: iVar,
+            type: 'i32'
+        });
+        const condVar = this.newTemp();
+        this.emit({
+            kind: 'BinaryOp',
+            result: condVar,
+            op: 'lt',
+            left: { kind: 'LocalRef', name: iLoadHeader, type: 'i32' },
+            right: { kind: 'LocalRef', name: lenVar, type: 'i32' },
+            type: 'i1'
+        });
+        this.setTerminator({
+            kind: 'CondBranch',
+            condition: { kind: 'LocalRef', name: condVar, type: 'i1' },
+            trueBlock: bodyBlock.label,
+            falseBlock: exitBlock.label
+        });
+        // 5. loop_body: obter elemento, gerar corpo, incrementar %i
+        this.switchToBlock(bodyBlock);
+        const iLoadBody = this.newTemp();
+        this.emit({
+            kind: 'Load',
+            result: iLoadBody,
+            source: iVar,
+            type: 'i32'
+        });
+        const elemVar = this.newTemp();
+        this.emit({
+            kind: 'Call',
+            result: elemVar,
+            callee: '@jade_lista_obter',
+            args: [lista, { kind: 'LocalRef', name: iLoadBody, type: 'i32' }],
+            returnType: 'ptr'
+        });
+        this.emit({
+            kind: 'Store',
+            target: '%' + node.variavel,
+            value: { kind: 'LocalRef', name: elemVar, type: 'ptr' },
+            type: 'ptr'
+        });
+        this.generateBloco(node.corpo);
+        if (this.currentBlock && this.currentBlock.terminator.kind === 'Unreachable') {
+            const iLoadInc = this.newTemp();
+            this.emit({
+                kind: 'Load',
+                result: iLoadInc,
+                source: iVar,
+                type: 'i32'
+            });
+            const iPlusOne = this.newTemp();
+            this.emit({
+                kind: 'BinaryOp',
+                result: iPlusOne,
+                op: 'add',
+                left: { kind: 'LocalRef', name: iLoadInc, type: 'i32' },
+                right: { kind: 'Constant', type: 'i32', value: 1 },
+                type: 'i32'
+            });
+            this.emit({
+                kind: 'Store',
+                target: iVar,
+                value: { kind: 'LocalRef', name: iPlusOne, type: 'i32' },
+                type: 'i32'
+            });
+            this.setTerminator({ kind: 'Branch', target: headerBlock.label });
+        }
+        // 6. Continua no exit
+        this.switchToBlock(exitBlock);
+    }
+    generateRetorno(node) {
+        // Se tem valor: gera expressão → Return com valor
+        // Se não tem: Return sem valor
+        if (node.valor) {
+            const value = this.generateExpressao(node.valor);
+            this.setTerminator({ kind: 'Return', value });
+        }
+        else {
+            this.setTerminator({ kind: 'Return' });
+        }
+    }
+    generateErro(node) {
+        // Emite Call para função runtime @jade_erro
+        const mensagem = this.generateExpressao(node.mensagem);
+        this.emit({
+            kind: 'Call',
+            callee: '@jade_erro',
+            args: [mensagem],
+            returnType: 'void'
+        });
+        // Emite Unreachable (erro nunca retorna)
+        this.setTerminator({ kind: 'Unreachable' });
+    }
+    generateEmissaoEvento(node) {
+        // Emite Call para função runtime @jade_emitir_evento
+        const args = node.argumentos.map(arg => this.generateExpressao(arg));
+        this.emit({
+            kind: 'Call',
+            callee: '@jade_emitir_evento',
+            args: [{ kind: 'Constant', type: 'ptr', value: node.evento }, ...args],
+            returnType: 'void'
+        });
+    }
+    // ── Geradores de expressão (retornam IRValue) ────────────
+    generateExpressao(node) {
+        switch (node.kind) {
+            case 'Literal':
+                return this.generateLiteral(node);
+            case 'Identificador':
+                return this.generateIdentificador(node);
+            case 'Binario':
+                return this.generateBinario(node);
+            case 'Unario':
+                return this.generateUnario(node);
+            case 'ChamadaFuncao':
+                return this.generateChamadaFuncao(node);
+            case 'AcessoMembro':
+                return this.generateAcessoMembro(node);
+            case 'Atribuicao':
+                this.generateAtribuicao(node);
+                // Retornar valor atribuído
+                return this.generateExpressao(node.valor);
+            default:
+                throw new Error(`Expressão não suportada: ${node.kind}`);
+        }
+    }
+    generateLiteral(node) {
+        // Retorna IRConstant com o valor e tipo corretos
+        let type;
+        let value = node.valor;
+        switch (node.tipoLiteral) {
+            case 'texto':
+                type = 'ptr';
+                break;
+            case 'numero':
+                type = 'i32';
+                value = Number(node.valor);
+                break;
+            case 'decimal':
+                type = 'f64';
+                value = Number(node.valor);
+                break;
+            case 'booleano':
+                type = 'i1';
+                value = Boolean(node.valor);
+                break;
+            case 'data':
+            case 'hora':
+                type = 'ptr';
+                break;
+            default:
+                type = 'ptr';
+        }
+        return {
+            kind: 'Constant',
+            type,
+            value
+        };
+    }
+    generateIdentificador(node) {
+        // Emite Load da variável local
+        const result = this.newTemp();
+        // Busca tipo nos parâmetros da função atual
+        const param = this.currentFunction?.parameters.find(p => p.name === '%' + node.nome || p.name === node.nome);
+        // Busca tipo nas variáveis locais da função atual
+        const local = this.currentFunction?.locals.find(l => l.name === '%' + node.nome || l.name === node.nome);
+        const type = param?.type || local?.type || 'i32';
+        this.emit({
+            kind: 'Load',
+            result,
+            source: '%' + node.nome,
+            type
+        });
+        return {
+            kind: 'LocalRef',
+            name: result,
+            type
+        };
+    }
+    generateBinario(node) {
+        // Gera esquerda e direita
+        const left = this.generateExpressao(node.esquerda);
+        const right = this.generateExpressao(node.direita);
+        const result = this.newTemp();
+        const op = this.mapOperator(node.operador);
+        // Concatenação de texto: op '+' com operando esquerdo do tipo 'ptr'
+        if (op === 'add' && left.type === 'ptr') {
+            this.emit({
+                kind: 'Call',
+                result,
+                callee: '@jade_concat',
+                args: [left, right],
+                returnType: 'ptr'
+            });
+            return { kind: 'LocalRef', name: result, type: 'ptr' };
+        }
+        // Propaga tipo do operando esquerdo
+        const type = left.type !== 'void' ? left.type : right.type !== 'void' ? right.type : 'i32';
+        // Operadores de comparação sempre retornam i1
+        const resultType = ['eq', 'ne', 'lt', 'le', 'gt', 'ge', 'and', 'or'].includes(op) ? 'i1' : type;
+        this.emit({
+            kind: 'BinaryOp',
+            result,
+            op,
+            left,
+            right,
+            type: resultType
+        });
+        return {
+            kind: 'LocalRef',
+            name: result,
+            type: resultType
+        };
+    }
+    generateUnario(node) {
+        const operand = this.generateExpressao(node.operando);
+        const result = this.newTemp();
+        const op = node.operador === '-' ? 'neg' : 'not';
+        const type = operand.type !== 'void' ? operand.type : 'i32';
+        const resultType = op === 'not' ? 'i1' : type;
+        this.emit({
+            kind: 'UnaryOp',
+            result,
+            op,
+            operand,
+            type: resultType
+        });
+        return {
+            kind: 'LocalRef',
+            name: result,
+            type: resultType
+        };
+    }
+    generateChamadaFuncao(node) {
+        const args = node.argumentos.map(arg => this.generateExpressao(arg));
+        const result = this.newTemp();
+        // Busca o tipo de retorno na lista de funções do módulo
+        const funcIR = this.module.functions.find(f => f.name === '@' + node.nome || f.name === node.nome);
+        const returnType = funcIR?.returnType || 'void';
+        this.emit({
+            kind: 'Call',
+            result: returnType === 'void' ? undefined : result,
+            callee: '@' + node.nome,
+            args,
+            returnType
+        });
+        if (returnType === 'void') {
+            return { kind: 'Constant', type: 'void', value: 0 };
+        }
+        return {
+            kind: 'LocalRef',
+            name: result,
+            type: returnType
+        };
+    }
+    generateAcessoMembro(node) {
+        // Gera objeto
+        const object = this.generateExpressao(node.objeto);
+        // Emite GetField
+        const result = this.newTemp();
+        const type = 'void'; // TODO: Obter tipo do campo
+        this.emit({
+            kind: 'GetField',
+            result,
+            object,
+            field: node.membro,
+            type
+        });
+        return {
+            kind: 'LocalRef',
+            name: result,
+            type
+        };
+    }
+    // ── Utilitários ──────────────────────────────────────────
+    newTemp() {
+        return `%t${this.tempCounter++}`;
+    }
+    newBlockLabel(prefix) {
+        return `${prefix}_${this.blockCounter++}`;
+    }
+    emit(instruction) {
+        if (!this.currentBlock) {
+            throw new Error('Não há bloco atual para emitir instrução');
+        }
+        this.currentBlock.instructions.push(instruction);
+        this.declareLocalIfNeeded(instruction);
+    }
+    declareLocalIfNeeded(instr) {
+        if (!this.currentFunction)
+            return;
+        let name;
+        let type;
+        switch (instr.kind) {
+            case 'BinaryOp':
+                name = instr.result;
+                type = instr.type;
+                break;
+            case 'UnaryOp':
+                name = instr.result;
+                type = instr.type;
+                break;
+            case 'Load':
+                name = instr.result;
+                type = instr.type;
+                break;
+            case 'GetField':
+                name = instr.result;
+                type = instr.type;
+                break;
+            case 'Assign':
+                name = instr.result;
+                type = instr.type;
+                break;
+            case 'Alloc':
+                name = instr.result;
+                type = 'ptr';
+                break;
+            case 'Call':
+                if (instr.result) {
+                    name = instr.result;
+                    type = instr.returnType;
+                }
+                break;
+            case 'Store':
+                name = instr.target;
+                type = instr.type;
+                break;
+        }
+        if (!name || !type || type === 'void')
+            return;
+        const isParam = this.currentFunction.parameters.some(p => p.name === name);
+        if (isParam)
+            return;
+        const alreadyDeclared = this.currentFunction.locals.some(l => l.name === name);
+        if (alreadyDeclared)
+            return;
+        this.currentFunction.locals.push({ name, type });
+    }
+    setTerminator(terminator) {
+        if (!this.currentBlock) {
+            throw new Error('Não há bloco atual para definir terminador');
+        }
+        this.currentBlock.terminator = terminator;
+    }
+    switchToBlock(block) {
+        this.currentBlock = block;
+    }
+    createBlock(label) {
+        if (!this.currentFunction) {
+            throw new Error('Não há função atual para criar bloco');
+        }
+        const block = {
+            label,
+            instructions: [],
+            terminator: { kind: 'Unreachable' }
+        };
+        this.currentFunction.blocks.push(block);
+        return block;
+    }
+    jadeTypeToIR(type) {
+        switch (type.kind) {
+            case 'TipoSimples':
+                const nome = type.nome;
+                // Mapeamento tipo JADE → IRType
+                switch (nome) {
+                    case 'numero': return 'i32';
+                    case 'decimal': return 'f64';
+                    case 'booleano': return 'i1';
+                    case 'texto': return 'ptr';
+                    case 'id': return 'ptr';
+                    case 'data': return 'ptr';
+                    case 'hora': return 'ptr';
+                    default: return 'ptr'; // classes/entidades são ponteiros
+                }
+            case 'TipoLista':
+            case 'TipoMapa':
+            case 'TipoObjeto':
+                return 'ptr';
+            default:
+                return 'ptr';
+        }
+    }
+    mapOperator(op) {
+        switch (op) {
+            case '+': return 'add';
+            case '-': return 'sub';
+            case '*': return 'mul';
+            case '/': return 'div';
+            case '==': return 'eq';
+            case '!=': return 'ne';
+            case '<': return 'lt';
+            case '<=': return 'le';
+            case '>': return 'gt';
+            case '>=': return 'ge';
+            case 'e': return 'and';
+            case 'ou': return 'or';
+            default: throw new Error(`Operador não suportado: ${op}`);
+        }
+    }
+}
+//# sourceMappingURL=ir_generator.js.map