Repository: DesignLiquido/delegua
Pull request #425 (2023-06-02 01:27:45)

Potigol 2 + Correção fundamental em estrutura chamável.
Durante a codificação do dialeto de Potigol, encontramos um bug na estrutura chamável, que não estava executando seu comportamento assíncrono corretamente.


Patch:
diff --git a/README.md b/README.md
index 87c2bde8..c9032c3a 100644
--- a/README.md
+++ b/README.md
@@ -24,7 +24,6 @@
     <a href="https://www.npmjs.com/package/@designliquido/delegua" target="_blank">
       <img src="https://img.shields.io/npm/v/@designliquido/delegua" />
     </a>
-    <img src="https://img.shields.io/npm/dw/@designliquido/delegua" />
     <img src="https://img.shields.io/github/license/Designliquido/delegua" />
   </p>
 
diff --git a/fontes/avaliador-sintatico/README.md b/fontes/avaliador-sintatico/README.md
new file mode 100644
index 00000000..c0b42b80
--- /dev/null
+++ b/fontes/avaliador-sintatico/README.md
@@ -0,0 +1,19 @@
+# Avaliador Sintático
+
+O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.Essas estruturas de alto nível são as partes que contêm lógica de programação de fato.
+
+Há dois grupos de estruturas de alto nível: Construtos e Declarações. 
+
+- Um Construto não executa por si só;
+- Uma combinação de Construtos forma uma Expressão;
+- Uma Expressão é um tipo de Declaração;
+- Uma Declaração é um elemento que
+    - Pode ser executado pelo Interpretador;
+    - Pode ser traduzido pelo Tradutor;
+    - Pode ser analisado pelo Analisador Semântico.
+
+## Micro Avaliador Sintático
+
+Há algumas situações em que a avaliação sintática de uma linguagem precisa ser feita num âmbito reduzido, como por exemplo em interpolações de texto (como no analisador sintático de Delégua), ou em verificação preguiçosa de parâmetros de funções (ver analisador sintático de Potigol para um exemplo). Por exemplo, não faz sentido em uma interpolação de texto termos uma declaração de classe, de tipo ou de função, mas faz sentido avaliarmos expressões. 
+
+Micro avaliadores sintáticos cumprem essa função. Tendo a implementação da sintaxe da linguagem reduzida para alguns casos, não apenas o processamento é mais rápido como é também mais seguro, tendo a limitação de escopo como uma vantagem para detecção de erros.
\ No newline at end of file
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
index bf5c95e3..4663dcd5 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
@@ -151,7 +151,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
             )
         ) {
             const operador = this.simbolos[this.atual - 1];
-            const direito = this.unario();
+            const direito = this.exponenciacao();
             expressao = new Binario(this.hashArquivo, expressao, operador, direito);
         }
 
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-potigol.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-potigol.ts
deleted file mode 100644
index a6b6655e..00000000
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-potigol.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-import { Construto, FuncaoConstruto, Literal, Variavel } from "../../construtos";
-import { Escreva, Declaracao, Se, Enquanto, Para, Escolha, Fazer, EscrevaMesmaLinha } from "../../declaracoes";
-import { RetornoLexador, RetornoAvaliadorSintatico } from "../../interfaces/retornos";
-import { AvaliadorSintaticoBase } from "../avaliador-sintatico-base";
-
-import tiposDeSimbolos from "../../tipos-de-simbolos/potigol";
-import { SimboloInterface } from "../../interfaces";
-
-export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
-    primario(): Construto {
-        const simboloAtual = this.simbolos[this.atual];
-
-        switch (simboloAtual.tipo) {
-            case tiposDeSimbolos.INTEIRO:
-            case tiposDeSimbolos.REAL:
-            case tiposDeSimbolos.TEXTO:
-                const simboloNumeroTexto: SimboloInterface = this.avancarEDevolverAnterior();
-                return new Literal(this.hashArquivo, Number(simboloNumeroTexto.linha), simboloNumeroTexto.literal);
-            default:
-                const simboloIdentificador: SimboloInterface = this.avancarEDevolverAnterior();
-                return new Variavel(this.hashArquivo, simboloIdentificador);
-        }
-    }
-
-    chamar(): Construto {
-        return this.primario();
-    }
-    
-
-    declaracaoEscreva(): Escreva {
-        const simboloAtual = this.avancarEDevolverAnterior();
-
-        const argumentos: Construto[] = [];
-
-        do {
-            argumentos.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
-
-        return new Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
-    }
-
-    declaracaoImprima(): EscrevaMesmaLinha {
-        const simboloAtual = this.avancarEDevolverAnterior();
-
-        const argumentos: Construto[] = [];
-
-        do {
-            argumentos.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
-
-        return new EscrevaMesmaLinha(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
-    }
-
-    blocoEscopo(): Declaracao[] {
-        throw new Error("Método não implementado.");
-    }
-    declaracaoSe(): Se {
-        throw new Error("Método não implementado.");
-    }
-    declaracaoEnquanto(): Enquanto {
-        throw new Error("Método não implementado.");
-    }
-    declaracaoPara(): Para {
-        throw new Error("Método não implementado.");
-    }
-    declaracaoEscolha(): Escolha {
-        throw new Error("Método não implementado.");
-    }
-    declaracaoFazer(): Fazer {
-        throw new Error("Método não implementado.");
-    }
-    corpoDaFuncao(tipo: string): FuncaoConstruto {
-        throw new Error("Método não implementado.");
-    }
-
-    declaracao(): Declaracao | Declaracao[] | Construto | Construto[] | any {
-        const simboloAtual = this.simbolos[this.atual];
-        switch (simboloAtual.tipo) {
-            case tiposDeSimbolos.ESCREVA:
-                return this.declaracaoEscreva();
-            case tiposDeSimbolos.IMPRIMA:
-                return this.declaracaoImprima();
-            default:
-                return this.expressao();
-        }
-    }
-
-    atribuir(): Construto {
-        return this.ou();
-    }
-
-    analisar(retornoLexador: RetornoLexador, hashArquivo: number): RetornoAvaliadorSintatico {
-        this.erros = [];
-        this.atual = 0;
-        this.blocos = 0;
-
-        this.hashArquivo = hashArquivo || 0;
-        this.simbolos = retornoLexador?.simbolos || [];
-
-        const declaracoes: Declaracao[] = [];
-        while (!this.estaNoFinal()) {
-            declaracoes.push(this.declaracao() as Declaracao);
-        }
-
-        return {
-            declaracoes: declaracoes,
-            erros: this.erros,
-        } as RetornoAvaliadorSintatico;
-    }
-}
\ No newline at end of file
diff --git a/fontes/avaliador-sintatico/dialetos/index.ts b/fontes/avaliador-sintatico/dialetos/index.ts
index 67f36fa5..1a0c6fb6 100644
--- a/fontes/avaliador-sintatico/dialetos/index.ts
+++ b/fontes/avaliador-sintatico/dialetos/index.ts
@@ -2,7 +2,7 @@ export * from './avaliador-sintatico-birl';
 export * from './avaliador-sintatico-egua-classico';
 export * from './avaliador-sintatico-eguap';
 export * from './avaliador-sintatico-mapler';
-export * from './avaliador-sintatico-potigol';
+export * from './potigol/avaliador-sintatico-potigol';
 export * from './avaliador-sintatico-portugol-ipt';
 export * from './avaliador-sintatico-portugol-studio';
 export * from './avaliador-sintatico-visualg';
diff --git a/fontes/avaliador-sintatico/dialetos/potigol/README.md b/fontes/avaliador-sintatico/dialetos/potigol/README.md
new file mode 100644
index 00000000..c62d53f0
--- /dev/null
+++ b/fontes/avaliador-sintatico/dialetos/potigol/README.md
@@ -0,0 +1,28 @@
+# Avaliador Sintático para dialeto Potigol
+
+Aqui temos toda a implementação da avaliação sintática para Potigol separada em dois elementos:
+
+- `AvaliadorSintaticoPotigol`: O avaliador sintático em si;
+- `MicroAvaliadorSintaticoPotigol`: O micro avaliador sintático, usado para inferência de parâmetros e pequenas operações de expressões.
+
+## Características de Potigol
+
+### Tipos e Objetos
+
+Cada tipo em Potigol implementa um construtor implícito: cada propriedade anotada com tipo e sem valor é entendida como parte do construtor. Por exemplo;
+
+```
+tipo Quadrado
+  lado: Inteiro
+  area() = lado * lado
+  perimetro() = 4 * lado
+fim
+```
+
+`lado: Inteiro` irá gerar um construtor com um parâmetro inteiro:
+
+```
+q1 = Quadrado(10)
+```
+
+A ordem das propriedades é importante para a definição do construtor.
\ No newline at end of file
diff --git a/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts b/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts
new file mode 100644
index 00000000..dd29881f
--- /dev/null
+++ b/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts
@@ -0,0 +1,974 @@
+import {
+    AcessoIndiceVariavel,
+    AcessoMetodo,
+    Agrupamento,
+    Atribuir,
+    Binario,
+    Chamada,
+    Constante,
+    ConstanteOuVariavel,
+    Construto,
+    DefinirValor,
+    FimPara,
+    FuncaoConstruto,
+    Isto,
+    Literal,
+    Unario,
+    Variavel,
+} from '../../../construtos';
+import {
+    Escreva,
+    Declaracao,
+    Se,
+    Enquanto,
+    Para,
+    Escolha,
+    Fazer,
+    EscrevaMesmaLinha,
+    Const,
+    Var,
+    Bloco,
+    Expressao,
+    FuncaoDeclaracao,
+    Classe,
+    PropriedadeClasse,
+} from '../../../declaracoes';
+import { RetornoLexador, RetornoAvaliadorSintatico } from '../../../interfaces/retornos';
+import { AvaliadorSintaticoBase } from '../../avaliador-sintatico-base';
+
+import { ParametroInterface, SimboloInterface } from '../../../interfaces';
+import { TiposDadosInterface } from '../../../interfaces/tipos-dados-interface';
+import { Simbolo } from '../../../lexador';
+import { ErroAvaliadorSintatico } from '../../erro-avaliador-sintatico';
+import { RetornoDeclaracao } from '../../retornos';
+
+import tiposDeSimbolos from '../../../tipos-de-simbolos/potigol';
+import { SeletorTuplas, Tupla } from '../../../construtos/tuplas';
+import { MicroAvaliadorSintaticoPotigol } from './micro-avaliador-sintatico-potigol';
+
+/**
+ * TODO: Pensar numa forma de avaliar múltiplas constantes sem
+ * transformar o retorno de `primario()` em um vetor.
+ */
+export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
+    microAvaliadorSintatico: MicroAvaliadorSintaticoPotigol;
+
+    tiposPotigolParaDelegua = {
+        Caractere: 'texto',
+        Inteiro: 'numero',
+        Logico: 'lógico',
+        Lógico: 'lógico',
+        Real: 'numero',
+        Texto: 'texto',
+        undefined: undefined,
+    };
+
+    declaracoesAnteriores: { [identificador: string]: any[] }
+
+    /**
+     * Testa se o primeiro parâmetro na lista de símbolos
+     * pertence a uma declaração ou não.
+     * @param simbolos Os símbolos que fazem parte da lista de argumentos
+     * de uma chamada ou declaração de função.
+     * @returns `true` se parâmetros são de declaração. `false` caso contrário.
+     */
+    protected testePrimeiroParametro(simbolos: SimboloInterface[]) {
+        let atual = 0;
+
+        // Primeiro teste: literal ou identificador
+        if ([
+                tiposDeSimbolos.INTEIRO,
+                tiposDeSimbolos.LOGICO,
+                tiposDeSimbolos.REAL,
+                tiposDeSimbolos.TEXTO
+            ].includes(simbolos[atual].tipo)
+        ) {
+            return false;
+        }
+
+        // Segundo teste: vírgula imediatamente após identificador, 
+        // ou simplesmente fim da lista de símbolos.
+        atual++;
+        if (atual === simbolos.length || simbolos[atual].tipo === tiposDeSimbolos.VIRGULA) {
+            return false;
+        }
+
+        // Outros casos: dois-pontos após identificador, etc.
+        return true;
+    }
+
+    /**
+     * Retorna uma declaração de função iniciada por igual, 
+     * ou seja, com apenas uma instrução.
+     * @param simboloPrimario O símbolo que identifica a função (nome).
+     * @param parenteseEsquerdo O parêntese esquerdo, usado para fins de pragma.
+     * @param parametros A lista de parâmetros da função.
+     * @param tipoRetorno O tipo de retorno da função.
+     * @returns Um construto do tipo `FuncaoDeclaracao`.
+     */
+    protected declaracaoFuncaoPotigolIniciadaPorIgual(
+        simboloPrimario: SimboloInterface,
+        parenteseEsquerdo: SimboloInterface,
+        parametros: ParametroInterface[],
+        tipoRetorno?: SimboloInterface
+    ): FuncaoDeclaracao {
+        const corpo = new FuncaoConstruto(
+            simboloPrimario.hashArquivo, 
+            simboloPrimario.linha,
+            parametros,
+            [this.expressao()] 
+        );
+        return new FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno);
+    }
+
+    /**
+     * Retorna uma declaração de função terminada por fim, 
+     * ou seja, com mais de uma instrução.
+     * @param simboloPrimario O símbolo que identifica a função (nome).
+     * @param parenteseEsquerdo O parêntese esquerdo, usado para fins de pragma.
+     * @param parametros A lista de parâmetros da função.
+     * @param tipoRetorno O tipo de retorno da função.
+     * @returns Um construto do tipo `FuncaoDeclaracao`.
+     */
+    protected declaracaoFuncaoPotigolTerminadaPorFim(
+        simboloPrimario: SimboloInterface,
+        parenteseEsquerdo: SimboloInterface,
+        parametros: ParametroInterface[],
+        tipoRetorno?: SimboloInterface
+    ): FuncaoDeclaracao {
+        const corpo = this.corpoDaFuncao(simboloPrimario.lexema, parenteseEsquerdo, parametros);
+        return new FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno);
+    }
+
+    corpoDaFuncao(nomeFuncao: string, simboloPragma?: SimboloInterface, parametros?: any[]): FuncaoConstruto {
+        // this.consumir(tiposDeSimbolos.IGUAL, `Esperado '=' antes do escopo da função ${nomeFuncao}.`);
+
+        const corpo = this.blocoEscopo();
+
+        return new FuncaoConstruto(this.hashArquivo, Number(simboloPragma.linha), parametros, corpo);
+    }
+
+    protected declaracaoDeFuncaoOuMetodo(construtoPrimario: ConstanteOuVariavel): FuncaoDeclaracao {
+        // O parêntese esquerdo é considerado o símbolo inicial para
+        // fins de pragma.
+        const parenteseEsquerdo = this.avancarEDevolverAnterior();
+        
+        const simbolosEntreParenteses: SimboloInterface[] = [];
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
+            simbolosEntreParenteses.push(this.avancarEDevolverAnterior());
+        }
+
+        const resolucaoParametros = this.logicaComumParametrosPotigol(simbolosEntreParenteses);
+        const parenteseDireito = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+
+        // Pode haver uma dica do tipo de retorno ou não.
+        // Se houver, é uma declaração de função (verificado mais abaixo).
+        let tipoRetorno: SimboloInterface = undefined;
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DOIS_PONTOS)) {
+            this.verificacaoTipo(this.simbolos[this.atual], 'Esperado tipo válido após dois-pontos como retorno de função.');
+
+            tipoRetorno = this.simbolos[this.atual - 1];
+        }
+        
+        // Se houver símbolo de igual, seja após fechamento de parênteses,
+        // seja após a dica de retorno, é uma declaração de função.
+        if (this.simbolos[this.atual].tipo === tiposDeSimbolos.IGUAL) {
+            this.avancarEDevolverAnterior();
+            this.declaracoesAnteriores[construtoPrimario.simbolo.lexema] = [];
+            return this.declaracaoFuncaoPotigolIniciadaPorIgual(
+                construtoPrimario.simbolo, 
+                parenteseEsquerdo, 
+                resolucaoParametros.parametros, 
+                tipoRetorno
+            );
+        }
+
+        return this.declaracaoFuncaoPotigolTerminadaPorFim(
+            construtoPrimario.simbolo, 
+            parenteseEsquerdo, 
+            resolucaoParametros.parametros, 
+            tipoRetorno
+        );
+    }
+
+    finalizarChamada(entidadeChamada: Construto): Construto {
+        // Parêntese esquerdo 
+        // this.avancarEDevolverAnterior();
+
+        const simbolosEntreParenteses: SimboloInterface[] = [];
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
+            simbolosEntreParenteses.push(this.avancarEDevolverAnterior());
+        }
+
+        const parenteseDireito = this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+
+        const argumentos = this.microAvaliadorSintatico.analisar(
+            { simbolos: simbolosEntreParenteses } as any,
+            entidadeChamada.linha
+        )
+
+        return new Chamada(
+            this.hashArquivo, 
+            entidadeChamada, 
+            parenteseDireito, 
+            argumentos.declaracoes.filter(d => d)
+        );
+    }
+
+    /**
+     * Verificação comum de tipos.
+     * Avança o símbolo se não houver erros.
+     * @param simbolo O símbolo sendo analisado.
+     * @param mensagemErro A mensagem de erro caso o símbolo atual não seja de tipo.
+     */
+    protected verificacaoTipo(simbolo: SimboloInterface, mensagemErro: string) {
+        if (
+            ![
+                tiposDeSimbolos.INTEIRO,
+                tiposDeSimbolos.LOGICO,
+                tiposDeSimbolos.REAL,
+                tiposDeSimbolos.TEXTO].includes(simbolo.tipo)
+        ) {
+            throw this.erro(simbolo, mensagemErro);
+        }
+    }
+
+    protected logicaComumParametrosPotigol(
+        simbolos: SimboloInterface[]
+    ): { parametros: ParametroInterface[], tipagemDefinida: boolean } {
+        const parametros: ParametroInterface[] = [];
+        let indice = 0;
+        let tipagemDefinida = false;
+
+        while (indice < simbolos.length) {
+            if (parametros.length >= 255) {
+                this.erro(simbolos[indice], 'Não pode haver mais de 255 parâmetros');
+            }
+
+            const parametro: Partial<ParametroInterface> = {};
+
+            // TODO: verificar se Potigol trabalha com número variável de parâmetros.
+            /* if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) {
+                this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
+                parametro.abrangencia = 'multiplo';
+            } else {
+                parametro.abrangencia = 'padrao';
+            } */
+
+            parametro.abrangencia = 'padrao';
+            if (simbolos[indice].tipo !== tiposDeSimbolos.IDENTIFICADOR) {
+                throw this.erro(simbolos[indice], 'Esperado nome do parâmetro.');
+            }
+
+            parametro.nome = simbolos[indice];
+            indice++;
+
+            if (simbolos[indice].tipo === tiposDeSimbolos.DOIS_PONTOS) {
+                // throw this.erro(simbolos[indice], 'Esperado dois-pontos após nome de argumento para função.');
+
+                indice++;
+                this.verificacaoTipo(simbolos[indice], 'Esperado tipo do argumento após dois-pontos, em definição de função.');
+
+                const tipoParametro = simbolos[indice];
+                parametro.tipo = this.tiposPotigolParaDelegua[tipoParametro.lexema];
+                tipagemDefinida = true;
+            }
+
+            // TODO: Verificar se Potigol trabalha com valores padrão em argumentos.
+            /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                parametro.valorPadrao = this.primario();
+            } */
+
+            parametros.push(parametro as ParametroInterface);
+
+            // if (parametro.abrangencia === 'multiplo') break;
+            indice++;
+            if (indice < simbolos.length && simbolos[indice].tipo !== tiposDeSimbolos.VIRGULA) {
+                throw this.erro(simbolos[indice], 'Esperado vírgula entre parâmetros de função.');
+            }
+
+            indice++;
+        };
+
+        return { 
+            parametros, 
+            tipagemDefinida
+        };
+    }
+
+    primario(): Construto {
+        const simboloAtual = this.simbolos[this.atual];
+
+        switch (simboloAtual.tipo) {
+            case tiposDeSimbolos.PARENTESE_ESQUERDO:
+                this.avancarEDevolverAnterior();
+                const expressao = this.expressao();
+                switch (this.simbolos[this.atual].tipo) {
+                    case tiposDeSimbolos.VIRGULA:
+                        // Tupla
+                        const argumentos = [expressao];
+                        while (this.simbolos[this.atual].tipo === tiposDeSimbolos.VIRGULA) {
+                            this.avancarEDevolverAnterior();
+                            argumentos.push(this.expressao());
+                        }
+
+                        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                        return new SeletorTuplas(...argumentos) as Tupla;
+                    default:
+                        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                        return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
+                }
+
+            case tiposDeSimbolos.CARACTERE:
+            case tiposDeSimbolos.INTEIRO:
+            case tiposDeSimbolos.LOGICO:
+            case tiposDeSimbolos.REAL:
+            case tiposDeSimbolos.TEXTO:
+                const simboloLiteral: SimboloInterface = this.avancarEDevolverAnterior();
+                return new Literal(this.hashArquivo, Number(simboloLiteral.linha), simboloLiteral.literal);
+            case tiposDeSimbolos.FALSO:
+            case tiposDeSimbolos.VERDADEIRO:
+                const simboloVerdadeiroFalso: SimboloInterface = this.avancarEDevolverAnterior();
+                return new Literal(
+                    this.hashArquivo,
+                    Number(simboloVerdadeiroFalso.linha),
+                    simboloVerdadeiroFalso.tipo === tiposDeSimbolos.VERDADEIRO
+                );
+            default:
+                const simboloIdentificador: SimboloInterface = this.avancarEDevolverAnterior();
+                return new ConstanteOuVariavel(this.hashArquivo, simboloIdentificador);
+        }
+    }
+
+    /**
+     * Em Potigol, só é possível determinar a diferença entre uma chamada e uma
+     * declaração de função depois dos argumentos.
+     * 
+     * Chamadas não aceitam dicas de tipos de parâmetros. 
+     * @returns Um construto do tipo `AcessoMetodo`, `AcessoIndiceVariavel` ou `Constante`,
+     * dependendo dos símbolos encontrados.
+     */
+    chamar(): Construto {
+        let expressao = this.primario();
+
+        while (true) {
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)) {
+                if (expressao instanceof ConstanteOuVariavel) {
+                    expressao = new Constante(expressao.hashArquivo, expressao.simbolo);
+                }
+                expressao = this.finalizarChamada(expressao);
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO)) {
+                const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, "Esperado nome do método após '.'.");
+                const variavelMetodo = new Variavel(expressao.hashArquivo, (expressao as any).simbolo);
+                expressao = new AcessoMetodo(this.hashArquivo, variavelMetodo, nome);
+            } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
+                const indice = this.expressao();
+                const simboloFechamento = this.consumir(
+                    tiposDeSimbolos.COLCHETE_DIREITO,
+                    "Esperado ']' após escrita do indice."
+                );
+                const variavelVetor = new Variavel(expressao.hashArquivo, (expressao as any).simbolo);
+                expressao = new AcessoIndiceVariavel(this.hashArquivo, variavelVetor, indice, simboloFechamento);
+            } else {
+                if (expressao instanceof ConstanteOuVariavel) {
+                    expressao = new Constante(expressao.hashArquivo, (expressao as any).simbolo);
+                }
+                
+                break;
+            }
+        }
+
+        return expressao;
+    }
+
+    comparacaoIgualdade(): Construto {
+        let expressao = this.comparar();
+
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DIFERENTE, tiposDeSimbolos.IGUAL_IGUAL)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.comparar();
+            expressao = new Binario(this.hashArquivo, expressao, operador, direito);
+        }
+
+        return expressao;
+    }
+
+    declaracaoEscreva(): Escreva {
+        const simboloAtual = this.avancarEDevolverAnterior();
+
+        const argumentos: Construto[] = [];
+
+        do {
+            argumentos.push(this.expressao());
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+
+        return new Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
+    }
+
+    declaracaoImprima(): EscrevaMesmaLinha {
+        const simboloAtual = this.avancarEDevolverAnterior();
+
+        const argumentos: Construto[] = [];
+
+        do {
+            argumentos.push(this.expressao());
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+
+        return new EscrevaMesmaLinha(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
+    }
+
+    /**
+     * Blocos de escopo em Potigol existem quando:
+     * 
+     * - Em uma declaração de função ou método, após fecha parênteses, o próximo 
+     * símbolo obrigatório não é `=` e há pelo menos um `fim` até o final do código;
+     * - Em uma declaração `se`;
+     * - Em uma declaração `enquanto`;
+     * - Em uma declaração `para`.
+     * @returns Um vetor de `Declaracao`.
+     */
+    blocoEscopo(): Array<RetornoDeclaracao> {
+        let declaracoes: Array<RetornoDeclaracao> = [];
+
+        while (!this.estaNoFinal() && !this.verificarTipoSimboloAtual(tiposDeSimbolos.FIM)) {
+            const retornoDeclaracao = this.declaracao();
+            if (Array.isArray(retornoDeclaracao)) {
+                declaracoes = declaracoes.concat(retornoDeclaracao);
+            } else {
+                declaracoes.push(retornoDeclaracao as Declaracao);
+            }
+        }
+
+        return declaracoes;
+    }
+
+    declaracaoSe(): Se {
+        const simboloSe: SimboloInterface = this.avancarEDevolverAnterior();
+
+        const condicao = this.expressao();
+
+        this.consumir(tiposDeSimbolos.ENTAO, "Esperado palavra reservada 'entao' após condição em declaração 'se'.");
+
+        const declaracoes = [];
+        do {
+            declaracoes.push(this.declaracao());
+        } while (![tiposDeSimbolos.SENAO, tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo));
+
+        let caminhoSenao = null;
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO)) {
+            const simboloSenao = this.simbolos[this.atual - 1];
+            const declaracoesSenao = [];
+
+            do {
+                declaracoesSenao.push(this.declaracao());
+            } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo));
+
+            caminhoSenao = new Bloco(
+                this.hashArquivo,
+                Number(simboloSenao.linha),
+                declaracoesSenao.filter((d) => d)
+            );
+        }
+
+        this.consumir(tiposDeSimbolos.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'se'.");
+
+        return new Se(
+            condicao,
+            new Bloco(
+                this.hashArquivo,
+                Number(simboloSe.linha),
+                declaracoes.filter((d) => d)
+            ),
+            [],
+            caminhoSenao
+        );
+    }
+
+    declaracaoEnquanto(): Enquanto {
+        const simboloAtual = this.avancarEDevolverAnterior();
+
+        const condicao = this.expressao();
+
+        this.consumir(
+            tiposDeSimbolos.FACA,
+            "Esperado paravra reservada 'faca' após condição de continuidade em declaracão 'enquanto'."
+        );
+
+        const declaracoes = [];
+        do {
+            declaracoes.push(this.declaracao());
+        } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo));
+
+        this.consumir(tiposDeSimbolos.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'enquanto'.");
+
+        return new Enquanto(
+            condicao,
+            new Bloco(
+                simboloAtual.hashArquivo,
+                Number(simboloAtual.linha),
+                declaracoes.filter((d) => d)
+            )
+        );
+    }
+
+    declaracaoPara(): Para {
+        const simboloPara: SimboloInterface = this.avancarEDevolverAnterior();
+
+        const variavelIteracao = this.consumir(
+            tiposDeSimbolos.IDENTIFICADOR,
+            "Esperado identificador de variável após 'para'."
+        );
+
+        this.consumir(tiposDeSimbolos.DE, "Esperado palavra reservada 'de' após variáve de controle de 'para'.");
+
+        const literalOuVariavelInicio = this.adicaoOuSubtracao();
+
+        this.consumir(
+            tiposDeSimbolos.ATE,
+            "Esperado palavra reservada 'ate' após valor inicial do laço de repetição 'para'."
+        );
+
+        const literalOuVariavelFim = this.adicaoOuSubtracao();
+
+        let operadorCondicao = new Simbolo(
+            tiposDeSimbolos.MENOR_IGUAL,
+            '',
+            '',
+            Number(simboloPara.linha),
+            this.hashArquivo
+        );
+        let operadorCondicaoIncremento = new Simbolo(
+            tiposDeSimbolos.MENOR,
+            '',
+            '',
+            Number(simboloPara.linha),
+            this.hashArquivo
+        );
+
+        // Isso existe porque o laço `para` do Potigol pode ter o passo positivo ou negativo
+        // dependendo dos operandos de início e fim, que só são possíveis de determinar
+        // em tempo de execução.
+        // Quando um dos operandos é uma variável, tanto a condição do laço quanto o
+        // passo são considerados indefinidos aqui.
+        let passo: Construto;
+        let resolverIncrementoEmExecucao = false;
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PASSO)) {
+            passo = this.unario();
+        } else {
+            if (literalOuVariavelInicio instanceof Literal && literalOuVariavelFim instanceof Literal) {
+                if (literalOuVariavelInicio.valor > literalOuVariavelFim.valor) {
+                    passo = new Unario(
+                        this.hashArquivo,
+                        new Simbolo(
+                            tiposDeSimbolos.SUBTRACAO,
+                            '-',
+                            undefined,
+                            simboloPara.linha,
+                            simboloPara.hashArquivo
+                        ),
+                        new Literal(this.hashArquivo, Number(simboloPara.linha), 1),
+                        'ANTES'
+                    );
+                    operadorCondicao = new Simbolo(
+                        tiposDeSimbolos.MAIOR_IGUAL,
+                        '',
+                        '',
+                        Number(simboloPara.linha),
+                        this.hashArquivo
+                    );
+                    operadorCondicaoIncremento = new Simbolo(
+                        tiposDeSimbolos.MAIOR,
+                        '',
+                        '',
+                        Number(simboloPara.linha),
+                        this.hashArquivo
+                    );
+                } else {
+                    passo = new Literal(this.hashArquivo, Number(simboloPara.linha), 1);
+                }
+            } else {
+                // Passo e operador de condição precisam ser resolvidos em tempo de execução.
+                passo = undefined;
+                operadorCondicao = undefined;
+                operadorCondicaoIncremento = undefined;
+                resolverIncrementoEmExecucao = true;
+            }
+        }
+
+        this.consumir(
+            tiposDeSimbolos.FACA,
+            "Esperado palavra reservada 'faca' após valor final do laço de repetição 'para'."
+        );
+
+        const declaracoesBlocoPara = [];
+        let simboloAtualBlocoPara: SimboloInterface = this.simbolos[this.atual];
+        while (simboloAtualBlocoPara.tipo !== tiposDeSimbolos.FIM) {
+            declaracoesBlocoPara.push(this.declaracao());
+            simboloAtualBlocoPara = this.simbolos[this.atual];
+        }
+
+        this.consumir(tiposDeSimbolos.FIM, '');
+
+        const corpo = new Bloco(
+            this.hashArquivo,
+            Number(simboloPara.linha) + 1,
+            declaracoesBlocoPara.filter((d) => d)
+        );
+
+        const para = new Para(
+            this.hashArquivo,
+            Number(simboloPara.linha),
+            new Atribuir(this.hashArquivo, variavelIteracao, literalOuVariavelInicio),
+            new Binario(
+                this.hashArquivo,
+                new Variavel(this.hashArquivo, variavelIteracao),
+                operadorCondicao,
+                literalOuVariavelFim
+            ),
+            new FimPara(
+                this.hashArquivo,
+                Number(simboloPara.linha),
+                new Binario(
+                    this.hashArquivo,
+                    new Variavel(this.hashArquivo, variavelIteracao),
+                    operadorCondicaoIncremento,
+                    literalOuVariavelFim
+                ),
+                new Expressao(
+                    new Atribuir(
+                        this.hashArquivo,
+                        variavelIteracao,
+                        new Binario(
+                            this.hashArquivo,
+                            new Variavel(this.hashArquivo, variavelIteracao),
+                            new Simbolo(tiposDeSimbolos.ADICAO, '', null, Number(simboloPara.linha), this.hashArquivo),
+                            passo
+                        )
+                    )
+                )
+            ),
+            corpo
+        );
+        para.blocoPosExecucao = corpo;
+        para.resolverIncrementoEmExecucao = resolverIncrementoEmExecucao;
+        return para;
+    }
+
+    declaracaoEscolha(): Escolha {
+        this.avancarEDevolverAnterior();
+
+        const condicao = this.expressao();
+
+        const caminhos = [];
+        let caminhoPadrao = null;
+
+        while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.FIM)) {
+            this.consumir(tiposDeSimbolos.CASO, "Esperado palavra reservada 'caso' após condição de 'escolha'.");
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.TRACO_BAIXO)) {
+                // Caso padrão
+                if (caminhoPadrao !== null) {
+                    const excecao = new ErroAvaliadorSintatico(
+                        this.simbolos[this.atual],
+                        "Você só pode ter um caminho padrão em cada declaração de 'escolha'."
+                    );
+                    this.erros.push(excecao);
+                    throw excecao;
+                }
+
+                this.consumir(tiposDeSimbolos.SETA, "Esperado '=>' após palavra reservada 'caso'.");
+                const declaracoesPadrao = [this.declaracao()];
+
+                // TODO: Verificar se Potigol admite bloco de escopo para `escolha`.
+                /* const declaracoesPadrao = [];
+                do {
+                    declaracoesPadrao.push(this.declaracao());
+                } while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO, tiposDeSimbolos.FIM)); */
+
+                caminhoPadrao = {
+                    declaracoes: declaracoesPadrao,
+                };
+
+                continue;
+            }
+
+            const caminhoCondicoes = [this.expressao()];
+            this.consumir(tiposDeSimbolos.SETA, "Esperado '=>' após palavra reservada 'caso'.");
+            const declaracoes = [this.declaracao()];
+
+            // TODO: Verificar se Potigol admite bloco de escopo para `escolha`.
+            /* const declaracoes = [];
+            do {
+                declaracoes.push(this.declaracao());
+            } while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO, tiposDeSimbolos.FIM)); */
+
+            caminhos.push({
+                condicoes: caminhoCondicoes,
+                declaracoes,
+            });
+        }
+
+        return new Escolha(condicao, caminhos, caminhoPadrao);
+    }
+
+    declaracaoDeVariaveis(): Var[] {
+        const simboloVar = this.avancarEDevolverAnterior();
+        const identificadores: SimboloInterface[] = [];
+        do {
+            identificadores.push(this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome de variável.'));
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+
+        this.consumir(tiposDeSimbolos.REATRIBUIR, "Esperado ':=' após identificador em instrução 'var'.");
+
+        const inicializadores = [];
+        do {
+            inicializadores.push(this.expressao());
+        } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+
+        if (identificadores.length !== inicializadores.length) {
+            throw this.erro(
+                simboloVar,
+                'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.'
+            );
+        }
+
+        const retorno = [];
+        for (let [indice, identificador] of identificadores.entries()) {
+            retorno.push(new Var(identificador, inicializadores[indice]));
+        }
+
+        return retorno;
+    }
+
+    protected logicaAtribuicaoComDica(expressao: Constante) {
+        // A dica de tipo é opcional.
+        // Só que, se a avaliação entra na dica, só
+        // podemos ter uma constante apenas.
+        this.avancarEDevolverAnterior();
+        if (
+            ![
+                tiposDeSimbolos.CARACTERE,
+                tiposDeSimbolos.INTEIRO,
+                tiposDeSimbolos.LOGICO,
+                tiposDeSimbolos.REAL,
+                tiposDeSimbolos.TEXTO,
+            ].includes(this.simbolos[this.atual].tipo)
+        ) {
+            throw this.erro(this.simbolos[this.atual], 'Esperado tipo após dois-pontos e nome de identificador.');
+        }
+
+        const tipoVariavel = this.avancarEDevolverAnterior();
+        const valorAtribuicaoConstante = this.ou();
+        return new Const(
+            (expressao as Constante).simbolo,
+            valorAtribuicaoConstante,
+            this.tiposPotigolParaDelegua[tipoVariavel.lexema] as TiposDadosInterface
+        );
+    }
+
+    declaracaoFazer(): Fazer {
+        throw new Error('Método não implementado.');
+    }
+
+    /**
+     * Uma declaração de tipo nada mais é do que um declaração de classe.
+     * Em Potigol, classe e tipo são praticamente a mesma coisa.
+     * 
+     * @returns Um construto do tipo `Classe`.
+     */
+    declaracaoTipo(): Classe {
+        const simboloTipo = this.avancarEDevolverAnterior();
+        const construto: ConstanteOuVariavel = this.primario() as ConstanteOuVariavel;
+
+        // TODO: Verificar se Potigol trabalha com herança.
+        /* let superClasse = null;
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
+            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+            superClasse = new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
+        } */
+
+        const metodos: FuncaoDeclaracao[] = [];
+        const propriedades: PropriedadeClasse[] = [];
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.FIM) && !this.estaNoFinal()) {
+            const identificador: SimboloInterface = this.consumir(
+                tiposDeSimbolos.IDENTIFICADOR,
+                'Esperado nome de propriedade ou método.'
+            );
+
+            if (this.simbolos[this.atual].tipo === tiposDeSimbolos.PARENTESE_ESQUERDO) {
+                // Método
+                const construtoMetodo = new Constante(identificador.hashArquivo, identificador);
+                metodos.push(this.declaracaoDeFuncaoOuMetodo(construtoMetodo));
+            } else {
+                // Propriedade
+                this.consumir(
+                    tiposDeSimbolos.DOIS_PONTOS,
+                    'Esperado dois-pontos após nome de propriedade em declaração de tipo.'
+                );
+
+                this.verificacaoTipo(
+                    this.simbolos[this.atual], 
+                    'Esperado tipo do argumento após dois-pontos, em definição de função.'
+                );
+
+                const tipoPropriedade = this.avancarEDevolverAnterior();
+                propriedades.push(
+                    new PropriedadeClasse(identificador, this.tiposPotigolParaDelegua[tipoPropriedade.lexema])
+                );
+            }
+        }
+
+        this.consumir(tiposDeSimbolos.FIM, "Esperado 'fim' após o escopo do tipo.");
+
+        // Depois de verificadas todas as propriedades anotadas com tipo, 
+        // Precisamos gerar um construtor com todas elas na ordem em que
+        // foram lidas.
+        const instrucoesConstrutor = [];
+        for (let propriedade of propriedades) {
+            instrucoesConstrutor.push(
+                new Expressao(
+                    new DefinirValor(
+                        propriedade.hashArquivo,
+                        propriedade.linha,
+                        new Isto(
+                            propriedade.hashArquivo,
+                            propriedade.linha,
+                            new Simbolo(
+                                tiposDeSimbolos.ISTO,
+                                'isto',
+                                undefined,
+                                simboloTipo.linha,
+                                simboloTipo.hashArquivo
+                            )
+                        ),
+                        propriedade.nome,
+                        new Variavel(
+                            propriedade.hashArquivo,
+                            propriedade.nome
+                        )
+                    )
+                )
+            );
+        }
+
+        const construtorConstruto = new FuncaoConstruto(
+            simboloTipo.hashArquivo, 
+            simboloTipo.linha,
+            propriedades.map(p => ({
+                abrangencia: 'padrao',
+                nome: p.nome
+            } as ParametroInterface)),
+            instrucoesConstrutor
+        );
+
+        const construtor = new FuncaoDeclaracao(
+            new Simbolo(
+                tiposDeSimbolos.CONSTRUTOR, 
+                'construtor', 
+                undefined, 
+                simboloTipo.hashArquivo,
+                simboloTipo.linha
+            ),
+            construtorConstruto,
+            undefined
+        );
+
+        metodos.unshift(construtor);
+        return new Classe(construto.simbolo, undefined, metodos, propriedades);
+    }
+
+    atribuir(): Construto {
+        const expressao = this.ou();
+
+        if (!this.estaNoFinal() && expressao instanceof Constante) {
+            // Atribuição constante.
+
+            switch (this.simbolos[this.atual].tipo) {
+                case tiposDeSimbolos.DOIS_PONTOS:
+                    return this.logicaAtribuicaoComDica(expressao);
+                case tiposDeSimbolos.IGUAL:
+                    this.avancarEDevolverAnterior();
+                    const valorAtribuicao = this.ou();
+                    return new Const(expressao.simbolo, valorAtribuicao);
+            }
+        }
+
+        return expressao;
+    }
+
+    /**
+     * Em Potigol, uma definição de função normalmente começa com um 
+     * identificador - que não é uma palavra reservada - seguido de parênteses.
+     * Este ponto de entrada verifica o símbolo atual e o próximo.
+     * 
+     * Diferentemente dos demais dialetos, verificamos logo de cara se
+     * temos uma definição ou chamada de função, isto porque definições
+     * nunca aparecem do lado direito de uma atribuição, a não ser que
+     * estejam entre parênteses (_currying_). 
+     * 
+     * Se o próximo símbolo for parênteses, ou é uma definiçao de função, 
+     * ou uma chamada de função.
+     */
+    expressaoOuDefinicaoFuncao() {
+        if (!this.estaNoFinal() && this.simbolos[this.atual].tipo === tiposDeSimbolos.IDENTIFICADOR) {
+            if (this.atual + 1 < this.simbolos.length) {
+                switch (this.simbolos[this.atual + 1].tipo) {
+                    case tiposDeSimbolos.PARENTESE_ESQUERDO:
+                        const construtoPrimario = this.primario();
+                        return this.declaracaoDeFuncaoOuMetodo(construtoPrimario as ConstanteOuVariavel);
+                }
+            }
+        }
+
+        return this.atribuir();
+    }
+
+    declaracao(): Declaracao | Declaracao[] | Construto | Construto[] | any {
+        const simboloAtual = this.simbolos[this.atual];
+        switch (simboloAtual.tipo) {
+            case tiposDeSimbolos.ENQUANTO:
+                return this.declaracaoEnquanto();
+            case tiposDeSimbolos.ESCOLHA:
+                return this.declaracaoEscolha();
+            case tiposDeSimbolos.ESCREVA:
+                return this.declaracaoEscreva();
+            case tiposDeSimbolos.IMPRIMA:
+                return this.declaracaoImprima();
+            case tiposDeSimbolos.PARA:
+                return this.declaracaoPara();
+            case tiposDeSimbolos.SE:
+                return this.declaracaoSe();
+            case tiposDeSimbolos.TIPO:
+                return this.declaracaoTipo();
+            case tiposDeSimbolos.VARIAVEL:
+                return this.declaracaoDeVariaveis();
+            default:
+                return this.expressaoOuDefinicaoFuncao();
+        }
+    }
+
+    analisar(retornoLexador: RetornoLexador, hashArquivo: number): RetornoAvaliadorSintatico {
+        this.microAvaliadorSintatico = new MicroAvaliadorSintaticoPotigol(hashArquivo);
+        this.erros = [];
+        this.atual = 0;
+        this.blocos = 0;
+        this.declaracoesAnteriores = {};
+
+        this.hashArquivo = hashArquivo || 0;
+        this.simbolos = retornoLexador?.simbolos || [];
+
+        let declaracoes: Declaracao[] = [];
+        while (!this.estaNoFinal()) {
+            const retornoDeclaracao = this.declaracao();
+            if (Array.isArray(retornoDeclaracao)) {
+                declaracoes = declaracoes.concat(retornoDeclaracao);
+            } else {
+                declaracoes.push(retornoDeclaracao as Declaracao);
+            }
+        }
+
+        return {
+            declaracoes: declaracoes,
+            erros: this.erros,
+        } as RetornoAvaliadorSintatico;
+    }
+}
diff --git a/fontes/avaliador-sintatico/dialetos/potigol/micro-avaliador-sintatico-potigol.ts b/fontes/avaliador-sintatico/dialetos/potigol/micro-avaliador-sintatico-potigol.ts
new file mode 100644
index 00000000..0107d12f
--- /dev/null
+++ b/fontes/avaliador-sintatico/dialetos/potigol/micro-avaliador-sintatico-potigol.ts
@@ -0,0 +1,87 @@
+import { Agrupamento, ConstanteOuVariavel, Construto, Literal, Logico } from "../../../construtos";
+import { Declaracao } from "../../../declaracoes";
+import { RetornoLexador, RetornoAvaliadorSintatico } from "../../../interfaces/retornos";
+import { MicroAvaliadorSintaticoBase } from "../../micro-avaliador-sintatico-base";
+import { SeletorTuplas, Tupla } from "../../../construtos/tuplas";
+import { SimboloInterface } from "../../../interfaces";
+
+import tiposDeSimbolos from '../../../tipos-de-simbolos/potigol';
+
+export class MicroAvaliadorSintaticoPotigol 
+    extends MicroAvaliadorSintaticoBase
+{
+    hashArquivo: number;
+
+    constructor(hashArquivo: number) {
+        super();
+        this.hashArquivo = hashArquivo;
+    }
+
+    primario(): Construto {
+        const simboloAtual = this.simbolos[this.atual];
+
+        switch (simboloAtual.tipo) {
+            case tiposDeSimbolos.PARENTESE_ESQUERDO:
+                this.avancarEDevolverAnterior();
+                const expressao = this.ou();
+                switch (this.simbolos[this.atual].tipo) {
+                    case tiposDeSimbolos.VIRGULA:
+                        // Tupla
+                        const argumentos = [expressao];
+                        while (this.simbolos[this.atual].tipo === tiposDeSimbolos.VIRGULA) {
+                            this.avancarEDevolverAnterior();
+                            argumentos.push(this.ou());
+                        }
+
+                        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                        return new SeletorTuplas(...argumentos) as Tupla;
+                    default:
+                        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                        return new Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
+                }
+
+            case tiposDeSimbolos.CARACTERE:
+            case tiposDeSimbolos.INTEIRO:
+            case tiposDeSimbolos.LOGICO:
+            case tiposDeSimbolos.REAL:
+            case tiposDeSimbolos.TEXTO:
+                const simboloLiteral: SimboloInterface = this.avancarEDevolverAnterior();
+                return new Literal(this.hashArquivo, Number(simboloLiteral.linha), simboloLiteral.literal);
+            case tiposDeSimbolos.FALSO:
+            case tiposDeSimbolos.VERDADEIRO:
+                const simboloVerdadeiroFalso: SimboloInterface = this.avancarEDevolverAnterior();
+                return new Literal(
+                    this.hashArquivo,
+                    Number(simboloVerdadeiroFalso.linha),
+                    simboloVerdadeiroFalso.tipo === tiposDeSimbolos.VERDADEIRO
+                );
+            case tiposDeSimbolos.VIRGULA:
+                return undefined;
+            default:
+                const simboloIdentificador: SimboloInterface = this.avancarEDevolverAnterior();
+                return new ConstanteOuVariavel(this.hashArquivo, simboloIdentificador);
+        }
+    }
+
+    chamar(): Construto {
+        return this.primario();
+    }
+
+    analisar(retornoLexador: RetornoLexador, linha: number): RetornoAvaliadorSintatico {
+        this.erros = [];
+        this.atual = 0;
+        this.linha = linha;
+
+        this.simbolos = retornoLexador?.simbolos || [];
+
+        const declaracoes: Declaracao[] = [];
+        while (this.atual < this.simbolos.length) {
+            declaracoes.push(this.declaracao() as Declaracao);
+        }
+
+        return {
+            declaracoes: declaracoes,
+            erros: this.erros,
+        } as RetornoAvaliadorSintatico;
+    }
+}
\ No newline at end of file
diff --git a/fontes/avaliador-sintatico/micro-avaliador-sintatico-base.ts b/fontes/avaliador-sintatico/micro-avaliador-sintatico-base.ts
new file mode 100644
index 00000000..2fd66ac0
--- /dev/null
+++ b/fontes/avaliador-sintatico/micro-avaliador-sintatico-base.ts
@@ -0,0 +1,173 @@
+import { Construto, Unario, Binario, Logico } from "../construtos";
+import { Declaracao } from "../declaracoes";
+import { SimboloInterface } from "../interfaces";
+import { RetornoAvaliadorSintatico, RetornoLexador } from "../interfaces/retornos";
+import { ErroAvaliadorSintatico } from "./erro-avaliador-sintatico";
+
+import tiposDeSimbolos from '../tipos-de-simbolos/comum';
+
+export abstract class MicroAvaliadorSintaticoBase {
+    simbolos: SimboloInterface[];
+    erros: ErroAvaliadorSintatico[];
+    atual: number;
+    linha: number;
+
+    avancarEDevolverAnterior(): SimboloInterface {
+        if (this.atual < this.simbolos.length) this.atual += 1;
+        return this.simbolos[this.atual - 1];
+    }
+
+    verificarTipoSimboloAtual(tipo: string): boolean {
+        if (this.atual === this.simbolos.length) return false;
+        return this.simbolos[this.atual].tipo === tipo;
+    }
+
+    verificarSeSimboloAtualEIgualA(...argumentos: string[]): boolean {
+        for (let i = 0; i < argumentos.length; i++) {
+            const tipoAtual = argumentos[i];
+            if (this.verificarTipoSimboloAtual(tipoAtual)) {
+                this.avancarEDevolverAnterior();
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    erro(simbolo: SimboloInterface, mensagemDeErro: string): ErroAvaliadorSintatico {
+        const excecao = new ErroAvaliadorSintatico(simbolo, mensagemDeErro);
+        this.erros.push(excecao);
+        return excecao;
+    }
+
+    consumir(tipo: string, mensagemDeErro: string): SimboloInterface {
+        if (this.verificarTipoSimboloAtual(tipo)) return this.avancarEDevolverAnterior();
+        throw this.erro(this.simbolos[this.atual], mensagemDeErro);
+    }
+
+    abstract chamar(): Construto;
+
+    unario(): Construto {
+        if (
+            this.verificarSeSimboloAtualEIgualA(
+                tiposDeSimbolos.NEGACAO,
+                tiposDeSimbolos.SUBTRACAO
+            )
+        ) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.unario();
+            return new Unario(-1, operador, direito, 'ANTES');
+        }
+
+        return this.chamar();
+    }
+
+    exponenciacao(): Construto {
+        let expressao = this.unario();
+
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.EXPONENCIACAO)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.unario();
+            expressao = new Binario(-1, expressao, operador, direito);
+        }
+
+        return expressao;
+    }
+
+    multiplicar(): Construto {
+        let expressao = this.exponenciacao();
+
+        while (
+            this.verificarSeSimboloAtualEIgualA(
+                tiposDeSimbolos.DIVISAO,
+                tiposDeSimbolos.DIVISAO_INTEIRA,
+                tiposDeSimbolos.MODULO,
+                tiposDeSimbolos.MULTIPLICACAO
+            )
+        ) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.exponenciacao();
+            expressao = new Binario(-1, expressao, operador, direito);
+        }
+
+        return expressao;
+    }
+
+    adicaoOuSubtracao(): Construto {
+        let expressao = this.multiplicar();
+
+        while (
+            this.verificarSeSimboloAtualEIgualA(
+                tiposDeSimbolos.SUBTRACAO,
+                tiposDeSimbolos.ADICAO
+            )
+        ) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.multiplicar();
+            expressao = new Binario(-1, expressao, operador, direito);
+        }
+
+        return expressao;
+    }
+
+    comparar(): Construto {
+        let expressao = this.adicaoOuSubtracao();
+
+        while (
+            this.verificarSeSimboloAtualEIgualA(
+                tiposDeSimbolos.MAIOR,
+                tiposDeSimbolos.MAIOR_IGUAL,
+                tiposDeSimbolos.MENOR,
+                tiposDeSimbolos.MENOR_IGUAL
+            )
+        ) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.adicaoOuSubtracao();
+            expressao = new Binario(-1, expressao, operador, direito);
+        }
+
+        return expressao;
+    }
+
+    comparacaoIgualdade(): Construto {
+        let expressao = this.comparar();
+
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DIFERENTE, tiposDeSimbolos.IGUAL_IGUAL)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.comparar();
+            expressao = new Binario(-1, expressao, operador, direito);
+        }
+
+        return expressao;
+    }
+
+    e(): Construto {
+        let expressao = this.comparacaoIgualdade();
+
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.E)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.comparacaoIgualdade();
+            expressao = new Logico(-1, expressao, operador, direito);
+        }
+
+        return expressao;
+    }
+
+    ou(): Construto {
+        let expressao = this.e();
+
+        while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.OU)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.e();
+            expressao = new Logico(-1, expressao, operador, direito);
+        }
+
+        return expressao;
+    }
+
+    declaracao(): Declaracao | Construto {
+        return this.ou();
+    }
+
+    abstract analisar(retornoLexador: RetornoLexador, linha: number): RetornoAvaliadorSintatico;
+}
\ No newline at end of file
diff --git a/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts b/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts
index e098379f..decd9504 100644
--- a/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/micro-avaliador-sintatico.ts
@@ -5,15 +5,16 @@ import { RetornoAvaliadorSintatico, RetornoLexador } from "../interfaces/retorno
 import { ErroAvaliadorSintatico } from "./erro-avaliador-sintatico";
 
 import tiposDeSimbolos from "../tipos-de-simbolos/microgramaticas/delegua";
+import { MicroAvaliadorSintaticoBase } from "./micro-avaliador-sintatico-base";
 
 /**
  * O MicroAvaliadorSintatico funciona apenas dentro de interpolações de texto. 
  */
-export class MicroAvaliadorSintatico {
-    simbolos: SimboloInterface[];
-    erros: ErroAvaliadorSintatico[];
-    atual: number;
-    linha: number;
+export class MicroAvaliadorSintatico extends MicroAvaliadorSintaticoBase {
+    // simbolos: SimboloInterface[];
+    // erros: ErroAvaliadorSintatico[];
+    // atual: number;
+    // linha: number;
 
     avancarEDevolverAnterior(): SimboloInterface {
         if (this.atual < this.simbolos.length) this.atual += 1;
@@ -356,10 +357,6 @@ export class MicroAvaliadorSintatico {
     }
 
     declaracao(): Declaracao | Construto {
-        /* switch (this.simbolos[this.atual].tipo) {
-
-        } */
-
         return this.ou();
     }
 
diff --git a/fontes/bibliotecas/dialetos/potigol/biblioteca-global.ts b/fontes/bibliotecas/dialetos/potigol/biblioteca-global.ts
new file mode 100644
index 00000000..256c454b
--- /dev/null
+++ b/fontes/bibliotecas/dialetos/potigol/biblioteca-global.ts
@@ -0,0 +1,92 @@
+import { FuncaoPadrao } from "../../../estruturas";
+import { PilhaEscoposExecucaoInterface } from "../../../interfaces/pilha-escopos-execucao-interface";
+import { InterpretadorBase } from "../../../interpretador";
+
+export function registrarBibliotecaGlobalPotigol(
+    interpretador: InterpretadorBase, 
+    pilhaEscoposExecucao: PilhaEscoposExecucaoInterface) 
+{
+    pilhaEscoposExecucao.definirVariavel(
+        'abs', 
+        new FuncaoPadrao(1, function(valor: number) {
+            return Math.abs(valor);
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'aleatório',
+        new FuncaoPadrao(0, function() {
+            return Math.random();
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'arccos', 
+        new FuncaoPadrao(1, function(valor: number) {
+            return Math.acos(valor);
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'arcsen',
+        new FuncaoPadrao(1, function(valor: number) {
+            return Math.asin(valor);
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'arctg',
+        new FuncaoPadrao(1, function(valor: number) {
+            return Math.atan(valor);
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'cos',
+        new FuncaoPadrao(1, function(valor: number) {
+            return Math.cos(valor);
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'log',
+        new FuncaoPadrao(1, function(valor: number) {
+            return Math.log(valor);
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'log10',
+        new FuncaoPadrao(1, function(valor: number) {
+            return Math.log10(valor);
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'pi',
+        new FuncaoPadrao(0, function() {
+            return Math.PI;
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'raiz',
+        new FuncaoPadrao(1, function(valor: number) {
+            return Math.sqrt(valor);
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'sen',
+        new FuncaoPadrao(1, function(valor: number) {
+            return Math.sin(valor);
+        })
+    );
+
+    pilhaEscoposExecucao.definirVariavel(
+        'tg',
+        new FuncaoPadrao(1, function(valor: number) {
+            return Math.tan(valor);
+        })
+    );
+}
\ No newline at end of file
diff --git a/fontes/bibliotecas/dialetos/potigol/primitivas-numero.ts b/fontes/bibliotecas/dialetos/potigol/primitivas-numero.ts
new file mode 100644
index 00000000..e399112c
--- /dev/null
+++ b/fontes/bibliotecas/dialetos/potigol/primitivas-numero.ts
@@ -0,0 +1,12 @@
+import { VisitanteComumInterface } from "../../../interfaces";
+
+export default {
+    arredonde: (interpretador: VisitanteComumInterface, numero: number): Promise<any> => Promise.resolve(Math.ceil(numero)),
+    caractere: (interpretador: VisitanteComumInterface, numero: number): Promise<any> => Promise.resolve(String.fromCharCode(numero)),
+    inteiro: (interpretador: VisitanteComumInterface, numero: number): Promise<any> => Promise.resolve(Math.floor(numero)),
+    qual_tipo: (interpretador: VisitanteComumInterface, numero: number): Promise<any> => Promise.resolve(Math.floor(numero) === numero ? "Inteiro" : "Real"),
+    piso: (interpretador: VisitanteComumInterface, numero: number): Promise<any> => Promise.resolve(Math.floor(numero)),
+    real: (interpretador: VisitanteComumInterface, numero: number): Promise<any> => Promise.resolve(numero),
+    teto: (interpretador: VisitanteComumInterface, numero: number): Promise<any> => Promise.resolve(Math.ceil(numero)),
+    texto: (interpretador: VisitanteComumInterface, numero: number): Promise<any> => Promise.resolve(String(numero)),
+}
\ No newline at end of file
diff --git a/fontes/bibliotecas/dialetos/potigol/primitivas-texto.ts b/fontes/bibliotecas/dialetos/potigol/primitivas-texto.ts
new file mode 100644
index 00000000..9571548f
--- /dev/null
+++ b/fontes/bibliotecas/dialetos/potigol/primitivas-texto.ts
@@ -0,0 +1,36 @@
+import { VisitanteComumInterface } from "../../../interfaces";
+
+export default {
+    cabeça: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto[0]),
+    cauda: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.substring(1)),
+    contém: (interpretador: VisitanteComumInterface, texto: string, caractere: string): Promise<any> => Promise.resolve(texto.includes(caractere)),
+    descarte: (interpretador: VisitanteComumInterface, texto: string, posicao: number): Promise<any> => Promise.resolve(texto.substring(posicao)),
+    descarte_enquanto: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(""),
+    divida: (interpretador: VisitanteComumInterface, texto: string, separador: string = ' '): Promise<any> => Promise.resolve(texto.split(separador)),
+    injete: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(""),
+    insira: (interpretador: VisitanteComumInterface, texto: string, posicao: number, elemento: string): Promise<any> => {
+        let vetor = texto.split('');
+        vetor.splice(posicao - 1, 0, elemento);
+        return Promise.resolve(vetor.join(''));
+    },
+    inteiro: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(Math.floor(Number(texto))),
+    inverta: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.split('').reduce((texto, caracter) => texto = caracter + texto, '')),
+    junte: (interpretador: VisitanteComumInterface, texto: string, separador: string): Promise<any> => Promise.resolve(texto.split('').join(separador)),
+    lista: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.split('')),
+    maiúsculo: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.toUpperCase()),
+    minúsculo: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.toLowerCase()),
+    ordene: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.split('').sort().join('')),
+    qual_tipo: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve("Texto"),
+    pegue: (interpretador: VisitanteComumInterface, texto: string, caracteres: number): Promise<any> => Promise.resolve(texto.substring(0, caracteres)),
+    pegue_enquanto: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(""),
+    posição: (interpretador: VisitanteComumInterface, texto: string, caractere: string): Promise<any> => Promise.resolve(texto.indexOf(caractere) + 1),
+    real: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(Number(texto)),
+    remova: (interpretador: VisitanteComumInterface, texto: string, posicao: number): Promise<any> => {
+        let vetor = texto.split('');
+        vetor.splice(posicao - 1, 1);
+        return Promise.resolve(vetor.join(''));
+    },
+    selecione: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(""),
+    tamanho: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.length),
+    último: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.length > 0 ? texto[texto.length - 1] : ''),
+}
\ No newline at end of file
diff --git a/fontes/bibliotecas/dialetos/potigol/primitivas-vetor.ts b/fontes/bibliotecas/dialetos/potigol/primitivas-vetor.ts
new file mode 100644
index 00000000..56af2e63
--- /dev/null
+++ b/fontes/bibliotecas/dialetos/potigol/primitivas-vetor.ts
@@ -0,0 +1,47 @@
+import { VisitanteComumInterface } from "../../../interfaces";
+
+export default {
+    cabeça: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(vetor[0]),
+    cauda: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => {
+        let copia = [...vetor];
+        copia.splice(0, 1);
+        return Promise.resolve(copia);
+    },
+    contém: (interpretador: VisitanteComumInterface, vetor: Array<any>, elemento: any): Promise<any> => Promise.resolve(vetor.includes(elemento)),
+    descarte: (interpretador: VisitanteComumInterface, vetor: Array<any>, elementos: number): Promise<any> => {
+        let copia = [...vetor];
+        copia.splice(0, elementos);
+        return Promise.resolve(copia);
+    },
+    descarte_enquanto: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(),
+    divida_quando: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(),
+    imutável: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(),
+    injete: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(),
+    insira: (interpretador: VisitanteComumInterface, vetor: Array<any>, posicao: number, elemento: string): Promise<any> => {
+        let copia = [...vetor];
+        copia.splice(posicao - 1, 0, elemento);
+        return Promise.resolve(copia);
+    },
+    inverta: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => {
+        let copia = [];
+        for (let elemento of vetor) {
+            copia.unshift(elemento);
+        }
+        return Promise.resolve(copia);
+    },
+    junte: (interpretador: VisitanteComumInterface, vetor: Array<any>, separador: string): Promise<any> => Promise.resolve(vetor.join(separador)),
+    mapeie: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(),
+    ordene: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(vetor.sort((a, b) => a - b)),
+    pegue: (interpretador: VisitanteComumInterface, vetor: Array<any>, elementos: number): Promise<any> => Promise.resolve(vetor.slice(0, elementos)),
+    pegue_enquanto: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(),
+    posição: (interpretador: VisitanteComumInterface, vetor: Array<any>, elemento: any): Promise<any> => Promise.resolve(vetor.indexOf(elemento) + 1),
+    remova: (interpretador: VisitanteComumInterface, vetor: Array<any>, posicao: number): Promise<any> => {
+        let copia = [...vetor];
+        copia.splice(posicao - 1, 1);
+        return Promise.resolve(copia);
+    },
+    selecione: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(),
+    tamanho: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(vetor.length),
+    último: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(vetor.length > 0 ? vetor[vetor.length - 1] : undefined),
+    vazia: (interpretador: VisitanteComumInterface, vetor: Array<any>): Promise<any> => Promise.resolve(vetor.length === 0),
+}
\ No newline at end of file
diff --git a/fontes/bibliotecas/primitivas-texto.ts b/fontes/bibliotecas/primitivas-texto.ts
index e41f680f..81ed222e 100644
--- a/fontes/bibliotecas/primitivas-texto.ts
+++ b/fontes/bibliotecas/primitivas-texto.ts
@@ -8,6 +8,7 @@ export default {
     dividir: (interpretador: VisitanteComumInterface, texto: string, divisor: any, limite: number): Promise<any> => Promise.resolve(texto.split(divisor || ' ', limite)),
     fatiar: (interpretador: VisitanteComumInterface, texto: string, inicio: number, fim: number): Promise<any> => Promise.resolve(texto.slice(inicio, fim)),
     inclui: (interpretador: VisitanteComumInterface, texto: string, elemento: any): Promise<any> => Promise.resolve(texto.includes(elemento)),
+    inverter: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.split('').reduce((texto, caracter) => texto = caracter + texto, '')),
     maiusculo: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.toUpperCase()),
     minusculo: (interpretador: VisitanteComumInterface, texto: string): Promise<any> => Promise.resolve(texto.toLowerCase()),
     substituir: (interpretador: VisitanteComumInterface, texto: string, elemento: string, substituto: string): Promise<any> => Promise.resolve(texto.replace(elemento, substituto)),
diff --git a/fontes/construtos/README.md b/fontes/construtos/README.md
new file mode 100644
index 00000000..d0be6954
--- /dev/null
+++ b/fontes/construtos/README.md
@@ -0,0 +1,5 @@
+# Construtos
+
+Construtos são estruturas da linguagem que não executam por si só. Normalmente requerem estar dentro de uma declaração. Por padrão, `Expressao` pode ser usada para avaliar um ou mais construtos.
+
+Alguns construtos nunca vão para a interpretação, tradução ou avaliação semântica. Por exemplo, `ConstanteOuVariavel`, emitido pela avaliação primária do avaliador sintático quando não é possível determinar se o símbolo resolve como uma constante, variável, declaração ou chamada de função ou chamada de construtor de tipo. 
\ No newline at end of file
diff --git a/fontes/construtos/constante-ou-variavel.ts b/fontes/construtos/constante-ou-variavel.ts
new file mode 100644
index 00000000..a824eef1
--- /dev/null
+++ b/fontes/construtos/constante-ou-variavel.ts
@@ -0,0 +1,35 @@
+import { VisitanteComumInterface, SimboloInterface, VariavelInterface } from '../interfaces';
+import { Construto } from './construto';
+
+/**
+ * Este construto existe para alguns dialetos, como Potigol, onde
+ * não é possível definir se um construto é constante, variável, 
+ * identificador de função, tipo ou classe no momento da avaliação
+ * primária. 
+ * 
+ * Durante o restante da avaliação sintática, esse construto deve **obrigatoriamente**
+ * resolver para `Constante`, `Variavel` ou algum construto de chamada/declaração de
+ * função.
+ */
+export class ConstanteOuVariavel implements Construto {
+    linha: number;
+    hashArquivo: number;
+
+    simbolo: SimboloInterface;
+
+    constructor(hashArquivo: number, simbolo: SimboloInterface) {
+        this.linha = Number(simbolo.linha);
+        this.hashArquivo = hashArquivo;
+
+        this.simbolo = simbolo;
+    }
+
+    async aceitar(visitante: VisitanteComumInterface): Promise<VariavelInterface> {
+        return Promise.reject(
+            new Error(
+                'Este método não deveria ser chamado. ' + 
+                'O construto deve resolver como constante ou variável ainda na avaliação sintática.'
+            )
+        );
+    }
+}
diff --git a/fontes/construtos/constante.ts b/fontes/construtos/constante.ts
index 558dcf57..a5228347 100644
--- a/fontes/construtos/constante.ts
+++ b/fontes/construtos/constante.ts
@@ -18,4 +18,3 @@ export class Constante implements Construto {
         return Promise.resolve(visitante.visitarExpressaoDeVariavel(this));
     }
 }
-
diff --git a/fontes/construtos/index.ts b/fontes/construtos/index.ts
index 640ff89e..804b0689 100644
--- a/fontes/construtos/index.ts
+++ b/fontes/construtos/index.ts
@@ -3,6 +3,7 @@ export * from './atribuir';
 export * from './binario';
 export * from './chamada';
 export * from './constante';
+export * from './constante-ou-variavel';
 export * from './definir-valor';
 export * from './dicionario';
 export * from './construto';
diff --git a/fontes/construtos/tuplas/deceto.ts b/fontes/construtos/tuplas/deceto.ts
new file mode 100644
index 00000000..896fcfcc
--- /dev/null
+++ b/fontes/construtos/tuplas/deceto.ts
@@ -0,0 +1,46 @@
+import { Tupla } from "./tupla";
+
+export class Deceto extends Tupla {
+    primeiro: any;
+    segundo: any;
+    terceiro: any;
+    quarto: any;
+    quinto: any;
+    sexto: any;
+    setimo: any;
+    oitavo: any;
+    nono: any;
+    decimo: any;
+
+    constructor(primeiro: any, segundo: any, terceiro: any, quarto: any, quinto: any, sexto: any, 
+        setimo: any, oitavo: any, nono: any, decimo: any
+    ) {
+        super();
+        this.primeiro = primeiro;
+        this.segundo = segundo;
+        this.terceiro = terceiro;
+        this.quarto = quarto;
+        this.quinto = quinto;
+        this.sexto = sexto;
+        this.setimo = setimo;
+        this.oitavo = oitavo;
+        this.nono = nono;
+        this.decimo = decimo;
+    }
+
+    get sétimo() {
+        return this.setimo;
+    }
+
+    set sétimo(valor: any) {
+        this.setimo = valor;
+    }
+
+    get décimo() {
+        return this.decimo;
+    }
+
+    set décimo(valor: any) {
+        this.decimo = valor;
+    }
+}
diff --git a/fontes/construtos/tuplas/dupla.ts b/fontes/construtos/tuplas/dupla.ts
new file mode 100644
index 00000000..835ae99f
--- /dev/null
+++ b/fontes/construtos/tuplas/dupla.ts
@@ -0,0 +1,12 @@
+import { Tupla } from "./tupla";
+
+export class Dupla extends Tupla {
+    primeiro: any;
+    segundo: any;
+
+    constructor(primeiro: any, segundo: any) {
+        super();
+        this.primeiro = primeiro;
+        this.segundo = segundo;
+    }
+}
diff --git a/fontes/construtos/tuplas/index.ts b/fontes/construtos/tuplas/index.ts
new file mode 100644
index 00000000..bc1b7a1c
--- /dev/null
+++ b/fontes/construtos/tuplas/index.ts
@@ -0,0 +1,104 @@
+import { Deceto } from './deceto';
+import { Dupla } from './dupla';
+import { Noneto } from './noneto';
+import { Octeto } from './octeto';
+import { Quarteto } from './quarteto';
+import { Quinteto } from './quinteto';
+import { Septeto } from './septeto';
+import { Sexteto } from './sexteto';
+import { Trio } from './trio';
+
+export * from './deceto';
+export * from './dupla';
+export * from './noneto';
+export * from './octeto';
+export * from './quarteto';
+export * from './quinteto';
+export * from './septeto';
+export * from './sexteto';
+export * from './trio';
+export * from './tupla';
+
+export class SeletorTuplas {
+    constructor(...argumentos: any[]) {
+        if (argumentos.length > 10) {
+            throw new Error("Tuplas com mais de 10 elementos não são suportadas.");
+        }
+
+        if (argumentos.length < 2) {
+            throw new Error("Tuplas devem ter no mínimo 2 elementos.");
+        }
+
+        switch (argumentos.length) {
+            case 2:
+                return new Dupla(argumentos[0], argumentos[1]);
+            case 3:
+                return new Trio(argumentos[0], argumentos[1], argumentos[2]);
+            case 4:
+                return new Quarteto(argumentos[0], argumentos[1], argumentos[2], argumentos[3]);
+            case 5:
+                return new Quinteto(
+                    argumentos[0], 
+                    argumentos[1], 
+                    argumentos[2], 
+                    argumentos[3],
+                    argumentos[4]
+                );
+            case 6:
+                return new Sexteto(
+                    argumentos[0], 
+                    argumentos[1], 
+                    argumentos[2], 
+                    argumentos[3],
+                    argumentos[4],
+                    argumentos[5]
+                );
+            case 7:
+                return new Septeto(
+                    argumentos[0], 
+                    argumentos[1], 
+                    argumentos[2], 
+                    argumentos[3],
+                    argumentos[4],
+                    argumentos[5],
+                    argumentos[6]
+                );
+            case 8:
+                return new Octeto(
+                    argumentos[0], 
+                    argumentos[1], 
+                    argumentos[2], 
+                    argumentos[3],
+                    argumentos[4],
+                    argumentos[5],
+                    argumentos[6],
+                    argumentos[7]
+                );
+            case 9:
+                return new Noneto(
+                    argumentos[0], 
+                    argumentos[1], 
+                    argumentos[2], 
+                    argumentos[3],
+                    argumentos[4],
+                    argumentos[5],
+                    argumentos[6],
+                    argumentos[7],
+                    argumentos[8]
+                );
+            case 10:
+                return new Deceto(
+                    argumentos[0], 
+                    argumentos[1], 
+                    argumentos[2], 
+                    argumentos[3],
+                    argumentos[4],
+                    argumentos[5],
+                    argumentos[6],
+                    argumentos[7],
+                    argumentos[8],
+                    argumentos[9]
+                );
+        }
+    }
+}
\ No newline at end of file
diff --git a/fontes/construtos/tuplas/noneto.ts b/fontes/construtos/tuplas/noneto.ts
new file mode 100644
index 00000000..aaa22046
--- /dev/null
+++ b/fontes/construtos/tuplas/noneto.ts
@@ -0,0 +1,36 @@
+import { Tupla } from "./tupla";
+
+export class Noneto extends Tupla {
+    primeiro: any;
+    segundo: any;
+    terceiro: any;
+    quarto: any;
+    quinto: any;
+    sexto: any;
+    setimo: any;
+    oitavo: any;
+    nono: any;
+
+    constructor(primeiro: any, segundo: any, terceiro: any, quarto: any, quinto: any, sexto: any, 
+        setimo: any, oitavo: any, nono: any
+    ) {
+        super();
+        this.primeiro = primeiro;
+        this.segundo = segundo;
+        this.terceiro = terceiro;
+        this.quarto = quarto;
+        this.quinto = quinto;
+        this.sexto = sexto;
+        this.setimo = setimo;
+        this.oitavo = oitavo;
+        this.nono = nono;
+    }
+
+    get sétimo() {
+        return this.setimo;
+    }
+
+    set sétimo(valor: any) {
+        this.setimo = valor;
+    }
+}
diff --git a/fontes/construtos/tuplas/octeto.ts b/fontes/construtos/tuplas/octeto.ts
new file mode 100644
index 00000000..c1a68f88
--- /dev/null
+++ b/fontes/construtos/tuplas/octeto.ts
@@ -0,0 +1,34 @@
+import { Tupla } from "./tupla";
+
+export class Octeto extends Tupla {
+    primeiro: any;
+    segundo: any;
+    terceiro: any;
+    quarto: any;
+    quinto: any;
+    sexto: any;
+    setimo: any;
+    oitavo: any;
+
+    constructor(primeiro: any, segundo: any, terceiro: any, quarto: any, quinto: any, sexto: any, 
+        setimo: any, oitavo: any
+    ) {
+        super();
+        this.primeiro = primeiro;
+        this.segundo = segundo;
+        this.terceiro = terceiro;
+        this.quarto = quarto;
+        this.quinto = quinto;
+        this.sexto = sexto;
+        this.setimo = setimo;
+        this.oitavo = oitavo;
+    }
+
+    get sétimo() {
+        return this.setimo;
+    }
+
+    set sétimo(valor: any) {
+        this.setimo = valor;
+    }
+}
diff --git a/fontes/construtos/tuplas/quarteto.ts b/fontes/construtos/tuplas/quarteto.ts
new file mode 100644
index 00000000..ce2dc25a
--- /dev/null
+++ b/fontes/construtos/tuplas/quarteto.ts
@@ -0,0 +1,16 @@
+import { Tupla } from "./tupla";
+
+export class Quarteto extends Tupla {
+    primeiro: any;
+    segundo: any;
+    terceiro: any;
+    quarto: any;
+
+    constructor(primeiro: any, segundo: any, terceiro: any, quarto: any) {
+        super();
+        this.primeiro = primeiro;
+        this.segundo = segundo;
+        this.terceiro = terceiro;
+        this.quarto = quarto;
+    }
+}
diff --git a/fontes/construtos/tuplas/quinteto.ts b/fontes/construtos/tuplas/quinteto.ts
new file mode 100644
index 00000000..9e557a88
--- /dev/null
+++ b/fontes/construtos/tuplas/quinteto.ts
@@ -0,0 +1,18 @@
+import { Tupla } from "./tupla";
+
+export class Quinteto extends Tupla {
+    primeiro: any;
+    segundo: any;
+    terceiro: any;
+    quarto: any;
+    quinto: any;
+
+    constructor(primeiro: any, segundo: any, terceiro: any, quarto: any, quinto: any) {
+        super();
+        this.primeiro = primeiro;
+        this.segundo = segundo;
+        this.terceiro = terceiro;
+        this.quarto = quarto;
+        this.quinto = quinto;
+    }
+}
diff --git a/fontes/construtos/tuplas/septeto.ts b/fontes/construtos/tuplas/septeto.ts
new file mode 100644
index 00000000..72ff3795
--- /dev/null
+++ b/fontes/construtos/tuplas/septeto.ts
@@ -0,0 +1,30 @@
+import { Tupla } from "./tupla";
+
+export class Septeto extends Tupla {
+    primeiro: any;
+    segundo: any;
+    terceiro: any;
+    quarto: any;
+    quinto: any;
+    sexto: any;
+    setimo: any;
+
+    constructor(primeiro: any, segundo: any, terceiro: any, quarto: any, quinto: any, sexto: any, setimo: any) {
+        super();
+        this.primeiro = primeiro;
+        this.segundo = segundo;
+        this.terceiro = terceiro;
+        this.quarto = quarto;
+        this.quinto = quinto;
+        this.sexto = sexto;
+        this.setimo = setimo;
+    }
+
+    get sétimo() {
+        return this.setimo;
+    }
+
+    set sétimo(valor: any) {
+        this.setimo = valor;
+    }
+}
diff --git a/fontes/construtos/tuplas/sexteto.ts b/fontes/construtos/tuplas/sexteto.ts
new file mode 100644
index 00000000..1116bfab
--- /dev/null
+++ b/fontes/construtos/tuplas/sexteto.ts
@@ -0,0 +1,20 @@
+import { Tupla } from "./tupla";
+
+export class Sexteto extends Tupla {
+    primeiro: any;
+    segundo: any;
+    terceiro: any;
+    quarto: any;
+    quinto: any;
+    sexto: any;
+
+    constructor(primeiro: any, segundo: any, terceiro: any, quarto: any, quinto: any, sexto: any) {
+        super();
+        this.primeiro = primeiro;
+        this.segundo = segundo;
+        this.terceiro = terceiro;
+        this.quarto = quarto;
+        this.quinto = quinto;
+        this.sexto = sexto;
+    }
+}
diff --git a/fontes/construtos/tuplas/trio.ts b/fontes/construtos/tuplas/trio.ts
new file mode 100644
index 00000000..96405af3
--- /dev/null
+++ b/fontes/construtos/tuplas/trio.ts
@@ -0,0 +1,14 @@
+import { Tupla } from "./tupla";
+
+export class Trio extends Tupla {
+    primeiro: any;
+    segundo: any;
+    terceiro: any;
+
+    constructor(primeiro: any, segundo: any, terceiro: any) {
+        super();
+        this.primeiro = primeiro;
+        this.segundo = segundo;
+        this.terceiro = terceiro;
+    }
+}
diff --git a/fontes/construtos/tuplas/tupla.ts b/fontes/construtos/tuplas/tupla.ts
new file mode 100644
index 00000000..4811bb63
--- /dev/null
+++ b/fontes/construtos/tuplas/tupla.ts
@@ -0,0 +1,13 @@
+import { VisitanteComumInterface } from "../../interfaces";
+import { Construto } from "../construto";
+
+export abstract class Tupla implements Construto {
+    linha: number;
+    hashArquivo: number;
+    valor?: any;
+
+    async aceitar(visitante: VisitanteComumInterface): Promise<any> {
+        throw new Error("Method not implemented.");
+    }
+    
+}
\ No newline at end of file
diff --git a/fontes/declaracoes/classe.ts b/fontes/declaracoes/classe.ts
index ee7acf92..7f086547 100644
--- a/fontes/declaracoes/classe.ts
+++ b/fontes/declaracoes/classe.ts
@@ -1,16 +1,25 @@
 import { VisitanteComumInterface, SimboloInterface } from '../interfaces';
 import { Declaracao } from './declaracao';
+import { FuncaoDeclaracao } from './funcao';
+import { PropriedadeClasse } from './propriedade-classe';
 
 export class Classe extends Declaracao {
     simbolo: SimboloInterface;
     superClasse: any;
-    metodos: any;
+    metodos: FuncaoDeclaracao[];
+    propriedades: PropriedadeClasse[];
 
-    constructor(simbolo: SimboloInterface, superClasse: any, metodos: any) {
+    constructor(
+        simbolo: SimboloInterface, 
+        superClasse: any, 
+        metodos: FuncaoDeclaracao[], 
+        propriedades: PropriedadeClasse[] = []
+    ) {
         super(Number(simbolo.linha), simbolo.hashArquivo);
         this.simbolo = simbolo;
         this.superClasse = superClasse;
         this.metodos = metodos;
+        this.propriedades = propriedades;
     }
 
     async aceitar(visitante: VisitanteComumInterface): Promise<any> {
diff --git a/fontes/declaracoes/const.ts b/fontes/declaracoes/const.ts
index ff89486a..a17b760a 100644
--- a/fontes/declaracoes/const.ts
+++ b/fontes/declaracoes/const.ts
@@ -9,7 +9,7 @@ import { Declaracao } from './declaracao';
 export class Const extends Declaracao {
     simbolo: SimboloInterface;
     inicializador: Construto;
-    tipo: TiposDadosInterface
+    tipo: TiposDadosInterface;
 
     constructor(
         simbolo: SimboloInterface,
diff --git a/fontes/declaracoes/index.ts b/fontes/declaracoes/index.ts
index 387e4976..6321579c 100644
--- a/fontes/declaracoes/index.ts
+++ b/fontes/declaracoes/index.ts
@@ -15,6 +15,7 @@ export * from './importar';
 export * from './leia';
 export * from './para';
 export * from './para-cada';
+export * from './propriedade-classe';
 export * from './sustar';
 export * from './retorna';
 export * from './se';
diff --git a/fontes/declaracoes/propriedade-classe.ts b/fontes/declaracoes/propriedade-classe.ts
new file mode 100644
index 00000000..69309867
--- /dev/null
+++ b/fontes/declaracoes/propriedade-classe.ts
@@ -0,0 +1,17 @@
+import { SimboloInterface, VisitanteComumInterface } from "../interfaces";
+import { Declaracao } from "./declaracao";
+
+export class PropriedadeClasse extends Declaracao {
+    nome: SimboloInterface;
+    tipo?: string;
+
+    constructor(nome: SimboloInterface, tipo?: string) {
+        super(Number(nome.linha), nome.hashArquivo);
+        this.nome = nome;
+        this.tipo = tipo;
+    }
+
+    async aceitar(visitante: VisitanteComumInterface): Promise<any> {
+        return Promise.reject(new Error('Não utilizado por enquanto.'));
+    }
+}
diff --git a/fontes/estruturas/chamavel.ts b/fontes/estruturas/chamavel.ts
index 4dfd360e..ad2dbc4a 100644
--- a/fontes/estruturas/chamavel.ts
+++ b/fontes/estruturas/chamavel.ts
@@ -5,7 +5,7 @@ export class Chamavel {
         return this.valorAridade;
     }
 
-    chamar(interpretador?: any, argumentos?: any, simbolo?: any): any {
-        throw new Error('Este método não deveria ser chamado.');
+    async chamar(interpretador?: any, argumentos?: any, simbolo?: any): Promise<any> {
+        return Promise.reject(new Error('Este método não deveria ser chamado.'));
     }
 }
diff --git a/fontes/estruturas/delegua-classe.ts b/fontes/estruturas/delegua-classe.ts
index 65307543..176c2a40 100644
--- a/fontes/estruturas/delegua-classe.ts
+++ b/fontes/estruturas/delegua-classe.ts
@@ -1,3 +1,4 @@
+import { PropriedadeClasse } from '../declaracoes';
 import { VisitanteComumInterface } from '../interfaces'
 import { Chamavel } from './chamavel';
 import { DeleguaFuncao } from './delegua-funcao';
@@ -7,12 +8,14 @@ export class DeleguaClasse extends Chamavel {
     nome: string;
     superClasse: DeleguaClasse;
     metodos: { [nome: string]: DeleguaFuncao };
+    propriedades: PropriedadeClasse[]
 
-    constructor(nome?: string, superClasse?: any, metodos?: any) {
+    constructor(nome?: string, superClasse?: any, metodos?: any, propriedades?: PropriedadeClasse[]) {
         super();
         this.nome = nome;
         this.superClasse = superClasse;
-        this.metodos = metodos;
+        this.metodos = metodos || {};
+        this.propriedades = propriedades || [];
     }
 
     encontrarMetodo(nome: string): DeleguaFuncao {
@@ -20,13 +23,25 @@ export class DeleguaClasse extends Chamavel {
             return this.metodos[nome];
         }
 
-        if (this.superClasse !== null) {
+        if (this.superClasse !== null && this.superClasse !== undefined) {
             return this.superClasse.encontrarMetodo(nome);
         }
 
         return undefined;
     }
 
+    encontrarPropriedade(nome: string): PropriedadeClasse {
+        if (nome in this.propriedades) {
+            return this.propriedades[nome];
+        }
+
+        if (this.superClasse !== null && this.superClasse !== undefined) {
+            return this.superClasse.encontrarPropriedade(nome);
+        }
+
+        return undefined;
+    }
+
     paraTexto(): string {
         return `<classe ${this.nome}>`;
     }
@@ -36,12 +51,13 @@ export class DeleguaClasse extends Chamavel {
         return inicializador ? inicializador.aridade() : 0;
     }
 
-    chamar(visitante: VisitanteComumInterface, argumentos: any[]): ObjetoDeleguaClasse {
+    async chamar(visitante: VisitanteComumInterface, argumentos: any[]): Promise<ObjetoDeleguaClasse> {
         const instancia = new ObjetoDeleguaClasse(this);
 
         const inicializador = this.encontrarMetodo('construtor');
         if (inicializador) {
-            inicializador.definirInstancia(instancia).chamar(visitante, argumentos);
+            const metodoConstrutor = inicializador.funcaoPorMetodoDeClasse(instancia);
+            await metodoConstrutor.chamar(visitante, argumentos);
         }
 
         return instancia;
diff --git a/fontes/estruturas/delegua-funcao.ts b/fontes/estruturas/delegua-funcao.ts
index 0c040e45..58f1f72a 100644
--- a/fontes/estruturas/delegua-funcao.ts
+++ b/fontes/estruturas/delegua-funcao.ts
@@ -78,7 +78,7 @@ export class DeleguaFuncao extends Chamavel {
         return retornoBloco;
     }
 
-    definirInstancia(instancia: ObjetoDeleguaClasse): DeleguaFuncao {
+    funcaoPorMetodoDeClasse(instancia: ObjetoDeleguaClasse): DeleguaFuncao {
         return new DeleguaFuncao(this.nome, this.declaracao, instancia, this.eInicializador);
     }
 }
diff --git a/fontes/estruturas/objeto-delegua-classe.ts b/fontes/estruturas/objeto-delegua-classe.ts
index fa116087..f9754028 100644
--- a/fontes/estruturas/objeto-delegua-classe.ts
+++ b/fontes/estruturas/objeto-delegua-classe.ts
@@ -17,7 +17,7 @@ export class ObjetoDeleguaClasse {
         }
 
         const metodo = this.classe.encontrarMetodo(simbolo.lexema);
-        if (metodo) return metodo.definirInstancia(this);
+        if (metodo) return metodo.funcaoPorMetodoDeClasse(this);
 
         throw new ErroEmTempoDeExecucao(simbolo, 'Método indefinido não recuperado.');
     }
diff --git a/fontes/interpretador/dialetos/index.ts b/fontes/interpretador/dialetos/index.ts
index b0021a88..4199bd9c 100644
--- a/fontes/interpretador/dialetos/index.ts
+++ b/fontes/interpretador/dialetos/index.ts
@@ -4,6 +4,7 @@ export * from './mapler/interpretador-mapler-com-depuracao';
 export * from './portugol-ipt/interpretador-portugol-ipt';
 export * from './portugol-studio/interpretador-portugol-studio';
 export * from './portugol-studio/interpretador-portugol-studio-com-depuracao';
+export * from './potigol/interpretador-potigol';
 export * from './visualg/interpretador-visualg';
 export * from './visualg/interpretador-visualg-com-depuracao';
 export * from './birl/interpretador-birl'
diff --git a/fontes/interpretador/dialetos/potigol/comum.ts b/fontes/interpretador/dialetos/potigol/comum.ts
new file mode 100644
index 00000000..e69de29b
diff --git a/fontes/interpretador/dialetos/potigol/inferenciador.ts b/fontes/interpretador/dialetos/potigol/inferenciador.ts
new file mode 100644
index 00000000..2bd197e9
--- /dev/null
+++ b/fontes/interpretador/dialetos/potigol/inferenciador.ts
@@ -0,0 +1,25 @@
+
+export function inferirTipoVariavel(variavel: string | number | Array<any> | boolean | null | undefined) {
+    const tipo = typeof variavel;
+    switch (tipo) {
+        case 'string':
+            return 'Texto';
+        case 'number':
+            return 'Número';
+        case 'bigint':
+            return 'Longo';
+        case 'boolean':
+            return 'Lógico';
+        case 'undefined':
+            return 'Nulo';
+        case 'object':
+            if (Array.isArray(variavel)) return 'vetor';
+            if (variavel === null) return 'nulo';
+            if (variavel.constructor.name === 'DeleguaModulo') return 'módulo';
+            return 'Dicionário';
+        case 'function':
+            return 'Função';
+        case 'symbol':
+            return 'Símbolo';
+    }
+}
diff --git a/fontes/interpretador/dialetos/potigol/interpretador-potigol.ts b/fontes/interpretador/dialetos/potigol/interpretador-potigol.ts
new file mode 100644
index 00000000..41ef305e
--- /dev/null
+++ b/fontes/interpretador/dialetos/potigol/interpretador-potigol.ts
@@ -0,0 +1,95 @@
+import { DeleguaModulo, MetodoPrimitiva, ObjetoDeleguaClasse } from "../../../estruturas";
+import { VariavelInterface } from "../../../interfaces";
+import { InterpretadorBase } from "../../interpretador-base";
+import { inferirTipoVariavel } from "./inferenciador";
+
+import { ErroEmTempoDeExecucao } from "../../../excecoes";
+import { registrarBibliotecaGlobalPotigol } from "../../../bibliotecas/dialetos/potigol/biblioteca-global";
+
+import primitivasNumero from "../../../bibliotecas/dialetos/potigol/primitivas-numero";
+import primitivasTexto from "../../../bibliotecas/dialetos/potigol/primitivas-texto";
+import primitivasVetor from "../../../bibliotecas/dialetos/potigol/primitivas-vetor";
+
+export class InterpretadorPotigol extends InterpretadorBase {
+    constructor(
+        diretorioBase: string,
+        performance = false,
+        funcaoDeRetorno: Function = null,
+        funcaoDeRetornoMesmaLinha: Function = null
+    ) {
+        super(diretorioBase, performance, funcaoDeRetorno, funcaoDeRetornoMesmaLinha);
+
+        registrarBibliotecaGlobalPotigol(this, this.pilhaEscoposExecucao);
+    }
+
+    /**
+     * Executa um acesso a método, normalmente de um objeto de classe.
+     * @param expressao A expressão de acesso.
+     * @returns O resultado da execução.
+     */
+    async visitarExpressaoAcessoMetodo(expressao: any): Promise<any> {
+        const variavelObjeto: VariavelInterface = await this.avaliar(expressao.objeto);
+        const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto;
+
+        if (objeto instanceof ObjetoDeleguaClasse) {
+            return objeto.obter(expressao.simbolo) || null;
+        }
+
+        // TODO: Possivelmente depreciar esta forma.
+        // Não parece funcionar em momento algum.
+        if (objeto.constructor === Object) {
+            return objeto[expressao.simbolo.lexema] || null;
+        }
+
+        // Função tradicional do JavaScript.
+        // Normalmente executa quando uma biblioteca é importada.
+        if (typeof objeto[expressao.simbolo.lexema] === 'function') {
+            return objeto[expressao.simbolo.lexema];
+        }
+
+        // Objeto tradicional do JavaScript.
+        // Normalmente executa quando uma biblioteca é importada.
+        if (typeof objeto[expressao.simbolo.lexema] === 'object') {
+            return objeto[expressao.simbolo.lexema];
+        }
+
+        if (objeto instanceof DeleguaModulo) {
+            return objeto.componentes[expressao.simbolo.lexema] || null;
+        }
+
+        let tipoObjeto: any = variavelObjeto.tipo;
+        if (tipoObjeto === null || tipoObjeto === undefined) {
+            tipoObjeto = inferirTipoVariavel(variavelObjeto as any);
+        }
+
+        switch (tipoObjeto) {
+            case 'numero':
+            case 'número':
+                const metodoDePrimitivaNumero: Function = primitivasNumero[expressao.simbolo.lexema];
+                if (metodoDePrimitivaNumero) {
+                    return new MetodoPrimitiva(objeto, metodoDePrimitivaNumero);
+                }
+                break;
+            case 'texto':
+                const metodoDePrimitivaTexto: Function = primitivasTexto[expressao.simbolo.lexema];
+                if (metodoDePrimitivaTexto) {
+                    return new MetodoPrimitiva(objeto, metodoDePrimitivaTexto);
+                }
+                break;
+            case 'vetor':
+                const metodoDePrimitivaVetor: Function = primitivasVetor[expressao.simbolo.lexema];
+                if (metodoDePrimitivaVetor) {
+                    return new MetodoPrimitiva(objeto, metodoDePrimitivaVetor);
+                }
+                break;
+        }
+
+        return Promise.reject(
+            new ErroEmTempoDeExecucao(
+                expressao.nome,
+                `Método para objeto ou primitiva não encontrado: ${expressao.simbolo.lexema}.`,
+                expressao.linha
+            )
+        );
+    }
+}
\ No newline at end of file
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index 63f3bbc0..d81b64ec 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -206,16 +206,16 @@ export class InterpretadorBase implements InterpretadorInterface {
 
         //TODO verificar erros do resultadosAvaliacaoSintatica
 
-        const resolucoesPromises = await Promise.all(resultadosAvaliacaoSintatica.flatMap(r => r.resultadoMicroAvaliadorSintatico.declaracoes).map(d => {
-            return this.avaliar(d)
-        }))
+        const resolucoesPromises = await Promise.all(
+            resultadosAvaliacaoSintatica
+                .flatMap(r => r.resultadoMicroAvaliadorSintatico.declaracoes)
+                .map(d => this.avaliar(d))
+        );
 
-        return resolucoesPromises.map((item, indice) => {
-            return {
-                variavel: resultadosAvaliacaoSintatica[indice].nomeVariavel,
-                valor: item,
-            }
-        });
+        return resolucoesPromises.map((item, indice) => ({
+            variavel: resultadosAvaliacaoSintatica[indice].nomeVariavel,
+            valor: item
+        }));
     }
 
     async visitarExpressaoLiteral(expressao: Literal): Promise<any> {
@@ -512,8 +512,8 @@ export class InterpretadorBase implements InterpretadorInterface {
             if (entidadeChamada instanceof DeleguaFuncao) {
                 parametros = entidadeChamada.declaracao.parametros;
             } else if (entidadeChamada instanceof DeleguaClasse) {
-                parametros = entidadeChamada.metodos.inicializacao
-                    ? entidadeChamada.metodos.inicializacao.declaracao.parametros
+                parametros = entidadeChamada.metodos.construtor
+                    ? entidadeChamada.metodos.construtor.declaracao.parametros
                     : [];
             } else {
                 parametros = [];
@@ -552,7 +552,8 @@ export class InterpretadorBase implements InterpretadorInterface {
             }
 
             if (entidadeChamada instanceof Chamavel) {
-                return entidadeChamada.chamar(this, argumentos);
+                const retornoEntidadeChamada = await entidadeChamada.chamar(this, argumentos);
+                return retornoEntidadeChamada;
             }
 
             // A função chamada pode ser de uma biblioteca JavaScript.
@@ -1196,7 +1197,7 @@ export class InterpretadorBase implements InterpretadorInterface {
      */
     async visitarDeclaracaoClasse(declaracao: Classe): Promise<any> {
         let superClasse = null;
-        if (declaracao.superClasse !== null) {
+        if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
             const variavelSuperClasse: VariavelInterface = await this.avaliar(declaracao.superClasse);
             superClasse = variavelSuperClasse.valor;
             if (!(superClasse instanceof DeleguaClasse)) {
@@ -1210,7 +1211,7 @@ export class InterpretadorBase implements InterpretadorInterface {
 
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, declaracao);
 
-        if (declaracao.superClasse !== null) {
+        if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
             this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
         }
 
@@ -1223,7 +1224,12 @@ export class InterpretadorBase implements InterpretadorInterface {
             metodos[metodoAtual.simbolo.lexema] = funcao;
         }
 
-        const deleguaClasse: DeleguaClasse = new DeleguaClasse(declaracao.simbolo.lexema, superClasse, metodos);
+        const deleguaClasse: DeleguaClasse = new DeleguaClasse(
+            declaracao.simbolo.lexema, 
+            superClasse, 
+            metodos,
+            declaracao.propriedades
+        );
 
         // TODO: Recolocar isso se for necessário.
         /* if (superClasse !== null) {
@@ -1405,8 +1411,13 @@ export class InterpretadorBase implements InterpretadorInterface {
             return Promise.reject(erro);
         } finally {
             this.pilhaEscoposExecucao.removerUltimo();
-            if (manterAmbiente) {
-                const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
+            const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
+
+            /* if ('isto' in escopoAnterior.ambiente.valores) {
+
+            } */
+
+            if (manterAmbiente) {    
                 escopoAnterior.ambiente.valores = Object.assign(
                     escopoAnterior.ambiente.valores,
                     ultimoEscopo.ambiente.valores
diff --git a/fontes/lexador/README.md b/fontes/lexador/README.md
index a1905562..ad659d76 100644
--- a/fontes/lexador/README.md
+++ b/fontes/lexador/README.md
@@ -7,3 +7,7 @@ Um símbolo é equivalente a um lexema. Um lexema é uma unidade básica do léx
 Caracteres que não são alfanuméricos normalmente possuem funções de estruturação e cadência nas linguagens implementadas. Por exemplo, os símbolos de abre e fecha chaves - `{` e `}`, respectivamente, podem representar tanto a definição de um escopo em Delégua quanto a definição de um dicionário. Cada um desses símbolos é traduzido pelo lexador para `tiposDeSimbolos.CHAVE_ESQUERDA` e `tiposDeSimbolos.CHAVE_DIREITA`, respectivamente.
 
 Todos os tipos de símbolos para Delégua e dialetos [estão definidos aqui](https://github.com/DesignLiquido/delegua/tree/principal/fontes/tipos-de-simbolos). 
+
+## Micro Lexador
+
+Delégua possui um micro lexador implementado. O micro lexador é utilizado em situações em que precisamos trabalhar com um número reduzido de símbolos. Um caso clássico é o de interpolação de texto, em que não faz sentido aceitar quebras de linha, ponto-e-vígula, ou abertura e fechamento de chaves - esses últimos usados justamente para cercar o escopo da interpolação. 
\ No newline at end of file
diff --git a/fontes/lexador/dialetos/lexador-potigol.ts b/fontes/lexador/dialetos/lexador-potigol.ts
index 2792f3fb..c5aacf24 100644
--- a/fontes/lexador/dialetos/lexador-potigol.ts
+++ b/fontes/lexador/dialetos/lexador-potigol.ts
@@ -2,9 +2,14 @@ import { RetornoLexador } from "../../interfaces/retornos";
 import { ErroLexador } from "../erro-lexador";
 import { LexadorBaseLinhaUnica } from "../lexador-base-linha-unica";
 
-import tiposDeSimbolos from '../../tipos-de-simbolos/potigol';
 import { palavrasReservadas } from "./palavras-reservadas/potigol";
 
+import tiposDeSimbolos from '../../tipos-de-simbolos/potigol';
+
+/**
+ * Lexador para o dialeto Potigol.
+ * Este dialeto é sensível a tamanho de caixa. `Inteiro` é aceito. `inteiro` não.
+ */
 export class LexadorPotigol extends LexadorBaseLinhaUnica {
     protected logicaComumCaracteres(delimitador: string) {
         while (this.simboloAtual() !== delimitador && !this.eFinalDoCodigo()) {
@@ -56,6 +61,12 @@ export class LexadorPotigol extends LexadorBaseLinhaUnica {
             parseFloat(numeroCompleto));
     }
 
+    avancarParaProximaLinha(): void {
+        while (this.codigo[this.atual] !== '\n') {
+            this.atual++;
+        }
+    }
+
     identificarPalavraChave(): void {
         while (this.eAlfabetoOuDigito(this.simboloAtual())) {
             this.avancar();
@@ -87,6 +98,8 @@ export class LexadorPotigol extends LexadorBaseLinhaUnica {
                 this.adicionarSimbolo(tiposDeSimbolos.PARENTESE_DIREITO);
                 this.avancar();
                 break;
+            // Até então encontradas apenas em interpolações de texto.
+            // Por ora não necessárias.
             /* case '{':
                 this.adicionarSimbolo(tiposDeSimbolos.CHAVE_ESQUERDA);
                 this.avancar();
@@ -95,6 +108,17 @@ export class LexadorPotigol extends LexadorBaseLinhaUnica {
                 this.adicionarSimbolo(tiposDeSimbolos.CHAVE_DIREITA);
                 this.avancar();
                 break; */
+            case ':':
+                this.inicioSimbolo = this.atual;
+                this.avancar();
+                if (this.simboloAtual() === '=') {
+                    this.adicionarSimbolo(tiposDeSimbolos.REATRIBUIR);
+                    this.avancar();
+                } else {
+                    this.adicionarSimbolo(tiposDeSimbolos.DOIS_PONTOS);
+                }
+                
+                break;
             case ',':
                 this.adicionarSimbolo(tiposDeSimbolos.VIRGULA);
                 this.avancar();
@@ -132,32 +156,38 @@ export class LexadorPotigol extends LexadorBaseLinhaUnica {
                 } */
 
                 break;
-
             case '*':
                 this.inicioSimbolo = this.atual;
                 this.avancar();
                 this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO);
-                /* switch (this.simboloAtual()) {
+                break;
+            case '^':
+                this.inicioSimbolo = this.atual;
+                this.avancar();
+                this.adicionarSimbolo(tiposDeSimbolos.EXPONENCIACAO);
+                break;
+            case '=':
+                this.inicioSimbolo = this.atual;
+                this.avancar();
+
+                switch (this.simboloAtual()) {
                     case '=':
+                        this.adicionarSimbolo(tiposDeSimbolos.IGUAL_IGUAL);
+                        this.avancar();
+                        break;    
+                    case '>':
+                        this.adicionarSimbolo(tiposDeSimbolos.SETA);
                         this.avancar();
-                        this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO_IGUAL);
                         break;
                     default:
-                        this.adicionarSimbolo(tiposDeSimbolos.MULTIPLICACAO);
+                        this.adicionarSimbolo(tiposDeSimbolos.IGUAL);
                         break;
-                } */
-                break;
-            case '=':
-                this.avancar();
-                this.adicionarSimbolo(tiposDeSimbolos.IGUAL);
-                /* if (this.simboloAtual() === '=') {
-                    this.adicionarSimbolo(tiposDeSimbolos.IGUAL_IGUAL);
-                    this.avancar();
-                } else {
-                    this.adicionarSimbolo(tiposDeSimbolos.IGUAL);
-                } */
+                }
 
                 break;
+            case '#':
+                this.avancarParaProximaLinha();
+                break;
 
             /* case '&':
                 this.adicionarSimbolo(tiposDeSimbolos.BIT_AND);
@@ -173,20 +203,24 @@ export class LexadorPotigol extends LexadorBaseLinhaUnica {
                 this.adicionarSimbolo(tiposDeSimbolos.BIT_OR);
                 this.avancar();
                 break;
-
-            case '^':
-                this.adicionarSimbolo(tiposDeSimbolos.BIT_XOR);
-                this.avancar();
-                break; */
+             */
 
             case '<':
                 this.avancar();
-                if (this.simboloAtual() === '=') {
-                    this.adicionarSimbolo(tiposDeSimbolos.MENOR_IGUAL);
-                    this.avancar();
-                } else {
-                    this.adicionarSimbolo(tiposDeSimbolos.MENOR);
+                switch (this.simboloAtual()) {
+                    case '=':
+                        this.adicionarSimbolo(tiposDeSimbolos.MENOR_IGUAL);
+                        this.avancar();
+                        break;
+                    case '>':
+                        this.adicionarSimbolo(tiposDeSimbolos.DIFERENTE);
+                        this.avancar();
+                        break;
+                    default:
+                        this.adicionarSimbolo(tiposDeSimbolos.MENOR);
+                        break;
                 }
+
                 break;
 
             case '>':
@@ -200,7 +234,9 @@ export class LexadorPotigol extends LexadorBaseLinhaUnica {
                 break;
 
             case '/':
+                this.inicioSimbolo = this.atual;
                 this.avancar();
+                this.adicionarSimbolo(tiposDeSimbolos.DIVISAO);
                 /* switch (this.simboloAtual()) {
                     case '/':
                         this.avancarParaProximaLinha();
@@ -213,7 +249,7 @@ export class LexadorPotigol extends LexadorBaseLinhaUnica {
                         this.avancar();s
                         break;
                     default:
-                        this.adicionarSimbolo(tiposDeSimbolos.DIVISAO);
+                        
                         break;
                 } */
 
@@ -229,6 +265,11 @@ export class LexadorPotigol extends LexadorBaseLinhaUnica {
                 this.avancar();
                 break;
 
+            case '\n':
+                this.linha++;
+                this.avancar();
+                break;
+
             case '"':
                 this.avancar();
                 this.analisarTexto();
@@ -241,6 +282,12 @@ export class LexadorPotigol extends LexadorBaseLinhaUnica {
                 this.avancar();
                 break;
 
+            case '_':
+                this.inicioSimbolo = this.atual;
+                this.avancar();
+                this.adicionarSimbolo(tiposDeSimbolos.TRACO_BAIXO);
+                break;
+
             default:
                 if (this.eDigito(caractere)) this.analisarNumero();
                 else if (this.eAlfabeto(caractere)) this.identificarPalavraChave();
diff --git a/fontes/lexador/dialetos/lexador-visualg.ts b/fontes/lexador/dialetos/lexador-visualg.ts
index 91fb1005..c35e0741 100644
--- a/fontes/lexador/dialetos/lexador-visualg.ts
+++ b/fontes/lexador/dialetos/lexador-visualg.ts
@@ -173,7 +173,7 @@ export class LexadorVisuAlg extends LexadorBaseLinhaUnica {
                 this.avancar();
                 break;
             // Esta sessão ignora espaços em branco na tokenização.
-            // Ponto-e-vírgula é opcional em Delégua, então pode apenas ser ignorado.
+            // Ponto-e-vírgula é opcional em VisuAlg, então pode apenas ser ignorado.
             case ' ':
             case '\0':
             case '\r':
diff --git a/fontes/lexador/dialetos/palavras-reservadas/potigol.ts b/fontes/lexador/dialetos/palavras-reservadas/potigol.ts
index f3f4ab44..9ddd27b2 100644
--- a/fontes/lexador/dialetos/palavras-reservadas/potigol.ts
+++ b/fontes/lexador/dialetos/palavras-reservadas/potigol.ts
@@ -1,12 +1,39 @@
 import tiposDeSimbolos from '../../../tipos-de-simbolos/potigol';
 
 export const palavrasReservadas = {
-    caractere: tiposDeSimbolos.CARACTERE,
+    ate: tiposDeSimbolos.ATE,
+    até: tiposDeSimbolos.ATE,
+    Caractere: tiposDeSimbolos.CARACTERE,
+    caso: tiposDeSimbolos.CASO,
+    de: tiposDeSimbolos.DE,
+    div: tiposDeSimbolos.DIVISAO_INTEIRA,
+    e: tiposDeSimbolos.E,
+    escolha: tiposDeSimbolos.ESCOLHA,
+    entao: tiposDeSimbolos.ENTAO,
+    então: tiposDeSimbolos.ENTAO,
+    enquanto: tiposDeSimbolos.ENQUANTO,
     escreva: tiposDeSimbolos.ESCREVA,
+    faca: tiposDeSimbolos.FACA,
+    faça: tiposDeSimbolos.FACA,
+    falso: tiposDeSimbolos.FALSO,
+    fim: tiposDeSimbolos.FIM,
     imprima: tiposDeSimbolos.IMPRIMA,
-    inteiro: tiposDeSimbolos.INTEIRO,
-    logico: tiposDeSimbolos.LOGICO,
-    não: tiposDeSimbolos.NAO,
-    real: tiposDeSimbolos.REAL,
-    texto: tiposDeSimbolos.TEXTO
+    Inteiro: tiposDeSimbolos.INTEIRO,
+    Logico: tiposDeSimbolos.LOGICO,
+    Lógico: tiposDeSimbolos.LOGICO,
+    mod: tiposDeSimbolos.MODULO,
+    ou: tiposDeSimbolos.OU,
+    nao: tiposDeSimbolos.NEGACAO,
+    não: tiposDeSimbolos.NEGACAO,
+    para: tiposDeSimbolos.PARA,
+    passo: tiposDeSimbolos.PASSO,
+    Real: tiposDeSimbolos.REAL,
+    retorne: tiposDeSimbolos.RETORNE,
+    se: tiposDeSimbolos.SE,
+    senao: tiposDeSimbolos.SENAO,
+    senão: tiposDeSimbolos.SENAO,
+    Texto: tiposDeSimbolos.TEXTO,
+    tipo: tiposDeSimbolos.TIPO,
+    var: tiposDeSimbolos.VARIAVEL,
+    verdadeiro: tiposDeSimbolos.VERDADEIRO
 }
\ No newline at end of file
diff --git a/fontes/tipos-de-simbolos/potigol.ts b/fontes/tipos-de-simbolos/potigol.ts
index b76a4c93..6612091f 100644
--- a/fontes/tipos-de-simbolos/potigol.ts
+++ b/fontes/tipos-de-simbolos/potigol.ts
@@ -1,26 +1,56 @@
 export default {
     ADICAO: 'ADICAO',
+    ATE: 'ATE',
     CARACTERE: 'CARACTERE',
+    CASO: 'CASO',
     COLCHETE_ESQUERDO: 'COLCHETE_ESQUERDO',
     COLCHETE_DIREITO: 'COLCHETE_DIREITO',
+    CONSTRUTOR: 'CONSTRUTOR',
+    DOIS_PONTOS: 'DOIS_PONTOS',
+    DE: 'DE',
+    DIFERENTE: 'DIFERENTE',
     DIVISAO: 'DIVISAO',
-    PARENTESE_ESQUERDO: 'PARENTESE_ESQUERDO',
-    PARENTESE_DIREITO: 'PARENTESE_DIREITO',
+    DIVISAO_INTEIRA: 'DIVISAO_INTEIRA',
+    E: 'E',
+    ENQUANTO: 'ENQUANTO',
+    ENTAO: 'ENTAO',
+    ESCOLHA: 'ESCOLHA',
     ESCREVA: 'ESCREVA',
+    EXPONENCIACAO: 'EXPONENCIACAO',
+    FALSO: 'FALSO',
+    FACA: 'FACA',
+    FIM: 'FIM',
     IDENTIFICADOR: 'IDENTIFICADOR',
     IGUAL: 'IGUAL',
+    IGUAL_IGUAL: 'IGUAL_IGUAL',
     IMPRIMA: 'IMPRIMA',
     INTEIRO: 'INTEIRO',
+    ISTO: 'ISTO',
     LOGICO: 'LOGICO',
     MAIOR: 'MAIOR',
     MAIOR_IGUAL: 'MAIOR_IGUAL',
     MENOR: 'MENOR',
     MENOR_IGUAL: 'MENOR_IGUAL',
+    MODULO: 'MODULO',
     MULTIPLICACAO: 'MULTIPLICACAO',
-    NAO: 'NAO',
+    NEGACAO: 'NEGACAO',
+    OU: 'OU',
+    PARA: 'PARA',
+    PARENTESE_ESQUERDO: 'PARENTESE_ESQUERDO',
+    PARENTESE_DIREITO: 'PARENTESE_DIREITO',
+    PASSO: 'PASSO',
     PONTO: 'PONTO',
     REAL: 'REAL',
+    REATRIBUIR: 'REATRIBUIR',
+    RETORNE: 'RETORNE',
+    SE: 'SE',
+    SENAO: 'SENAO',
+    SETA: 'SETA',
     SUBTRACAO: 'SUBTRACAO',
+    TIPO: 'TIPO',
+    TRACO_BAIXO: 'TRACO_BAIXO',
     TEXTO: 'TEXTO',
+    VERDADEIRO: 'VERDADEIRO',
+    VARIAVEL: 'VARIAVEL',
     VIRGULA: 'VIRGULA'
 }
\ No newline at end of file
diff --git a/fontes/tradutores/tradutor-javascript.ts b/fontes/tradutores/tradutor-javascript.ts
index 3dc0db5b..9429436c 100644
--- a/fontes/tradutores/tradutor-javascript.ts
+++ b/fontes/tradutores/tradutor-javascript.ts
@@ -384,13 +384,9 @@ export class TradutorJavaScript implements TradutorInterface {
 
     traduzirDeclaracaoPara(declaracaoPara: Para): string {
         let resultado = 'for (';
-        if(declaracaoPara.inicializador.constructor.name === 'Array') {
-            resultado +=
+        resultado +=
             this.dicionarioDeclaracoes[declaracaoPara.inicializador[0].constructor.name](declaracaoPara.inicializador[0]) +
             ' ';
-        } else {
-            resultado += this.dicionarioDeclaracoes[declaracaoPara.inicializador.constructor.name](declaracaoPara.inicializador) + ' ';
-        }
 
         resultado += !resultado.includes(';') ? ';' : '';
 
diff --git a/fontes/tradutores/tradutor-python.ts b/fontes/tradutores/tradutor-python.ts
index b476c623..c7015154 100644
--- a/fontes/tradutores/tradutor-python.ts
+++ b/fontes/tradutores/tradutor-python.ts
@@ -196,17 +196,13 @@ export class TradutorPython implements TradutorInterface {
         return resultado;
     }
 
-
-    traduzirDeclaracaoSe(declaracaoSe: Se, iniciarComIf: boolean = true): string {
-        let resultado = '';
-        if (iniciarComIf) {
-            resultado += 'if ';
-        } else {
-            resultado += 'elif '
-        }
+    traduzirDeclaracaoSe(declaracaoSe: Se): string {
+        let resultado = 'if ';
 
         const condicao = this.dicionarioConstrutos[declaracaoSe.condicao.constructor.name](declaracaoSe.condicao);
+
         resultado += condicao;
+
         resultado += ':\n';
         resultado += this.dicionarioDeclaracoes[declaracaoSe.caminhoEntao.constructor.name](declaracaoSe.caminhoEntao);
 
@@ -215,23 +211,19 @@ export class TradutorPython implements TradutorInterface {
             const se = declaracaoSe?.caminhoSenao as Se;
             if (se?.caminhoEntao) {
                 resultado += 'elif ';
-                resultado += this.dicionarioConstrutos[se.condicao.constructor.name](se.condicao, false);
+                resultado += this.dicionarioConstrutos[se.condicao.constructor.name](se.condicao);
                 resultado += ':\n';
                 resultado += this.dicionarioDeclaracoes[se.caminhoEntao.constructor.name](se.caminhoEntao);
                 resultado += ' '.repeat(this.indentacao);
                 if (se?.caminhoSenao) {
-                    if (se.caminhoSenao instanceof Bloco){
-                        resultado += 'else:\n';
-                        resultado += this.dicionarioDeclaracoes[se.caminhoSenao.constructor.name](se.caminhoSenao, false);
-                        return resultado;
-                    } else {
-                        resultado += this.dicionarioDeclaracoes[se.caminhoSenao.constructor.name](se.caminhoSenao, false);
-                        return resultado;
-                    }
+                    resultado += 'else:\n';
+                    resultado += this.dicionarioDeclaracoes[se.caminhoSenao.constructor.name](se.caminhoSenao);
+                    return resultado;
                 }
+            } else {
+                resultado += 'else:\n';
             }
-            resultado += 'else:\n';
-            resultado += ' '.repeat(this.indentacao);
+
             resultado += this.dicionarioDeclaracoes[declaracaoSe.caminhoSenao.constructor.name](
                 declaracaoSe.caminhoSenao
             );
@@ -257,13 +249,6 @@ export class TradutorPython implements TradutorInterface {
         }
 
         resultado += '):\n';
-        if (metodoClasse.funcao.corpo.length === 0) {
-            resultado += ' '.repeat(this.indentacao + 4);
-            resultado += 'pass\n'
-            this.indentacao -= 4;
-            return resultado;
-        }
-
         resultado += this.logicaComumBlocoEscopo(metodoClasse.funcao.corpo);
         resultado += ' '.repeat(this.indentacao) + '\n';
 
@@ -275,11 +260,9 @@ export class TradutorPython implements TradutorInterface {
         let resultado = 'class ';
 
         if (declaracaoClasse.superClasse)
-            resultado += `${declaracaoClasse.simbolo.lexema}(${declaracaoClasse.superClasse.simbolo.lexema}):\n`;
+            resultado += `${declaracaoClasse.simbolo.lexema} extends ${declaracaoClasse.superClasse.simbolo.lexema} {\n`;
         else resultado += declaracaoClasse.simbolo.lexema + ':\n';
 
-        if(declaracaoClasse.metodos.length === 0) return resultado += '    pass\n'
-
         for (let metodo of declaracaoClasse.metodos) {
             resultado += this.logicaTraducaoMetodoClasse(metodo);
         }
diff --git a/package.json b/package.json
index 71d3a82f..50f24ccc 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@designliquido/delegua",
-    "version": "0.21.2",
+    "version": "0.21.0",
     "description": "Linguagem de programação simples e moderna usando português estruturado, com suporte a múltiplos dialetos",
     "main": "index.js",
     "scripts": {


Test patch:
diff --git a/testes/interpretador.test.ts b/testes/interpretador.test.ts
index 85be00b0..0cad452b 100644
--- a/testes/interpretador.test.ts
+++ b/testes/interpretador.test.ts
@@ -593,7 +593,7 @@ describe('Interpretador', () => {
                 });
             });
 
-            describe('Classes', () => {
+            describe.only('Classes', () => {
                 it('Super Classe precisa ser uma classe', async () => {
                     const codigo = [
                         "funcao A(data) { }",
@@ -639,6 +639,32 @@ describe('Interpretador', () => {
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
+
+                it.skip('Construtor', async () => {
+                    const codigo = [
+                        'classe Quadrado {',
+                        '  construtor(lado) {',
+                        '    isto.lado = lado',
+                        '  }',
+                        '  area() {',
+                        '    retorna lado * lado',
+                        '  }',
+                        '  perimetro() {',
+                        '    retorna 4 * lado',
+                        '  }',
+                        '}',
+                        'var q1 = Quadrado(10)',
+                        'escreva(q1.area())',
+                        'escreva(q1.perimetro())',
+                    ];
+
+                    const retornoLexador = lexador.mapear(codigo, -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                });
             });
 
             describe('Declaração e chamada de funções', () => {
diff --git a/testes/potigol/avaliador-sintatico.test.ts b/testes/potigol/avaliador-sintatico.test.ts
index 9bc51841..15233ad9 100644
--- a/testes/potigol/avaliador-sintatico.test.ts
+++ b/testes/potigol/avaliador-sintatico.test.ts
@@ -1,5 +1,6 @@
 import { LexadorPotigol } from "../../fontes/lexador/dialetos";
 import { AvaliadorSintaticoPotigol } from "../../fontes/avaliador-sintatico/dialetos";
+import { ErroAvaliadorSintatico } from "../../fontes/avaliador-sintatico/erro-avaliador-sintatico";
 
 describe('Avaliador sintático', () => {
     describe('analisar()', () => {
@@ -7,28 +8,407 @@ describe('Avaliador sintático', () => {
         let avaliadorSintatico = new AvaliadorSintaticoPotigol();
 
         describe('Cenários de sucesso', () => {
-            it('Sucesso - Escreva Olá Mundo', () => {
-                const retornoLexador = lexador.mapear(['escreva "Olá mundo"'], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+            describe('Entrada e saída', () => {
+                it('Sucesso - Escreva Olá Mundo', () => {
+                    const retornoLexador = lexador.mapear(['escreva "Olá mundo"'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
     
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                it('Sucesso - Imprima Olá Mundo', () => {
+                    const retornoLexador = lexador.mapear(['imprima "Olá mundo"'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
             });
 
-            it('Sucesso - Imprima Olá Mundo', () => {
-                const retornoLexador = lexador.mapear(['imprima "Olá mundo"'], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+            describe('Operações matemáticas', () => {
+                it('Sucesso - 2 + 2', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 + 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
     
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                it('Sucesso - Operações encadeadas', () => {
+                    const retornoLexador = lexador.mapear(['escreva (2 * 8) - (5 / 4 ^ 7)'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Mod e Div', () => {
+                    const retornoLexador = lexador.mapear(['escreva (100 mod 6 div 2)'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
             });
-
-            it('Sucesso - 2 + 2', () => {
-                const retornoLexador = lexador.mapear(['escreva 2 + 2'], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+            
+            describe('Operações lógicas', () => {
+                it('Sucesso - Ou', () => {
+                    const retornoLexador = lexador.mapear(['verdadeiro ou falso'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - E', () => {
+                    const retornoLexador = lexador.mapear(['verdadeiro e falso'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Não (sem acento)', () => {
+                    const retornoLexador = lexador.mapear(['nao verdadeiro'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Não (com acento)', () => {
+                    const retornoLexador = lexador.mapear(['não verdadeiro'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Comparação de igualdade', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 == 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Comparação de desigualdade', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 <> 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Comparação de menor', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 < 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Comparação de menor ou igual', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 <= 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Comparação de maior', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 > 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Comparação de maior ou igual', () => {
+                    const retornoLexador = lexador.mapear(['escreva 2 >= 2'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+            });
+            
+            describe('Atribuição de variáveis', () => {
+                it('Sucesso - Declaração de inteiro constante, inferência', () => {
+                    const retornoLexador = lexador.mapear(['a = 10'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Declaração de inteiro variável, inferência', () => {
+                    const retornoLexador = lexador.mapear(['var a := 10'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it('Sucesso - Declaração de múltiplas variáveis inteiras, inferência', () => {
+                    const retornoLexador = lexador.mapear(['var a, b, c := 10, 20, 30'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
+                });
+    
+                it.skip('Sucesso - Declaração de caractere constante, dica de tipo', () => {
+                    const retornoLexador = lexador.mapear(["c: Caractere = 'z'"], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
     
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                it.skip('Sucesso - Declaração de inteiro constante, dica de tipo', () => {
+                    const retornoLexador = lexador.mapear(['a: Inteiro = 10'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it.skip('Sucesso - Declaração de lógico (com acento) constante, dica de tipo', () => {
+                    const retornoLexador = lexador.mapear(['b: Lógico = verdadeiro'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it.skip('Sucesso - Declaração de lógico (sem acento) constante, dica de tipo', () => {
+                    const retornoLexador = lexador.mapear(['b: Logico = verdadeiro'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it.skip('Sucesso - Declaração de real constante, dica de tipo', () => {
+                    const retornoLexador = lexador.mapear(['r: Real = 3.14'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+    
+                it.skip('Sucesso - Declaração de texto constante, dica de tipo', () => {
+                    const retornoLexador = lexador.mapear(['s: Texto = "Programação"'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+        
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+            });
+            
+            describe('Estruturas de decisão', () => {
+                it('Escolha', () => {
+                    const retornoLexador = lexador.mapear([
+                        'escolha x',
+                        '  caso 1 => escreva "Um"',
+                        '  caso 2 => escreva "Dois"',
+                        '  caso 3 => escreva "Três"',
+                        '  caso _ => escreva "Outro valor"',
+                        'fim'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Se', () => {
+                    const retornoLexador = lexador.mapear([
+                        'se verdadeiro então',
+                        '  escreva "verdadeiro"',
+                        'senão',
+                        '  escreva "falso"',
+                        'fim'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+            });
+
+            describe('Estruturas de repetição', () => {
+                it('Enquanto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var i := 0',
+                        'enquanto i <= 10 faça',
+                        '  escreva i',
+                        '  i := i + 1',
+                        'fim'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
+                });
+
+                it('Para', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var soma := 0',
+                        'para i de 1 até 10 faça',
+                        '  soma := soma + i',
+                        'fim',
+                        'escreva "A soma é {soma}."'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
+                });
+            });
+
+            describe('Declarações de funções', () => {
+                it('Função de uma linha, argumentos com tipo definido, sem dica de retorno', () => {
+                    const retornoLexador = lexador.mapear([
+                        'soma(x: Inteiro, y: Inteiro) = x + y'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Função de uma linha, argumentos com tipo definido, com dica de retorno', () => {
+                    const retornoLexador = lexador.mapear([
+                        'soma(x: Inteiro, y: Inteiro): Inteiro = x + y'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+            });
+
+            describe('Declarações de tuplas', () => {
+                it('Dupla', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Trio', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Quarteto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Quinteto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Sexteto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5, 6)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Septeto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5, 6, 7)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Octeto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5, 6, 7, 8)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Noneto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5, 6, 7, 8, 9)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Deceto', () => {
+                    const retornoLexador = lexador.mapear([
+                        'var t := (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+            });
+
+            describe('Tipos', () => {
+                it('Trivial', () => {
+                    const retornoLexador = lexador.mapear([
+                        'tipo Quadrado',
+                        '  lado: Inteiro',
+                        '  area() = lado * lado',
+                        '  perimetro() = 4 * lado',
+                        'fim'
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+            });
+        });
+
+        describe('Cenários de Falha', () => {
+            it('Falha - Declaração de múltiplas variáveis inteiras, lado direito diferente de esquerdo', () => {
+                const retornoLexador = lexador.mapear(['var a, b, c := 10, 20'], -1);
+                expect(() => avaliadorSintatico.analisar(retornoLexador, -1)).toThrow(ErroAvaliadorSintatico);
+                expect(() => avaliadorSintatico.analisar(retornoLexador, -1)).toThrow(
+                    expect.objectContaining({
+                        message: "Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.",
+                    })
+                );
             });
         });
     });
diff --git a/testes/potigol/interpretador.test.ts b/testes/potigol/interpretador.test.ts
index 2947307e..1cbe0e94 100644
--- a/testes/potigol/interpretador.test.ts
+++ b/testes/potigol/interpretador.test.ts
@@ -1,17 +1,17 @@
 import { AvaliadorSintaticoPotigol } from "../../fontes/avaliador-sintatico/dialetos";
-import { InterpretadorBase } from "../../fontes/interpretador";
+import { InterpretadorPotigol } from "../../fontes/interpretador/dialetos";
 import { LexadorPotigol } from "../../fontes/lexador/dialetos";
 
 describe('Interpretador', () => {
     describe('interpretar()', () => {
         let lexador: LexadorPotigol;
         let avaliadorSintatico: AvaliadorSintaticoPotigol;
-        let interpretador: InterpretadorBase;
+        let interpretador: InterpretadorPotigol;
 
         beforeEach(() => {
             lexador = new LexadorPotigol();
             avaliadorSintatico = new AvaliadorSintaticoPotigol();
-            interpretador = new InterpretadorBase(process.cwd());
+            interpretador = new InterpretadorPotigol(process.cwd());
         });
 
         it('Trivial', async () => {
@@ -24,5 +24,25 @@ describe('Interpretador', () => {
 
             expect(retornoInterpretador.erros).toHaveLength(0);
         });
+
+        describe.skip('Tipos e objetos', () => {
+            it('Trivial', async () => {
+                const retornoLexador = lexador.mapear([
+                    'tipo Quadrado',
+                    '  area() = lado * lado',
+                    '  lado: Inteiro',
+                    '  perimetro() = 4 * lado',
+                    'fim',
+                    'q1 = Quadrado(10)',
+                    'escreva q1.area()',
+                    'escreva q1.perimetro()'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+    
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+    
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+        });
     });
 });
diff --git a/testes/potigol/primitivas/primitivas-numero.test.ts b/testes/potigol/primitivas/primitivas-numero.test.ts
new file mode 100644
index 00000000..072f1755
--- /dev/null
+++ b/testes/potigol/primitivas/primitivas-numero.test.ts
@@ -0,0 +1,74 @@
+import primitivasNumero from "../../../fontes/bibliotecas/dialetos/potigol/primitivas-numero";
+import { InterpretadorPotigol } from "../../../fontes/interpretador/dialetos/potigol/interpretador-potigol";
+
+describe('Primitivas de número - Potigol', () => {
+    let interpretador: InterpretadorPotigol;
+
+    beforeEach(() => {
+        interpretador = new InterpretadorPotigol(
+            process.cwd(), 
+            false
+        )
+    });
+
+    describe('arredonde()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasNumero.arredonde(interpretador, 123.45);
+            expect(resultado).toStrictEqual(124);
+        });
+    });
+
+    describe('caractere()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasNumero.caractere(interpretador, 97);
+            expect(resultado).toStrictEqual('a');
+        });
+    });
+
+    describe('inteiro()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasNumero.inteiro(interpretador, 123.45);
+            expect(resultado).toStrictEqual(123);
+        });
+    });
+
+    describe('qual_tipo()', () => {
+        it('Inteiro', async () => {
+            const resultado = await primitivasNumero.qual_tipo(interpretador, 123);
+            expect(resultado).toStrictEqual('Inteiro');
+        });
+
+        it('Real', async () => {
+            const resultado = await primitivasNumero.qual_tipo(interpretador, 123.45);
+            expect(resultado).toStrictEqual('Real');
+        });
+    });
+
+    describe('piso()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasNumero.piso(interpretador, 123.45);
+            expect(resultado).toStrictEqual(123);
+        });
+    });
+
+    describe('real()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasNumero.real(interpretador, 123.45);
+            expect(resultado).toStrictEqual(123.45);
+        });
+    });
+
+    describe('teto()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasNumero.teto(interpretador, 123.45);
+            expect(resultado).toStrictEqual(124);
+        });
+    });
+    
+    describe('texto()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasNumero.texto(interpretador, 123.45);
+            expect(resultado).toStrictEqual('123.45');
+        });
+    });
+});
diff --git a/testes/potigol/primitivas/primitivas-texto.test.ts b/testes/potigol/primitivas/primitivas-texto.test.ts
new file mode 100644
index 00000000..ce705941
--- /dev/null
+++ b/testes/potigol/primitivas/primitivas-texto.test.ts
@@ -0,0 +1,173 @@
+import primitivasTexto from '../../../fontes/bibliotecas/dialetos/potigol/primitivas-texto';
+import { InterpretadorPotigol } from '../../../fontes/interpretador/dialetos/potigol/interpretador-potigol';
+
+describe('Primitivas de texto - Potigol', () => {
+    let interpretador: InterpretadorPotigol;
+
+    beforeEach(() => {
+        interpretador = new InterpretadorPotigol(
+            process.cwd(), 
+            false
+        )
+    });
+
+    describe('cabeça()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.cabeça(interpretador, 'abc');
+            expect(resultado).toStrictEqual('a');
+        });
+    });
+
+    describe('cauda()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.cauda(interpretador, 'abc');
+            expect(resultado).toStrictEqual('bc');
+        });
+    });
+
+    describe('contém()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.contém(interpretador, 'abc', 'b');
+            expect(resultado).toBe(true);
+        });
+
+        it('Elemento inexistente', async () => {
+            const resultado = await primitivasTexto.contém(interpretador, 'abc', 'f');
+            expect(resultado).toBe(false);
+        });
+    });
+
+    describe('descarte()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.descarte(interpretador, 'abcde', 2);
+            expect(resultado).toStrictEqual('cde');
+        });
+    });
+
+    describe('divida()', () => {
+        it('Sem separador como argumento', async () => {
+            const resultado = await primitivasTexto.divida(interpretador, 'Um texto');
+            expect(resultado).toStrictEqual(['Um', 'texto']);
+        });
+
+        it('Com separador como argumento', async () => {
+            const resultado = await primitivasTexto.divida(interpretador, 'Um-texto', '-');
+            expect(resultado).toStrictEqual(['Um', 'texto']);
+        });
+    });
+
+    describe('insira()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.insira(interpretador, 'abc', 3, 'd');
+            expect(resultado).toStrictEqual('abdc');
+        });
+    });
+
+    describe('inteiro()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.inteiro(interpretador, '123');
+            expect(resultado).toStrictEqual(123);
+        });
+
+        it('Texto decimal', async () => {
+            const resultado = await primitivasTexto.inteiro(interpretador, '123.45');
+            expect(resultado).toStrictEqual(123);
+        });
+    });
+
+    describe('inverta()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.inverta(interpretador, 'abcde');
+            expect(resultado).toStrictEqual('edcba');
+        });
+    });
+
+    describe('junte()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.junte(interpretador, 'abc', '-');
+            expect(resultado).toStrictEqual('a-b-c');
+        });
+    });
+
+    describe('lista()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.lista(interpretador, 'abc');
+            expect(resultado).toStrictEqual(['a', 'b', 'c']);
+        });
+    });
+
+    describe('maiúsculo()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.maiúsculo(interpretador, 'Abc');
+            expect(resultado).toStrictEqual('ABC');
+        });
+    });
+
+    describe('minúsculo()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.minúsculo(interpretador, 'Abc');
+            expect(resultado).toStrictEqual('abc');
+        });
+    });
+
+    describe('ordene()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.ordene(interpretador, 'bca');
+            expect(resultado).toStrictEqual('abc');
+        });
+    });
+
+    describe('pegue()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.pegue(interpretador, 'abcde', 3);
+            expect(resultado).toStrictEqual('abc');
+        });
+    });
+
+    describe('posição()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.posição(interpretador, 'abcde', 'b');
+            expect(resultado).toStrictEqual(2);
+        });
+    });
+
+    describe('qual_tipo()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.qual_tipo(interpretador, 'bca');
+            expect(resultado).toStrictEqual('Texto');
+        });
+    });
+
+    describe('real()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.real(interpretador, '123.45');
+            expect(resultado).toStrictEqual(123.45);
+        });
+    });
+
+    describe('remova()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.remova(interpretador, 'abc', 2);
+            expect(resultado).toStrictEqual('ac');
+        });
+    });
+
+    describe('tamanho()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.tamanho(interpretador, 'abc');
+            expect(resultado).toStrictEqual(3);
+        });
+    });
+
+    describe('último()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasTexto.último(interpretador, 'abc');
+            expect(resultado).toStrictEqual('c');
+        });
+
+        it('Texto vazio', async () => {
+            const resultado = await primitivasTexto.último(interpretador, '');
+            expect(resultado).toStrictEqual('');
+        });
+    });
+});
\ No newline at end of file
diff --git a/testes/potigol/primitivas/primitivas-vetor.test.ts b/testes/potigol/primitivas/primitivas-vetor.test.ts
new file mode 100644
index 00000000..80ce44db
--- /dev/null
+++ b/testes/potigol/primitivas/primitivas-vetor.test.ts
@@ -0,0 +1,114 @@
+import primitivasVetor from '../../../fontes/bibliotecas/dialetos/potigol/primitivas-vetor';
+import { InterpretadorPotigol } from '../../../fontes/interpretador/dialetos/potigol/interpretador-potigol';
+
+describe('Primitivas de vetor - Potigol', () => {
+    let interpretador: InterpretadorPotigol;
+
+    beforeEach(() => {
+        interpretador = new InterpretadorPotigol(
+            process.cwd(), 
+            false
+        )
+    });
+
+    describe('cabeça()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.cabeça(interpretador, [1, 2, 3]);
+            expect(resultado).toStrictEqual(1);
+        });
+    });
+
+    describe('cauda()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.cauda(interpretador, [1, 2, 3]);
+            expect(resultado).toStrictEqual([2, 3]);
+        });
+    });
+
+    describe('contém()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.contém(interpretador, [1, 2, 3], 2);
+            expect(resultado).toBe(true);
+        });
+
+        it('Elemento inexistente', async () => {
+            const resultado = await primitivasVetor.contém(interpretador, [1, 2, 3], 4);
+            expect(resultado).toBe(false);
+        });
+    });
+
+    describe('descarte()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.descarte(interpretador, [2, 4, 6, 8, 10], 2);
+            expect(resultado).toStrictEqual([6, 8, 10]);
+        });
+    });
+
+    describe('inverta()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.inverta(interpretador, [2, 4, 6, 8, 10]);
+            expect(resultado).toStrictEqual([10, 8, 6, 4, 2]);
+        });
+    });
+
+    describe('junte()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.junte(interpretador, [2, 4, 6, 8, 10], '-');
+            expect(resultado).toStrictEqual('2-4-6-8-10');
+        });
+    });
+
+    describe('ordene()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.ordene(interpretador, [4, 8, 10, 2, 6]);
+            expect(resultado).toStrictEqual([2, 4, 6, 8, 10]);
+        });
+    });
+
+    describe('pegue()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.pegue(interpretador, [2, 4, 6, 8, 10], 3);
+            expect(resultado).toStrictEqual([2, 4, 6]);
+        });
+    });
+
+    describe('posição()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.posição(interpretador, [2, 4, 6, 8, 10], 8);
+            expect(resultado).toStrictEqual(4);
+        });
+    });
+
+    describe('remova()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.remova(interpretador, [2, 4, 6, 8, 10], 3);
+            expect(resultado).toStrictEqual([2, 4, 8, 10]);
+        });
+    });
+
+    describe('tamanho()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.tamanho(interpretador, [2, 4, 6, 8, 10]);
+            expect(resultado).toStrictEqual(5);
+        });
+    });
+
+    describe('último()', () => {
+        it('Trivial', async () => {
+            const resultado = await primitivasVetor.último(interpretador, [2, 4, 6, 8, 10]);
+            expect(resultado).toStrictEqual(10);
+        });
+    });
+
+    describe('vazia()', () => {
+        it('Lista com elementos', async () => {
+            const resultado = await primitivasVetor.vazia(interpretador, [2, 4, 6, 8, 10]);
+            expect(resultado).toBe(false);
+        });
+
+        it('Lista vazia', async () => {
+            const resultado = await primitivasVetor.vazia(interpretador, []);
+            expect(resultado).toBe(true);
+        });
+    });
+});
diff --git a/testes/tradutores/tradutor-python.test.ts b/testes/tradutores/tradutor-python.test.ts
index f4aa5a27..721019e1 100644
--- a/testes/tradutores/tradutor-python.test.ts
+++ b/testes/tradutores/tradutor-python.test.ts
@@ -323,7 +323,7 @@ describe('Tradutor Delégua -> Python', () => {
             expect(resultado).toMatch(/print\(20\)/i);
         });
 
-        it('se senão 01 -> if/else, código', () => {
+        it('se senão 01 -> if else, código', () => {
             const retornoLexador = lexador.mapear(
                 [
                     'var a = 20',
@@ -349,7 +349,7 @@ describe('Tradutor Delégua -> Python', () => {
             expect(resultado).toMatch(/print\('Não é 10 e não é 20'\)/i);
         });
 
-        it('se senão 02 -> if/elif/else, código', () => {
+        it.skip('se senão 02 -> if else, código', () => {
             const retornoLexador = lexador.mapear(
                 [
                     'var a = 20',
@@ -359,11 +359,8 @@ describe('Tradutor Delégua -> Python', () => {
                     '   escreva(20)',
                     '} senão se (a == 30) {',
                     '   escreva(30)',
-                    '} senão se (a == \'40\') {',
-                    '   escreva(\'40\')',
-                    '}',
-                    'senão {',
-                    "   escreva('Não é nenhum desses valores: 10, 20, 30, 40')",
+                    '} senão {',
+                    "   escreva('Não é nenhum desses valores: 10, 20, 30')",
                     '}',
                 ],
                 -1
@@ -378,26 +375,8 @@ describe('Tradutor Delégua -> Python', () => {
             expect(resultado).toMatch(/print\(20\)/i);
             expect(resultado).toMatch(/elif a \=\= 30:/i);
             expect(resultado).toMatch(/print\(30\)/i);
-            expect(resultado).toMatch(/elif a \=\= \'40\':/i);
-            expect(resultado).toMatch(/print\(\'40\'\)/i);
             expect(resultado).toMatch(/else:/i);
-            expect(resultado).toMatch(/print\('Não é nenhum desses valores: 10, 20, 30, 40'\)/i);
-        });
-
-        it('leia -> input', () => {
-            const retornoLexador = lexador.mapear(
-                [
-                    'var nome = leia(\'Digite seu nome: \')',
-                    'escreva(nome)'
-                ],
-                -1
-            );
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-
-            const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
-            expect(resultado).toBeTruthy();
-            expect(resultado).toMatch(/nome = input\(\'Digite seu nome: \'\)/i);
-            expect(resultado).toMatch(/print\(nome\)/i);
+            expect(resultado).toMatch(/print\('Não é nenhum desses valores: 10, 20, 30'\)/i);
         });
 
         it('isto -> this', () => {
@@ -429,56 +408,6 @@ describe('Tradutor Delégua -> Python', () => {
             expect(resultado).toMatch(/teste.mostrarValor\(\)/i);
         });
 
-        it('herda', () => {
-            const retornoLexador = lexador.mapear(
-                [
-                    'classe Animal {',
-                    'corre() {',
-                    'escreva("correndo");',
-                    '}',
-                    '}',
-                    'classe Cachorro herda Animal {}',
-                    'var thor = Cachorro();',
-                    'thor.corre();',
-                ],
-                -1
-            );
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-
-            const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
-            expect(resultado).toBeTruthy();
-            expect(resultado).toMatch(/class Animal:/i);
-            expect(resultado).toMatch(/def corre\(self\):/i);
-            expect(resultado).toMatch(/print\('correndo'\)/i);
-            expect(resultado).toMatch(/class Cachorro\(Animal\):/i);
-            expect(resultado).toMatch(/pass/i);
-            expect(resultado).toMatch(/thor = Cachorro\(\)/i);
-            expect(resultado).toMatch(/thor.corre\(\)/i);
-        });
-
-        it('método de classe vazio - metodo de classe vazio com \'pass\'', () => {
-            const retornoLexador = lexador.mapear(
-                [
-                    'classe Cachorro {',
-                    'corre() {',
-                    '}',
-                    '}',
-                    'var thor = Cachorro();',
-                    'thor.corre();',
-                ],
-                -1
-            );
-            const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-
-            const resultado = tradutor.traduzir(retornoAvaliadorSintatico.declaracoes);
-            expect(resultado).toBeTruthy();
-            expect(resultado).toMatch(/class Cachorro:/i);
-            expect(resultado).toMatch(/def corre\(self\):/i);
-            expect(resultado).toMatch(/pass/i);
-            expect(resultado).toMatch(/thor = Cachorro\(\)/i);
-            expect(resultado).toMatch(/thor.corre\(\)/i);
-        });
-
         it('tente - pegue - finalmente -> try - except - finally', () => {
             const retornoLexador = lexador.mapear(
                 [