Estrutura declarativa de classes

fontes/avaliador-sintatico/avaliador-sintatico.ts

@@ -50,6 +50,7 @@ import {
     Const,
     ParaCada,
     Falhar,
+    PropriedadeClasse,
 } from '../declaracoes';
 import { RetornoAvaliadorSintatico } from '../interfaces/retornos/retorno-avaliador-sintatico';
 import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
@@ -1276,12 +1277,40 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
 
         const metodos = [];
+        const propriedades = [];
         while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
-            metodos.push(this.funcao('método'));
+            // Se o símbolo atual é arroba, é um decorador.
+            // Caso contrário, verificamos o próximo símbolo.
+            if (this.simbolos[this.atual].tipo === tiposDeSimbolos.ARROBA) {
+                this.resolverDecorador();
+                continue;
+            }
+
+            // Se o próximo símbolo ao atual for um parênteses, é um método. 
+            // Caso contrário, é uma propriedade.
+            const proximoSimbolo = this.simbolos[this.atual + 1];
+            switch (proximoSimbolo.tipo) {
+                case tiposDeSimbolos.PARENTESE_ESQUERDO:
+                    metodos.push(this.funcao('método'));
+                    break;
+                case tiposDeSimbolos.DOIS_PONTOS:
+                    const nomePropriedade = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado identificador para nome de propriedade.');
+                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, 'Esperado dois-pontos após nome de propriedade.');
+                    const tipoPropriedade = this.avancarEDevolverAnterior();
+                    propriedades.push(
+                        new PropriedadeClasse(
+                            nomePropriedade,
+                            tipoPropriedade.lexema
+                        )
+                    );
+                    break;
+                default:
+                    throw this.erro(this.simbolos[this.atual], 'Esperado definição de método ou propriedade.');
+            }
         }
 
         this.consumir(tiposDeSimbolos.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
-        return new Classe(simbolo, superClasse, metodos, null, pilhaDecoradoresClasse);
+        return new Classe(simbolo, superClasse, metodos, propriedades, pilhaDecoradoresClasse);
     }
 
     /**

fontes/estruturas/delegua-classe.ts

@@ -1,5 +1,6 @@
 import { PropriedadeClasse } from '../declaracoes';
-import { VisitanteComumInterface } from '../interfaces';
+import { ErroEmTempoDeExecucao } from '../excecoes';
+import { SimboloInterface, VisitanteComumInterface } from '../interfaces';
 import { Chamavel } from './chamavel';
 import { DeleguaFuncao } from './delegua-funcao';
 import { ObjetoDeleguaClasse } from './objeto-delegua-classe';
@@ -8,18 +9,25 @@ import { ObjetoDeleguaClasse } from './objeto-delegua-classe';
  * Estrutura de declaração de classe.
  */
 export class DeleguaClasse extends Chamavel {
-    nome: string;
+    simboloOriginal: SimboloInterface;
     superClasse: DeleguaClasse;
     metodos: { [nome: string]: DeleguaFuncao };
     propriedades: PropriedadeClasse[];
     dialetoRequerExpansaoPropriedadesEspacoVariaveis: boolean;
-
-    constructor(nome?: string, superClasse?: any, metodos?: any, propriedades?: PropriedadeClasse[]) {
+    dialetoRequerDeclaracaoPropriedades: boolean;
+
+    constructor(
+        simboloOriginal?: SimboloInterface, 
+        superClasse?: DeleguaClasse, 
+        metodos?: { [nome: string]: DeleguaFuncao }, 
+        propriedades?: PropriedadeClasse[]
+    ) {
         super();
-        this.nome = nome;
+        this.simboloOriginal = simboloOriginal;
         this.superClasse = superClasse;
         this.metodos = metodos || {};
         this.propriedades = propriedades || [];
+        this.dialetoRequerDeclaracaoPropriedades = false;
     }
 
     encontrarMetodo(nome: string): DeleguaFuncao {
@@ -43,11 +51,15 @@ export class DeleguaClasse extends Chamavel {
             return this.superClasse.encontrarPropriedade(nome);
         }
 
+        if (this.dialetoRequerDeclaracaoPropriedades) {
+            throw new ErroEmTempoDeExecucao(this.simboloOriginal, `Propriedade "${nome}" não declarada na classe ${this.simboloOriginal.lexema}.`);
+        }
+
         return undefined;
     }
 
     paraTexto(): string {
-        let texto = `<classe ${this.nome}`;
+        let texto = `<classe ${this.simboloOriginal.lexema}`;
         for (let propriedade of this.propriedades) {
             texto += ` ${propriedade.nome}`;
             if (propriedade.tipo) {

fontes/estruturas/delegua-funcao.ts

@@ -64,7 +64,7 @@ export class DeleguaFuncao extends Chamavel {
             };
 
             if (this.instancia.classe.dialetoRequerExpansaoPropriedadesEspacoVariaveis) {
-                for (let [nomeCampo, valorCampo] of Object.entries(this.instancia.campos)) {
+                for (let [nomeCampo, valorCampo] of Object.entries(this.instancia.propriedades)) {
                     ambiente.valores[nomeCampo] = {
                         valor: valorCampo,
                         tipo: inferirTipoVariavel(valorCampo as any),

fontes/estruturas/objeto-delegua-classe.ts

@@ -2,31 +2,49 @@ import { ErroEmTempoDeExecucao } from '../excecoes';
 import { SimboloInterface } from '../interfaces';
 import { DeleguaClasse } from './delegua-classe';
 
+/**
+ * A instância de uma classe em Delégua.
+ * Possui propriedades e métodos. Propriedades são definidas localmente.
+ * Métodos são extraídos da definição de classe.
+ */
 export class ObjetoDeleguaClasse {
     classe: DeleguaClasse;
-    campos: any;
+    propriedades: {[nome: string]: any};
 
-    constructor(classe: any) {
+    constructor(classe: DeleguaClasse) {
         this.classe = classe;
-        this.campos = {};
+        this.propriedades = {};
+        if (this.classe.superClasse) {
+            for (let propriedade of this.classe.superClasse.propriedades) {
+                this.propriedades[propriedade.nome.lexema] = undefined;
+            }
+        }
+
+        for (let propriedade of classe.propriedades) {
+            this.propriedades[propriedade.nome.lexema] = undefined;
+        }
     }
 
     obter(simbolo: SimboloInterface): any {
-        if (this.campos.hasOwnProperty(simbolo.lexema)) {
-            return this.campos[simbolo.lexema];
+        if (this.propriedades.hasOwnProperty(simbolo.lexema)) {
+            return this.propriedades[simbolo.lexema];
         }
 
         const metodo = this.classe.encontrarMetodo(simbolo.lexema);
         if (metodo) return metodo.funcaoPorMetodoDeClasse(this);
 
-        throw new ErroEmTempoDeExecucao(simbolo, 'Método indefinido não recuperado.');
+        throw new ErroEmTempoDeExecucao(simbolo, `Método ou propriedade "${simbolo.lexema}" não existe neste objeto.`);
     }
 
     definir(simbolo: SimboloInterface, valor: any): void {
-        this.campos[simbolo.lexema] = valor;
+        if (this.classe.dialetoRequerDeclaracaoPropriedades && !this.propriedades.hasOwnProperty(simbolo.lexema)) {
+            throw new ErroEmTempoDeExecucao(simbolo, `Propriedade "${simbolo.lexema}" não foi definida na declaração da classe ${this.classe.simboloOriginal.lexema}.`);
+        }
+
+        this.propriedades[simbolo.lexema] = valor;
     }
 
     toString(): string {
-        return '<Objeto ' + this.classe.nome + '>';
+        return '<Objeto ' + this.classe.simboloOriginal.lexema + '>';
     }
 }

fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts

@@ -64,6 +64,12 @@ import { ArgumentoInterface } from '../../argumento-interface';
 export class InterpretadorEguaClassico implements InterpretadorInterface {
     resolvedor: ResolvedorInterface;
 
+    // Esta variável indica que propriedades de classes precisam ser
+    // declaradas para serem válidas.
+    // Égua não requer isso, mas precisamos ter o valor
+    // aqui por questões de compatibilidade com outros elementos.
+    requerDeclaracaoPropriedades: boolean = false;
+
     diretorioBase: any;
     funcaoDeRetorno: Function;
     locais: Map<Construto, number>;
@@ -848,7 +854,9 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
             metodos[metodoAtual.simbolo.lexema] = funcao;
         }
 
-        const deleguaClasse = new DeleguaClasse(declaracao.simbolo.lexema, superClasse, metodos);
+        const deleguaClasse = new DeleguaClasse(declaracao.simbolo, superClasse, metodos);
+        deleguaClasse.dialetoRequerExpansaoPropriedadesEspacoVariaveis = false;
+        deleguaClasse.dialetoRequerDeclaracaoPropriedades = false;
 
         // TODO: Recolocar isso se for necessário.
         /* if (superClasse !== null) {

fontes/interpretador/interpretador-base.ts

@@ -91,8 +91,18 @@ export class InterpretadorBase implements InterpretadorInterface {
     declaracoes: Declaracao[];
     resultadoInterpretador: Array<string> = [];
 
+    // Esta variável indica que uma propriedade de um objeto
+    // não precisa da palavra `isto` para ser acessada, ou seja, 
+    // `minhaPropriedade` e `isto.minhaPropriedade` são a mesma coisa.
+    // Potigol, por exemplo, é um dialeto que tem essa característica.
     expandirPropriedadesDeObjetosEmEspacoVariaveis: boolean;
 
+    // Esta variável indica que propriedades de classes precisam ser
+    // declaradas para serem válidas.
+    // Delégua e Pituguês são dialetos que requerem a declaração 
+    // de propriedades de classes.
+    requerDeclaracaoPropriedades: boolean;
+
     performance: boolean;
     funcaoDeRetorno: Function = null;
     funcaoDeRetornoMesmaLinha: Function = null;
@@ -127,6 +137,10 @@ export class InterpretadorBase implements InterpretadorInterface {
         // Para acessar uma variável de classe, não é preciso a palavra `isto`.
         this.expandirPropriedadesDeObjetosEmEspacoVariaveis = false;
 
+        // Por padrão é verdadeiro porque Delégua e Pituguês usam
+        // o interpretador base como implementação padrão.
+        this.requerDeclaracaoPropriedades = true;
+
         this.pilhaEscoposExecucao = new PilhaEscoposExecucao();
         const escopoExecucao: EscopoExecucao = {
             declaracoes: [],
@@ -1317,14 +1331,16 @@ export class InterpretadorBase implements InterpretadorInterface {
         }
 
         const deleguaClasse: DeleguaClasse = new DeleguaClasse(
-            declaracao.simbolo.lexema,
+            declaracao.simbolo,
             superClasse,
             metodos,
             declaracao.propriedades
         );
 
         deleguaClasse.dialetoRequerExpansaoPropriedadesEspacoVariaveis =
             this.expandirPropriedadesDeObjetosEmEspacoVariaveis;
+        deleguaClasse.dialetoRequerDeclaracaoPropriedades =
+            this.requerDeclaracaoPropriedades;
 
         // TODO: Recolocar isso se for necessário.
         /* if (superClasse !== null) {

testes/avaliador-sintatico.test.ts

@@ -145,7 +145,7 @@ describe('Avaliador sintático', () => {
                 expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
 
-            it('Sucesso - decorador classe', () => {
+            it('Sucesso - decorador de classe', () => {
                 const retornoLexador = lexador.mapear([
                     '@meu.decorador1',
                     '@meu.decorador2',
@@ -161,7 +161,7 @@ describe('Avaliador sintático', () => {
                 expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
 
-            it('Sucesso - decorador função', () => {
+            it('Sucesso - decorador de método de classe', () => {
                 const retornoLexador = lexador.mapear([
                     '@meu.decorador1',
                     'classe Teste {',