Diversos ajustes influenciados por Potigol:

- Construto `ConstanteOuVariavel` passa a fazer parte apenas do dialeto Potigol;
- Expansão de parâmetros para função de classe (Potigol) não deve ocorrer na chamada no construtor.

fontes/construtos/binario.ts

@@ -3,14 +3,25 @@ import { Construto } from './construto';
 
 /**
  * Binário é uma estrutura com um operador e dois operandos: esquerda e direita.
- * Implementa as seguintes operações:
+ * Implementa as seguintes operações para Delégua e todos os dialetos:
  *
- * - `+` (Adição) e `+=` (Adição com Atribuição)
- * - `-` (Subtração) e `-=` (Subtração com Atribuição)
- * - `*` (Multiplicação) e `*=` (Multiplicação com Atribuição)
- * - `/` (Divisão) e `/=` (Divisão com Atribuição)
- * - `%` (Módulo) e `%=` (Módulo com Atribuição)
- * - `**` (Exponenciação)
+ * - `+` (Adição);
+ * - `-` (Subtração);
+ * - `*` (Multiplicação);
+ * - `/` (Divisão);
+ * - `%` (Módulo);
+ * 
+ * Algumas outras operações podem ser suportadas de dialeto para dialeto,
+ * como por exemplo:
+ * 
+ * - `+=` (Adição com Atribuição);
+ * - `-=` (Subtração com Atribuição);
+ * - `*=` (Multiplicação com Atribuição);
+ * - `/=` (Divisão com Atribuição);
+ * - `%=` (Módulo com Atribuição);
+ * - `**` (Exponenciação);
+ * - `::` (Concatenação);
+ * - `\` (Divisão inteira).
  */
 export class Binario<TTipoSimbolo extends string = string> implements Construto {
     linha: number;

fontes/construtos/index.ts

@@ -9,7 +9,6 @@ export * from './binario';
 export * from './chamada';
 export * from './comentario';
 export * from './constante';
-export * from './constante-ou-variavel';
 export * from './construto';
 export * from './decorador';
 export * from './definir-valor';

fontes/estruturas/delegua-funcao.ts

@@ -1,7 +1,7 @@
 import { Chamavel } from './chamavel';
 import { EspacoVariaveis } from '../espaco-variaveis';
 
-import { InterpretadorInterface, VariavelInterface, VisitanteComumInterface } from '../interfaces';
+import { VisitanteComumInterface } from '../interfaces';
 import { RetornoQuebra } from '../quebras';
 import { ObjetoDeleguaClasse } from './objeto-delegua-classe';
 import { FuncaoConstruto } from '../construtos';
@@ -41,7 +41,7 @@ export class DeleguaFuncao extends Chamavel {
      * @returns {string} A representação da função como texto.
      */
     paraTexto(): string {
-        if (this.nome === null) return '<função>';
+        if (!this.nome) return '<função>';
         let resultado = `<função ${this.nome}`;
         let parametros = '';
         let retorno = '';
@@ -82,6 +82,18 @@ export class DeleguaFuncao extends Chamavel {
         return this.paraTexto();
     }
 
+    private resolverParametrosEspalhados(argumentos: Array<ArgumentoInterface>, indiceArgumentoAtual: number) {
+        const argumentosResolvidos = [];
+        for (let i = indiceArgumentoAtual; i < argumentos.length; indiceArgumentoAtual++) {
+            const argumentoAtual = argumentos[i];
+            argumentosResolvidos.push(
+                argumentoAtual && argumentoAtual.hasOwnProperty('valor') ? argumentoAtual.valor : argumentoAtual
+            );
+        }
+
+        return argumentosResolvidos;
+    }
+
     async chamar(visitante: VisitanteComumInterface, argumentos: Array<ArgumentoInterface>): Promise<any> {
         const ambiente = new EspacoVariaveis();
         const parametros = this.declaracao.parametros || [];
@@ -91,13 +103,7 @@ export class DeleguaFuncao extends Chamavel {
 
             const nome = parametro['nome'].lexema;
             if (parametro.abrangencia === 'multiplo') {
-                const argumentosResolvidos = [];
-                for (let indiceArgumentoAtual = i; indiceArgumentoAtual < argumentos.length; indiceArgumentoAtual++) {
-                    const argumentoAtual = argumentos[indiceArgumentoAtual];
-                    argumentosResolvidos.push(
-                        argumentoAtual && argumentoAtual.hasOwnProperty('valor') ? argumentoAtual.valor : argumentoAtual
-                    );
-                }
+                const argumentosResolvidos = this.resolverParametrosEspalhados(argumentos, i);
 
                 // TODO: Verificar se `imutavel` é `true` aqui mesmo.
                 ambiente.valores[nome] = { tipo: 'vetor', valor: argumentosResolvidos, imutavel: true };
@@ -118,7 +124,12 @@ export class DeleguaFuncao extends Chamavel {
                 imutavel: false,
             };
 
-            if (this.instancia.classe.dialetoRequerExpansaoPropriedadesEspacoVariaveis) {
+            // TODO: Apenass Potigol usa isso até então.
+            // Estudar mover isso para o dialeto.
+            if (
+                this.instancia.classe.dialetoRequerExpansaoPropriedadesEspacoVariaveis && 
+                this.nome !== 'construtor'
+            ) {
                 for (let [nomeCampo, valorCampo] of Object.entries(this.instancia.propriedades)) {
                     ambiente.valores[nomeCampo] = {
                         valor: valorCampo,

fontes/interfaces/visitante-comum-interface.ts

@@ -80,7 +80,7 @@ export interface VisitanteComumInterface {
     visitarDeclaracaoSe(declaracao: Se): Promise<any> | void;
     visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any> | void;
     visitarDeclaracaoTente(declaracao: Tente): Promise<any> | void;
-    visitarDeclaracaoVar(declaracao: Var): Promise<any | void>;
+    visitarDeclaracaoVar(declaracao: Var): Promise<any> | void;
     visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any> | void;
     visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<any> | void;
     visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel): Promise<any> | void;

fontes/interpretador/interpretador-base.ts

@@ -496,7 +496,13 @@ export class InterpretadorBase implements InterpretadorInterface {
         return resultado;
     }
 
-    protected eIgual(esquerda: VariavelInterface | any, direita: VariavelInterface | any): boolean {
+    /**
+     * Lógica para verificação de valores iguais, para Delégua e alguns dialetos.
+     * @param esquerda Uma variável.
+     * @param direita Outra variável.
+     * @returns Verdadeiro se são iguais. Falso em caso contrário.
+     */
+    eIgual(esquerda: VariavelInterface | any, direita: VariavelInterface | any): boolean {
         if (esquerda === null && direita === null) return true;
         if (esquerda === null) return false;
         return esquerda === direita;
@@ -1200,7 +1206,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         return await this.executarBloco(declaracao.declaracoes);
     }
 
-    protected async avaliacaoDeclaracaoVarOuConst(declaracao: Const | ConstMultiplo | Var | VarMultiplo): Promise<any> {
+    async avaliacaoDeclaracaoVarOuConst(declaracao: Const | ConstMultiplo | Var | VarMultiplo): Promise<any> {
         let valorOuOutraVariavel = null;
         if (declaracao.inicializador !== null) {
             valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);