From 5c5293daa6fdd73008ebbe57b1c3cfded4aa970e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Douglas=20Gad=C3=AAlha?= <dgadelha@live.com>
Date: Sun, 10 Mar 2024 14:44:02 -0300
Subject: [PATCH] =?UTF-8?q?Otimiza=C3=A7=C3=A3o=20de=20desempenho=20da=20a?=
 =?UTF-8?q?n=C3=A1lise=20sem=C3=A2ntica?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 packages/antlr/src/PortugolErrorListener.ts   | 65 ++++++----------
 .../app/tab-start/tab-start.component.html    |  2 +-
 packages/parser/src/PortugolErrorChecker.ts   |  3 +-
 packages/parser/src/PortugolNode.ts           | 56 ++++++++------
 packages/parser/src/helpers/Tipo.ts           |  8 +-
 .../parser/src/helpers/express\303\265es.ts"  |  2 +-
 packages/parser/src/nodes/Arquivo.ts          | 29 +++----
 .../src/nodes/Atribui\303\247\303\243oCmd.ts" | 42 +++++-----
 ...\247\303\243oCompostaDivis\303\243oCmd.ts" | 10 +--
 ...CompostaMultiplica\303\247\303\243oCmd.ts" | 10 +--
 ...tribui\303\247\303\243oCompostaSomaCmd.ts" | 10 +--
 ...243oCompostaSubtra\303\247\303\243oCmd.ts" | 10 +--
 packages/parser/src/nodes/Bypass.ts           | 11 +--
 packages/parser/src/nodes/CadeiaExpr.ts       | 15 ++--
 packages/parser/src/nodes/CaractereExpr.ts    | 15 ++--
 packages/parser/src/nodes/CasoCmd.ts          | 31 ++++----
 .../src/nodes/CasoContr\303\241rioExpr.ts"    | 15 ++--
 .../nodes/ChamadaFun\303\247\303\243oExpr.ts" | 28 +++----
 packages/parser/src/nodes/Comando.ts          | 11 +--
 .../src/nodes/Declara\303\247\303\243oCmd.ts" | 65 ++++++++--------
 .../Declara\303\247\303\243oMatrizExpr.ts"    | 39 ++++------
 ...ra\303\247\303\243oVari\303\241velExpr.ts" | 27 +++----
 .../Declara\303\247\303\243oVetorExpr.ts"     | 33 ++++----
 .../DecrementoUn\303\241rioPrefixadoExpr.ts"  | 10 +--
 ...mentoUn\303\241rioP\303\263sfixadoExpr.ts" | 10 +--
 .../parser/src/nodes/Divis\303\243oExpr.ts"   | 10 +--
 packages/parser/src/nodes/EnquantoCmd.ts      | 27 +++----
 packages/parser/src/nodes/EscolhaCmd.ts       | 27 +++----
 .../parser/src/nodes/EscopoBibliotecaExpr.ts  | 10 +--
 .../parser/src/nodes/Express\303\243o.ts"     | 11 +--
 ...Express\303\243oEntrePar\303\252nteses.ts" | 23 ++----
 .../Express\303\243oMatem\303\241tica.ts"     | 35 ++++-----
 .../nodes/Express\303\243oUn\303\241ria.ts"   | 19 ++---
 .../src/nodes/Fa\303\247aEnquantoCmd.ts"      | 27 +++----
 .../parser/src/nodes/Fun\303\247\303\243o.ts" | 33 ++++----
 .../src/nodes/Inclus\303\243oBiblioteca.ts"   | 13 ++--
 .../IncrementoUn\303\241rioPrefixadoExpr.ts"  | 10 +--
 ...mentoUn\303\241rioP\303\263sfixadoExpr.ts" | 10 +--
 .../Inicializa\303\247\303\243oMatrizExpr.ts" | 23 +++---
 .../Inicializa\303\247\303\243oVetorExpr.ts"  | 21 ++---
 packages/parser/src/nodes/InteiroExpr.ts      | 15 ++--
 .../parser/src/nodes/L\303\263gicoExpr.ts"    | 17 +---
 .../src/nodes/MaisUn\303\241rioExpr.ts"       | 35 ++++-----
 .../src/nodes/MenosUn\303\241rioExpr.ts"      | 35 ++++-----
 .../nodes/Multiplica\303\247\303\243oExpr.ts" | 10 +--
 .../parser/src/nodes/M\303\263duloExpr.ts"    | 10 +--
 .../Nega\303\247\303\243oBitwiseExpr.ts"      | 23 ++----
 .../src/nodes/Nega\303\247\303\243oExpr.ts"   | 23 ++----
 packages/parser/src/nodes/Node.ts             | 19 +++--
 .../Opera\303\247\303\243oAndBitwiseExpr.ts"  | 10 +--
 ...a\303\247\303\243oAndL\303\263gicoExpr.ts" | 10 +--
 ...a\303\247\303\243oDiferen\303\247aExpr.ts" | 10 +--
 .../Opera\303\247\303\243oIgualdadeExpr.ts"   | 10 +--
 ...ra\303\247\303\243oMaiorOuIgualQueExpr.ts" | 10 +--
 .../Opera\303\247\303\243oMaiorQueExpr.ts"    | 10 +--
 ...ra\303\247\303\243oMenorOuIgualQueExpr.ts" | 10 +--
 .../Opera\303\247\303\243oMenorQueExpr.ts"    | 10 +--
 .../Opera\303\247\303\243oOrBitwiseExpr.ts"   | 10 +--
 ...ra\303\247\303\243oOrL\303\263gicoExpr.ts" | 10 +--
 .../Opera\303\247\303\243oShiftLeftExpr.ts"   | 10 +--
 .../Opera\303\247\303\243oShiftRightExpr.ts"  | 10 +--
 .../nodes/Opera\303\247\303\243oXorExpr.ts"   | 10 +--
 packages/parser/src/nodes/ParaCmd.ts          | 45 +++++------
 packages/parser/src/nodes/PareCmd.ts          | 16 +---
 .../parser/src/nodes/Par\303\242metro.ts"     | 59 +++++---------
 packages/parser/src/nodes/RealExpr.ts         | 18 ++---
 .../src/nodes/Refer\303\252nciaArrayExpr.ts"  | 27 +++----
 .../src/nodes/Refer\303\252nciaMatrizExpr.ts" | 35 +++------
 .../src/nodes/Refer\303\252nciaVarExpr.ts"    | 27 +++----
 packages/parser/src/nodes/RetorneCmd.ts       | 23 +++---
 packages/parser/src/nodes/SeCmd.ts            | 33 ++++----
 .../parser/src/nodes/Sen\303\243oCmd.ts"      | 21 ++---
 packages/parser/src/nodes/SomaExpr.ts         | 10 +--
 .../src/nodes/Subtra\303\247\303\243oExpr.ts" | 10 +--
 packages/parser/src/nodes/UnhandledNode.ts    |  8 +-
 packages/parser/src/nodes/VazioExpr.ts        | 12 +--
 packages/parser/src/nodes/index.ts            | 77 +++++++++++++++++++
 .../src/nodes/\303\215ndiceArrayExpr.ts"      | 23 ++----
 packages/worker/webpack.config.js             | 12 +++
 79 files changed, 618 insertions(+), 1011 deletions(-)

diff --git a/packages/antlr/src/PortugolErrorListener.ts b/packages/antlr/src/PortugolErrorListener.ts
index 71a00de2..f08d9f26 100644
--- a/packages/antlr/src/PortugolErrorListener.ts
+++ b/packages/antlr/src/PortugolErrorListener.ts
@@ -50,21 +50,10 @@ export class PortugolCodeError extends Error {
 
     const possibleSymbol = ctx.getPayload() as Token | ParseTree | ParserRuleContext | undefined;
 
-    if (
-      possibleSymbol &&
-      possibleSymbol.hasOwnProperty("column") &&
-      possibleSymbol.hasOwnProperty("line")
-    ) {
+    if (possibleSymbol && possibleSymbol.hasOwnProperty("column") && possibleSymbol.hasOwnProperty("line")) {
       const { line, column } = possibleSymbol as unknown as Token;
 
-      return new PortugolCodeError(
-        message,
-        ctx,
-        line,
-        column,
-        line,
-        column + ctx.getText().length,
-      );
+      return new PortugolCodeError(message, ctx, line, column, line, column + ctx.getText().length);
     }
 
     return new PortugolCodeError(message, ctx, 1, 1, 1, 2 + ctx.getText().length);
@@ -99,36 +88,30 @@ export class PortugolErrorListener implements ANTLRErrorListener {
   }
 
   reportAmbiguity(
-    recognizer: Parser,
-    dfa: DFA,
-    startIndex: number,
-    stopIndex: number,
-    exact: boolean,
-    ambigAlts: BitSet | undefined,
-    configs: ATNConfigSet,
-  ) {
-    console.debug("reportAmbiguity", { recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs });
-  }
+    _recognizer: Parser,
+    _dfa: DFA,
+    _startIndex: number,
+    _stopIndex: number,
+    _exact: boolean,
+    _ambigAlts: BitSet | undefined,
+    _configs: ATNConfigSet,
+  ) {}
 
   reportAttemptingFullContext(
-    recognizer: Parser,
-    dfa: DFA,
-    startIndex: number,
-    stopIndex: number,
-    conflictingAlts: BitSet | undefined,
-    configs: ATNConfigSet,
-  ) {
-    console.debug("reportAttemptingFullContext", { recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs });
-  }
+    _recognizer: Parser,
+    _dfa: DFA,
+    _startIndex: number,
+    _stopIndex: number,
+    _conflictingAlts: BitSet | undefined,
+    _configs: ATNConfigSet,
+  ) {}
 
   reportContextSensitivity(
-    recognizer: Parser,
-    dfa: DFA,
-    startIndex: number,
-    stopIndex: number,
-    prediction: number,
-    configs: ATNConfigSet,
-  ) {
-    console.debug("reportContextSensitivity", { recognizer, dfa, startIndex, stopIndex, prediction, configs });
-  }
+    _recognizer: Parser,
+    _dfa: DFA,
+    _startIndex: number,
+    _stopIndex: number,
+    _prediction: number,
+    _configs: ATNConfigSet,
+  ) {}
 }
diff --git a/packages/ide/src/app/tab-start/tab-start.component.html b/packages/ide/src/app/tab-start/tab-start.component.html
index 12a87942..f053075e 100644
--- a/packages/ide/src/app/tab-start/tab-start.component.html
+++ b/packages/ide/src/app/tab-start/tab-start.component.html
@@ -73,9 +73,9 @@
   <hr />
 
   <h4>📰&nbsp;&nbsp;Novidades</h4>
+  <p><strong>10/03/2024:</strong> Otimização de desempenho na análise semântica</p>
   <p><strong>09/03/2024:</strong> Novo domínio: <strong>portugol.dev</strong> e experimento com propagandas</p>
   <p><strong>08/03/2024:</strong> Melhorias de performance na interface da plataforma</p>
-  <p><strong>17/01/2024:</strong> Melhorias nas verificações de erros (comparação lógica e bibliotecas)</p>
 </section>
 
 <ins
diff --git a/packages/parser/src/PortugolErrorChecker.ts b/packages/parser/src/PortugolErrorChecker.ts
index 75ae91b3..43b05927 100644
--- a/packages/parser/src/PortugolErrorChecker.ts
+++ b/packages/parser/src/PortugolErrorChecker.ts
@@ -9,7 +9,6 @@ import { CharStream, CommonTokenStream } from "antlr4ng";
 
 import errorCheckers from "./errors/index.js";
 import { ParseError } from "./helpers/ParseError.js";
-import { Arquivo } from "./nodes/index.js";
 import { PortugolNode } from "./PortugolNode.js";
 
 export class PortugolErrorChecker {
@@ -32,7 +31,7 @@ export class PortugolErrorChecker {
     this.errorListener.reset();
 
     try {
-      const arquivo = this.portugolNode.visit(tree) as Arquivo;
+      const arquivo = this.portugolNode.visit(tree);
       const errors: PortugolCodeError[] = [];
 
       for (const checker of errorCheckers) {
diff --git a/packages/parser/src/PortugolNode.ts b/packages/parser/src/PortugolNode.ts
index a85a8aaf..9b3144cb 100644
--- a/packages/parser/src/PortugolNode.ts
+++ b/packages/parser/src/PortugolNode.ts
@@ -1,7 +1,7 @@
-import { PortugolVisitor } from "@portugol-webstudio/antlr";
-import { ParserRuleContext, ParseTree, AbstractParseTreeVisitor } from "antlr4ng";
+import { ArquivoContext, PortugolVisitor } from "@portugol-webstudio/antlr";
+import { ParseTree, AbstractParseTreeVisitor } from "antlr4ng";
 
-import { Bypass, UnhandledNode, Node, ContextNodeMap } from "./nodes/index.js";
+import { Node, Arquivo, ContextNodeObj, UnhandledNode, Bypass } from "./nodes/index.js";
 
 export interface Empty {}
 
@@ -14,38 +14,46 @@ export class PortugolNode extends AbstractParseTreeVisitor<Empty> implements Por
     throw new Error("Shouldn't need to aggregate results");
   }
 
-  visitChildrenArray(node: ParseTree): Node[] {
-    const result: Array<Node | undefined> = [];
-    const n = node.getChildCount();
+  visitChildrenFromParent(ctx: ParseTree, parent: Node) {
+    for (let i = 0; i < ctx.getChildCount(); i++) {
+      const child = ctx.getChild(i);
 
-    for (let i = 0; i < n; i++) {
-      const c = node.getChild(i);
-      const childResult = this.visit(c!);
-
-      // Vírgulas
-      if (childResult instanceof UnhandledNode && childResult.type === "TerminalNode") {
+      if (!child || child.constructor.name === "TerminalNode") {
         continue;
       }
 
-      if (childResult instanceof Bypass) {
-        result.push(...this.visitChildrenArray(childResult.ctx as ParseTree));
-        continue;
-      }
+      this.visitFromParent(child, parent);
+    }
+  }
+
+  visitFromParent(ctx: ParseTree, parent: Node) {
+    const ctor = ContextNodeObj[ctx.constructor.name];
+    let obj;
 
-      result.push(childResult);
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (ctor) {
+      obj = new ctor(ctx);
+    } else {
+      obj = new UnhandledNode(ctx, ctx.constructor.name);
     }
 
-    return result.map(x => x!);
+    if (obj instanceof Bypass) {
+      this.visitChildrenFromParent(ctx, parent);
+    } else {
+      parent.addChild(obj);
+      this.visitChildrenFromParent(ctx, obj);
+    }
   }
 
   visit(ctx: ParseTree) {
-    const children = this.visitChildrenArray(ctx);
-    const ctor = ContextNodeMap.get(ctx.constructor as new (...args: any[]) => ParserRuleContext);
-
-    if (ctor) {
-      return new ctor(ctx, children);
+    if (ctx.constructor.name !== "ArquivoContext") {
+      throw new Error("O algoritmo Portugol deve-se iniciar com um contexto de arquivo (palavra-chave 'programa')");
     }
 
-    return new UnhandledNode(ctx, ctx.constructor.name, ctx.getText(), children);
+    const arquivo = new Arquivo(ctx as ArquivoContext);
+
+    this.visitChildrenFromParent(ctx, arquivo);
+
+    return arquivo;
   }
 }
diff --git a/packages/parser/src/helpers/Tipo.ts b/packages/parser/src/helpers/Tipo.ts
index 020f6af0..1e531db9 100644
--- a/packages/parser/src/helpers/Tipo.ts
+++ b/packages/parser/src/helpers/Tipo.ts
@@ -24,16 +24,18 @@ export function parseTipoPrimitivo(tipo: TerminalNode | null): TipoPrimitivo {
     return TipoPrimitivo.VAZIO;
   }
 
-  switch (tipo.getText()) {
+  const text = tipo.getText();
+
+  switch (text) {
     case "inteiro":
     case "real":
     case "cadeia":
     case "logico":
     case "vazio":
     case "caracter":
-      return tipo.getText() as TipoPrimitivo;
+      return text as TipoPrimitivo;
 
     default:
-      throw new Error(`Tipo desconhecido: ${tipo.getText()}`);
+      throw new Error(`Tipo desconhecido: ${text}`);
   }
 }
diff --git "a/packages/parser/src/helpers/express\303\265es.ts" "b/packages/parser/src/helpers/express\303\265es.ts"
index e4b0eac1..4dcab18d 100644
--- "a/packages/parser/src/helpers/express\303\265es.ts"
+++ "b/packages/parser/src/helpers/express\303\265es.ts"
@@ -143,7 +143,7 @@ export function resolverResultadoExpressão(expressão: Expressão, escopo: Esco
     case IncrementoUnárioPósfixadoExpr:
     case DecrementoUnárioPrefixadoExpr:
     case DecrementoUnárioPósfixadoExpr:
-      return resolverResultadoExpressão((expressão as ExpressãoUnária).variável, escopo);
+      return resolverResultadoExpressão((expressão as ExpressãoUnária<any>).variável, escopo);
 
     case ExpressãoEntreParênteses:
       return resolverResultadoExpressão((expressão as ExpressãoEntreParênteses).expressão, escopo);
diff --git a/packages/parser/src/nodes/Arquivo.ts b/packages/parser/src/nodes/Arquivo.ts
index 20fd4934..48a58494 100644
--- a/packages/parser/src/nodes/Arquivo.ts
+++ b/packages/parser/src/nodes/Arquivo.ts
@@ -5,27 +5,22 @@ import { Função } from "./Função.js";
 import { InclusãoBiblioteca } from "./InclusãoBiblioteca.js";
 import { Node } from "./Node.js";
 
-export class Arquivo extends Node {
+export class Arquivo extends Node<ArquivoContext> {
   bibliotecas: InclusãoBiblioteca[] = [];
   declarações: DeclaraçãoCmd[] = [];
   funções: Função[] = [];
 
-  constructor(
-    public ctx: ArquivoContext,
-    public children: Node[],
-  ) {
-    super();
-
-    for (const child of children) {
-      if (child instanceof Função) {
-        this.funções.push(child);
-      } else if (child instanceof InclusãoBiblioteca) {
-        this.bibliotecas.push(child);
-      } else if (child instanceof DeclaraçãoCmd) {
-        this.declarações.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Função) {
+      this.funções.push(child);
+    } else if (child instanceof InclusãoBiblioteca) {
+      this.bibliotecas.push(child);
+    } else if (child instanceof DeclaraçãoCmd) {
+      this.declarações.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Atribui\303\247\303\243oCmd.ts" "b/packages/parser/src/nodes/Atribui\303\247\303\243oCmd.ts"
index c7951f15..5b59b86e 100644
--- "a/packages/parser/src/nodes/Atribui\303\247\303\243oCmd.ts"
+++ "b/packages/parser/src/nodes/Atribui\303\247\303\243oCmd.ts"
@@ -1,4 +1,4 @@
-import { ParserRuleContext } from "antlr4ng";
+import { ParseTree } from "antlr4ng";
 
 import { Comando } from "./Comando.js";
 import { Expressão } from "./Expressão.js";
@@ -8,34 +8,28 @@ import { ReferênciaMatrizExpr } from "./ReferênciaMatrizExpr.js";
 import { ReferênciaVarExpr } from "./ReferênciaVarExpr.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class AtribuiçãoCmd extends Comando {
+export class AtribuiçãoCmd<T extends ParseTree = ParseTree> extends Comando<T> {
   variável: ReferênciaVarExpr | ReferênciaArrayExpr | ReferênciaMatrizExpr;
   expressão: Expressão;
 
-  constructor(
-    public ctx: ParserRuleContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  addChild(child: Node) {
+    super.addChild(child);
 
-    for (const child of children) {
-      if (
-        (child instanceof ReferênciaVarExpr ||
-          child instanceof ReferênciaArrayExpr ||
-          child instanceof ReferênciaMatrizExpr) &&
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        !this.variável
-      ) {
-        this.variável = child;
-      } else if (child instanceof Expressão) {
-        invariant(!this.expressão, child.ctx, "Expressão já definida");
-        this.expressão = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+    if (
+      (child instanceof ReferênciaVarExpr ||
+        child instanceof ReferênciaArrayExpr ||
+        child instanceof ReferênciaMatrizExpr) &&
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      !this.variável
+    ) {
+      this.variável = child;
+    } else if (child instanceof Expressão) {
+      invariant(!this.expressão, child.ctx, "Expressão já definida");
+      this.expressão = child;
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.variável, ctx, "Variável não definida");
-    invariant(this.expressão, ctx, "Expressão não definida");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaDivis\303\243oCmd.ts" "b/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaDivis\303\243oCmd.ts"
index 452b4040..a8253f5e 100644
--- "a/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaDivis\303\243oCmd.ts"
+++ "b/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaDivis\303\243oCmd.ts"
@@ -1,13 +1,5 @@
 import { AtribuicaoCompostaDivisaoContext } from "@portugol-webstudio/antlr";
 
 import { AtribuiçãoCmd } from "./AtribuiçãoCmd.js";
-import { Node } from "./Node.js";
 
-export class AtribuiçãoCompostaDivisãoCmd extends AtribuiçãoCmd {
-  constructor(
-    public ctx: AtribuicaoCompostaDivisaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class AtribuiçãoCompostaDivisãoCmd extends AtribuiçãoCmd<AtribuicaoCompostaDivisaoContext> {}
diff --git "a/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaMultiplica\303\247\303\243oCmd.ts" "b/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaMultiplica\303\247\303\243oCmd.ts"
index c654b0ec..7b0eda16 100644
--- "a/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaMultiplica\303\247\303\243oCmd.ts"
+++ "b/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaMultiplica\303\247\303\243oCmd.ts"
@@ -1,13 +1,5 @@
 import { AtribuicaoCompostaMultiplicacaoContext } from "@portugol-webstudio/antlr";
 
 import { AtribuiçãoCmd } from "./AtribuiçãoCmd.js";
-import { Node } from "./Node.js";
 
-export class AtribuiçãoCompostaMultiplicaçãoCmd extends AtribuiçãoCmd {
-  constructor(
-    public ctx: AtribuicaoCompostaMultiplicacaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class AtribuiçãoCompostaMultiplicaçãoCmd extends AtribuiçãoCmd<AtribuicaoCompostaMultiplicacaoContext> {}
diff --git "a/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaSomaCmd.ts" "b/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaSomaCmd.ts"
index 9051d2b4..989787fb 100644
--- "a/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaSomaCmd.ts"
+++ "b/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaSomaCmd.ts"
@@ -1,13 +1,5 @@
 import { AtribuicaoCompostaSomaContext } from "@portugol-webstudio/antlr";
 
 import { AtribuiçãoCmd } from "./AtribuiçãoCmd.js";
-import { Node } from "./Node.js";
 
-export class AtribuiçãoCompostaSomaCmd extends AtribuiçãoCmd {
-  constructor(
-    public ctx: AtribuicaoCompostaSomaContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class AtribuiçãoCompostaSomaCmd extends AtribuiçãoCmd<AtribuicaoCompostaSomaContext> {}
diff --git "a/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaSubtra\303\247\303\243oCmd.ts" "b/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaSubtra\303\247\303\243oCmd.ts"
index 2e72c7a8..12b05de6 100644
--- "a/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaSubtra\303\247\303\243oCmd.ts"
+++ "b/packages/parser/src/nodes/Atribui\303\247\303\243oCompostaSubtra\303\247\303\243oCmd.ts"
@@ -1,13 +1,5 @@
 import { AtribuicaoCompostaSubtracaoContext } from "@portugol-webstudio/antlr";
 
 import { AtribuiçãoCmd } from "./AtribuiçãoCmd.js";
-import { Node } from "./Node.js";
 
-export class AtribuiçãoCompostaSubtraçãoCmd extends AtribuiçãoCmd {
-  constructor(
-    public ctx: AtribuicaoCompostaSubtracaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class AtribuiçãoCompostaSubtraçãoCmd extends AtribuiçãoCmd<AtribuicaoCompostaSubtracaoContext> {}
diff --git a/packages/parser/src/nodes/Bypass.ts b/packages/parser/src/nodes/Bypass.ts
index 097b965c..fc0912ad 100644
--- a/packages/parser/src/nodes/Bypass.ts
+++ b/packages/parser/src/nodes/Bypass.ts
@@ -1,12 +1,3 @@
-import { ParserRuleContext } from "antlr4ng";
-
 import { Node } from "./Node.js";
 
-export class Bypass extends Node {
-  constructor(
-    public ctx: ParserRuleContext,
-    public children: Node[] = [],
-  ) {
-    super();
-  }
-}
+export class Bypass extends Node {}
diff --git a/packages/parser/src/nodes/CadeiaExpr.ts b/packages/parser/src/nodes/CadeiaExpr.ts
index 682eed63..396bbab6 100644
--- a/packages/parser/src/nodes/CadeiaExpr.ts
+++ b/packages/parser/src/nodes/CadeiaExpr.ts
@@ -3,21 +3,18 @@ import { StringContext } from "@portugol-webstudio/antlr";
 import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 
-export class CadeiaExpr extends Expressão {
+export class CadeiaExpr extends Expressão<StringContext> {
   conteúdo: string;
 
-  constructor(
-    public ctx: StringContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  constructor(public ctx: StringContext) {
+    super(ctx);
 
     const text = ctx.STRING().getText();
 
     this.conteúdo = text.substring(1, text.length - 1);
+  }
 
-    for (const child of children) {
-      this.unexpectedChild(child);
-    }
+  addChild(child: Node) {
+    this.unexpectedChild(child);
   }
 }
diff --git a/packages/parser/src/nodes/CaractereExpr.ts b/packages/parser/src/nodes/CaractereExpr.ts
index 4d18cfb0..9899777e 100644
--- a/packages/parser/src/nodes/CaractereExpr.ts
+++ b/packages/parser/src/nodes/CaractereExpr.ts
@@ -4,23 +4,20 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class CaractereExpr extends Expressão {
+export class CaractereExpr extends Expressão<CaracterContext> {
   conteúdo: string;
 
-  constructor(
-    public ctx: CaracterContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  constructor(public ctx: CaracterContext) {
+    super(ctx);
 
     const text = ctx.CARACTER().getText();
 
     this.conteúdo = text.substring(1, text.length - 1);
 
     invariant(this.conteúdo.length === 1, ctx, "Caractere inválido");
+  }
 
-    for (const child of children) {
-      this.unexpectedChild(child);
-    }
+  addChild(child: Node) {
+    this.unexpectedChild(child);
   }
 }
diff --git a/packages/parser/src/nodes/CasoCmd.ts b/packages/parser/src/nodes/CasoCmd.ts
index a3edfb57..95aafdf2 100644
--- a/packages/parser/src/nodes/CasoCmd.ts
+++ b/packages/parser/src/nodes/CasoCmd.ts
@@ -6,33 +6,30 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class CasoCmd extends Comando {
+export class CasoCmd extends Comando<CasoContext> {
   condição: Expressão;
   instruções: Array<Expressão | Comando> = [];
 
-  constructor(
-    public ctx: CasoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  constructor(public ctx: CasoContext) {
+    super(ctx);
 
     const contrárioCtx = ctx.CONTRARIO();
 
     if (contrárioCtx) {
-      this.condição = new CasoContrárioExpr(contrárioCtx, []);
+      this.condição = new CasoContrárioExpr(contrárioCtx);
     }
+  }
 
-    for (const child of children) {
-      if (child instanceof Expressão && child.ctx === ctx.expressao()) {
-        invariant(!this.condição, child.ctx, "Condição já definida");
-        this.condição = child;
-      } else if (child instanceof Comando || child instanceof Expressão) {
-        this.instruções.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão && child.ctx === this.ctx.expressao()) {
+      invariant(!this.condição, child.ctx, "Condição já definida");
+      this.condição = child;
+    } else if (child instanceof Comando || child instanceof Expressão) {
+      this.instruções.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.condição, ctx, "Condição não definida");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/CasoContr\303\241rioExpr.ts" "b/packages/parser/src/nodes/CasoContr\303\241rioExpr.ts"
index 6a8533ff..cf6ea4ae 100644
--- "a/packages/parser/src/nodes/CasoContr\303\241rioExpr.ts"
+++ "b/packages/parser/src/nodes/CasoContr\303\241rioExpr.ts"
@@ -1,20 +1,17 @@
-import { TerminalNode } from "antlr4ng";
+import { ParseTree } from "antlr4ng";
 
 import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
 export class CasoContrárioExpr extends Expressão {
-  constructor(
-    public ctx: TerminalNode,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  constructor(public ctx: ParseTree) {
+    super(ctx);
 
     invariant(ctx.getText() === "contrario", ctx);
+  }
 
-    for (const child of children) {
-      this.unexpectedChild(child);
-    }
+  addChild(child: Node) {
+    this.unexpectedChild(child);
   }
 }
diff --git "a/packages/parser/src/nodes/ChamadaFun\303\247\303\243oExpr.ts" "b/packages/parser/src/nodes/ChamadaFun\303\247\303\243oExpr.ts"
index d7b5f9e4..1030be3a 100644
--- "a/packages/parser/src/nodes/ChamadaFun\303\247\303\243oExpr.ts"
+++ "b/packages/parser/src/nodes/ChamadaFun\303\247\303\243oExpr.ts"
@@ -3,26 +3,18 @@ import { ChamadaFuncaoContext } from "@portugol-webstudio/antlr";
 import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 
-export class ChamadaFunçãoExpr extends Expressão {
-  nome: string;
+export class ChamadaFunçãoExpr extends Expressão<ChamadaFuncaoContext> {
+  nome = this.ctx.ID().getText();
   argumentos: Expressão[] = [];
-  escopoBiblioteca?: string;
+  escopoBiblioteca?: string = this.ctx.escopoBiblioteca()?.ID()?.getText();
 
-  constructor(
-    public ctx: ChamadaFuncaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    this.nome = ctx.ID().getText();
-    this.escopoBiblioteca = ctx.escopoBiblioteca()?.ID()?.getText();
-
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        this.argumentos.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      this.argumentos.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git a/packages/parser/src/nodes/Comando.ts b/packages/parser/src/nodes/Comando.ts
index 10922f23..59a66f68 100644
--- a/packages/parser/src/nodes/Comando.ts
+++ b/packages/parser/src/nodes/Comando.ts
@@ -1,12 +1,5 @@
-import { ParserRuleContext } from "antlr4ng";
+import { ParseTree } from "antlr4ng";
 
 import { Node } from "./Node.js";
 
-export class Comando extends Node {
-  constructor(
-    public ctx: ParserRuleContext,
-    public children: Node[],
-  ) {
-    super();
-  }
-}
+export class Comando<T extends ParseTree = ParseTree> extends Node<T> {}
diff --git "a/packages/parser/src/nodes/Declara\303\247\303\243oCmd.ts" "b/packages/parser/src/nodes/Declara\303\247\303\243oCmd.ts"
index 65a27d84..c1e7b45c 100644
--- "a/packages/parser/src/nodes/Declara\303\247\303\243oCmd.ts"
+++ "b/packages/parser/src/nodes/Declara\303\247\303\243oCmd.ts"
@@ -9,55 +9,52 @@ import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 import { Tipo, parseTipoPrimitivo } from "../helpers/Tipo.js";
 
-export class DeclaraçãoCmd extends Comando {
+export class DeclaraçãoCmd extends Comando<DeclaracaoContext> {
   nome: string;
   tipo: Tipo;
   expressão?: Expressão;
   constante: boolean;
 
-  constructor(
-    public ctx: DeclaracaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  constructor(public ctx: DeclaracaoContext) {
+    super(ctx);
 
     invariant(ctx.parent instanceof ListaDeclaracoesContext, ctx);
 
     this.tipo = { primitivo: parseTipoPrimitivo(ctx.parent.TIPO()) };
     this.constante = Boolean(ctx.parent.CONSTANTE());
+  }
 
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        invariant(!this.expressão, child.ctx, "Expressão já definida");
-
-        if (child instanceof DeclaraçãoVetorExpr) {
-          this.nome = child.nome;
-          this.tipo = {
-            dimensão: "vetor",
-            tamanho: child.tamanho,
-            primitivo: this.tipo.primitivo,
-          };
-
-          this.expressão = child.inicialização;
-        } else if (child instanceof DeclaraçãoMatrizExpr) {
-          this.nome = child.nome;
-          this.tipo = {
-            dimensão: "matriz",
-            linhas: child.linhas,
-            colunas: child.colunas,
-            primitivo: this.tipo.primitivo,
-          };
-        } else if (child instanceof DeclaraçãoVariávelExpr) {
-          this.nome = child.nome;
-          this.expressão = child.valor;
-        } else {
-          this.unexpectedChild(child);
-        }
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      invariant(!this.expressão, child.ctx, "Expressão já definida");
+
+      if (child instanceof DeclaraçãoVetorExpr) {
+        this.nome = child.nome;
+        this.tipo = {
+          dimensão: "vetor",
+          tamanho: child.tamanho,
+          primitivo: this.tipo.primitivo,
+        };
+
+        this.expressão = child.inicialização;
+      } else if (child instanceof DeclaraçãoMatrizExpr) {
+        this.nome = child.nome;
+        this.tipo = {
+          dimensão: "matriz",
+          linhas: child.linhas,
+          colunas: child.colunas,
+          primitivo: this.tipo.primitivo,
+        };
+      } else if (child instanceof DeclaraçãoVariávelExpr) {
+        this.nome = child.nome;
+        this.expressão = child.valor;
       } else {
         this.unexpectedChild(child);
       }
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.nome, ctx, "Nome não definido");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Declara\303\247\303\243oMatrizExpr.ts" "b/packages/parser/src/nodes/Declara\303\247\303\243oMatrizExpr.ts"
index 024cb14e..df2d9519 100644
--- "a/packages/parser/src/nodes/Declara\303\247\303\243oMatrizExpr.ts"
+++ "b/packages/parser/src/nodes/Declara\303\247\303\243oMatrizExpr.ts"
@@ -7,36 +7,29 @@ import { Node } from "./Node.js";
 import { ReferênciaVarExpr } from "./ReferênciaVarExpr.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class DeclaraçãoMatrizExpr extends Expressão {
-  nome: string;
+export class DeclaraçãoMatrizExpr extends Expressão<DeclaracaoMatrizContext> {
+  nome = this.ctx.ID().getText();
   linhas?: InteiroExpr | ReferênciaVarExpr;
   colunas?: InteiroExpr | ReferênciaVarExpr;
   valor?: Expressão;
 
-  constructor(
-    public ctx: DeclaracaoMatrizContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    this.nome = ctx.ID().getText();
-
-    for (const child of children) {
-      if (child instanceof InteiroExpr || child instanceof ReferênciaVarExpr) {
-        if (!this.linhas) {
-          this.linhas = child;
-          // eslint-disable-next-line no-negated-condition
-        } else if (!this.colunas) {
-          this.colunas = child;
-        } else {
-          this.unexpectedChild(child);
-        }
-      } else if (child instanceof InicializaçãoMatrizExpr) {
-        invariant(!this.valor, child.ctx, "Valor já definido");
-        this.valor = child;
+  addChild(child: Node) {
+    if (child instanceof InteiroExpr || child instanceof ReferênciaVarExpr) {
+      if (!this.linhas) {
+        this.linhas = child;
+        // eslint-disable-next-line no-negated-condition
+      } else if (!this.colunas) {
+        this.colunas = child;
       } else {
         this.unexpectedChild(child);
       }
+    } else if (child instanceof InicializaçãoMatrizExpr) {
+      invariant(!this.valor, child.ctx, "Valor já definido");
+      this.valor = child;
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Declara\303\247\303\243oVari\303\241velExpr.ts" "b/packages/parser/src/nodes/Declara\303\247\303\243oVari\303\241velExpr.ts"
index f028760f..c76c8582 100644
--- "a/packages/parser/src/nodes/Declara\303\247\303\243oVari\303\241velExpr.ts"
+++ "b/packages/parser/src/nodes/Declara\303\247\303\243oVari\303\241velExpr.ts"
@@ -4,25 +4,18 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class DeclaraçãoVariávelExpr extends Expressão {
-  nome: string;
+export class DeclaraçãoVariávelExpr extends Expressão<DeclaracaoVariavelContext> {
+  nome = this.ctx.ID().getText();
   valor?: Expressão;
 
-  constructor(
-    public ctx: DeclaracaoVariavelContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    this.nome = ctx.ID().getText();
-
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        invariant(!this.valor, child.ctx, "Valor já definido");
-        this.valor = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      invariant(!this.valor, child.ctx, "Valor já definido");
+      this.valor = child;
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Declara\303\247\303\243oVetorExpr.ts" "b/packages/parser/src/nodes/Declara\303\247\303\243oVetorExpr.ts"
index fa1b89c9..0ac14da1 100644
--- "a/packages/parser/src/nodes/Declara\303\247\303\243oVetorExpr.ts"
+++ "b/packages/parser/src/nodes/Declara\303\247\303\243oVetorExpr.ts"
@@ -7,29 +7,22 @@ import { Node } from "./Node.js";
 import { ReferênciaVarExpr } from "./ReferênciaVarExpr.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class DeclaraçãoVetorExpr extends Expressão {
-  nome: string;
+export class DeclaraçãoVetorExpr extends Expressão<DeclaracaoArrayContext> {
+  nome = this.ctx.ID().getText();
   tamanho?: InteiroExpr | ReferênciaVarExpr;
   inicialização?: Expressão;
 
-  constructor(
-    public ctx: DeclaracaoArrayContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    this.nome = ctx.ID().getText();
-
-    for (const child of children) {
-      if (child instanceof InteiroExpr || child instanceof ReferênciaVarExpr) {
-        invariant(!this.tamanho, child.ctx, "Tamanho já definido");
-        this.tamanho = child;
-      } else if (child instanceof InicializaçãoVetorExpr) {
-        invariant(!this.inicialização, child.ctx, "Inicialização já definida");
-        this.inicialização = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof InteiroExpr || child instanceof ReferênciaVarExpr) {
+      invariant(!this.tamanho, child.ctx, "Tamanho já definido");
+      this.tamanho = child;
+    } else if (child instanceof InicializaçãoVetorExpr) {
+      invariant(!this.inicialização, child.ctx, "Inicialização já definida");
+      this.inicialização = child;
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/DecrementoUn\303\241rioPrefixadoExpr.ts" "b/packages/parser/src/nodes/DecrementoUn\303\241rioPrefixadoExpr.ts"
index 6822dba6..c3c178fe 100644
--- "a/packages/parser/src/nodes/DecrementoUn\303\241rioPrefixadoExpr.ts"
+++ "b/packages/parser/src/nodes/DecrementoUn\303\241rioPrefixadoExpr.ts"
@@ -1,13 +1,5 @@
 import { DecrementoUnarioPrefixadoContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoUnária } from "./ExpressãoUnária.js";
-import { Node } from "./Node.js";
 
-export class DecrementoUnárioPrefixadoExpr extends ExpressãoUnária {
-  constructor(
-    public ctx: DecrementoUnarioPrefixadoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class DecrementoUnárioPrefixadoExpr extends ExpressãoUnária<DecrementoUnarioPrefixadoContext> {}
diff --git "a/packages/parser/src/nodes/DecrementoUn\303\241rioP\303\263sfixadoExpr.ts" "b/packages/parser/src/nodes/DecrementoUn\303\241rioP\303\263sfixadoExpr.ts"
index 129e21aa..a6751fc3 100644
--- "a/packages/parser/src/nodes/DecrementoUn\303\241rioP\303\263sfixadoExpr.ts"
+++ "b/packages/parser/src/nodes/DecrementoUn\303\241rioP\303\263sfixadoExpr.ts"
@@ -1,13 +1,5 @@
 import { DecrementoUnarioPosfixadoContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoUnária } from "./ExpressãoUnária.js";
-import { Node } from "./Node.js";
 
-export class DecrementoUnárioPósfixadoExpr extends ExpressãoUnária {
-  constructor(
-    public ctx: DecrementoUnarioPosfixadoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class DecrementoUnárioPósfixadoExpr extends ExpressãoUnária<DecrementoUnarioPosfixadoContext> {}
diff --git "a/packages/parser/src/nodes/Divis\303\243oExpr.ts" "b/packages/parser/src/nodes/Divis\303\243oExpr.ts"
index eb09f80c..1c128018 100644
--- "a/packages/parser/src/nodes/Divis\303\243oExpr.ts"
+++ "b/packages/parser/src/nodes/Divis\303\243oExpr.ts"
@@ -1,13 +1,5 @@
 import { DivisaoContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class DivisãoExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: DivisaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class DivisãoExpr extends ExpressãoMatemática<DivisaoContext> {}
diff --git a/packages/parser/src/nodes/EnquantoCmd.ts b/packages/parser/src/nodes/EnquantoCmd.ts
index 9f7993ec..a527df16 100644
--- a/packages/parser/src/nodes/EnquantoCmd.ts
+++ b/packages/parser/src/nodes/EnquantoCmd.ts
@@ -5,27 +5,20 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class EnquantoCmd extends Comando {
+export class EnquantoCmd extends Comando<EnquantoContext> {
   condição: Expressão;
   instruções: Array<Expressão | Comando> = [];
 
-  constructor(
-    public ctx: EnquantoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão && child.ctx === ctx.expressao()) {
-        invariant(!this.condição, child.ctx, "Condição já definida");
-        this.condição = child;
-      } else if (child instanceof Comando || child instanceof Expressão) {
-        this.instruções.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão && child.ctx === this.ctx.expressao()) {
+      invariant(!this.condição, child.ctx, "Condição já definida");
+      this.condição = child;
+    } else if (child instanceof Comando || child instanceof Expressão) {
+      this.instruções.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.condição, ctx, "Condição não definida");
+    this.children.push(child);
   }
 }
diff --git a/packages/parser/src/nodes/EscolhaCmd.ts b/packages/parser/src/nodes/EscolhaCmd.ts
index e62de3d5..3b1621a6 100644
--- a/packages/parser/src/nodes/EscolhaCmd.ts
+++ b/packages/parser/src/nodes/EscolhaCmd.ts
@@ -6,27 +6,20 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class EscolhaCmd extends Comando {
+export class EscolhaCmd extends Comando<EscolhaContext> {
   condição: Expressão;
   casos: CasoCmd[] = [];
 
-  constructor(
-    public ctx: EscolhaContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão && child.ctx === ctx.expressao()) {
-        invariant(!this.condição, child.ctx, "Condição já definida");
-        this.condição = child;
-      } else if (child instanceof CasoCmd) {
-        this.casos.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão && child.ctx === this.ctx.expressao()) {
+      invariant(!this.condição, child.ctx, "Condição já definida");
+      this.condição = child;
+    } else if (child instanceof CasoCmd) {
+      this.casos.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.condição, ctx, "Condição não definida");
+    this.children.push(child);
   }
 }
diff --git a/packages/parser/src/nodes/EscopoBibliotecaExpr.ts b/packages/parser/src/nodes/EscopoBibliotecaExpr.ts
index 8b0715b7..c0843a7a 100644
--- a/packages/parser/src/nodes/EscopoBibliotecaExpr.ts
+++ b/packages/parser/src/nodes/EscopoBibliotecaExpr.ts
@@ -1,17 +1,13 @@
 import { EscopoBibliotecaContext } from "@portugol-webstudio/antlr";
 
 import { Expressão } from "./Expressão.js";
-import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class EscopoBibliotecaExpr extends Expressão {
+export class EscopoBibliotecaExpr extends Expressão<EscopoBibliotecaContext> {
   nome: string;
 
-  constructor(
-    public ctx: EscopoBibliotecaContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  constructor(public ctx: EscopoBibliotecaContext) {
+    super(ctx);
 
     const nome = ctx.ID()?.getText();
 
diff --git "a/packages/parser/src/nodes/Express\303\243o.ts" "b/packages/parser/src/nodes/Express\303\243o.ts"
index 5d1f5ad8..0f661d1f 100644
--- "a/packages/parser/src/nodes/Express\303\243o.ts"
+++ "b/packages/parser/src/nodes/Express\303\243o.ts"
@@ -1,12 +1,5 @@
-import { ParserRuleContext, TerminalNode } from "antlr4ng";
+import { ParseTree } from "antlr4ng";
 
 import { Node } from "./Node.js";
 
-export class Expressão extends Node {
-  constructor(
-    public ctx: ParserRuleContext | TerminalNode,
-    public children: Node[],
-  ) {
-    super();
-  }
-}
+export class Expressão<T extends ParseTree = ParseTree> extends Node<T> {}
diff --git "a/packages/parser/src/nodes/Express\303\243oEntrePar\303\252nteses.ts" "b/packages/parser/src/nodes/Express\303\243oEntrePar\303\252nteses.ts"
index 7f8663cb..a59599bd 100644
--- "a/packages/parser/src/nodes/Express\303\243oEntrePar\303\252nteses.ts"
+++ "b/packages/parser/src/nodes/Express\303\243oEntrePar\303\252nteses.ts"
@@ -4,24 +4,17 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class ExpressãoEntreParênteses extends Expressão {
+export class ExpressãoEntreParênteses extends Expressão<ExpressaoEntreParentesesContext> {
   expressão: Expressão;
 
-  constructor(
-    public ctx: ExpressaoEntreParentesesContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        invariant(!this.expressão, child.ctx, "Expressão já definida");
-        this.expressão = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      invariant(!this.expressão, child.ctx, "Expressão já definida");
+      this.expressão = child;
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.expressão, ctx, "Expressão não definida");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Express\303\243oMatem\303\241tica.ts" "b/packages/parser/src/nodes/Express\303\243oMatem\303\241tica.ts"
index be4c4571..9a429d5f 100644
--- "a/packages/parser/src/nodes/Express\303\243oMatem\303\241tica.ts"
+++ "b/packages/parser/src/nodes/Express\303\243oMatem\303\241tica.ts"
@@ -1,36 +1,27 @@
-import { ParserRuleContext } from "antlr4ng";
+import { ParseTree } from "antlr4ng";
 
 import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
-import { invariant } from "../helpers/nodes.js";
 
-export class ExpressãoMatemática extends Expressão {
+export class ExpressãoMatemática<T extends ParseTree = ParseTree> extends Expressão<T> {
   esquerda: Expressão;
   direita: Expressão;
 
-  constructor(
-    public ctx: ParserRuleContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (!this.esquerda) {
-          this.esquerda = child;
-          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, no-negated-condition
-        } else if (!this.direita) {
-          this.direita = child;
-        } else {
-          this.unexpectedChild(child);
-        }
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (!this.esquerda) {
+        this.esquerda = child;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, no-negated-condition
+      } else if (!this.direita) {
+        this.direita = child;
       } else {
         this.unexpectedChild(child);
       }
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.esquerda, ctx, "Lado esquerdo da expressão matemática não definido");
-    invariant(this.direita, ctx, "Lado direito da expressão matemática não definido");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Express\303\243oUn\303\241ria.ts" "b/packages/parser/src/nodes/Express\303\243oUn\303\241ria.ts"
index 92f85300..b71ba1ec 100644
--- "a/packages/parser/src/nodes/Express\303\243oUn\303\241ria.ts"
+++ "b/packages/parser/src/nodes/Express\303\243oUn\303\241ria.ts"
@@ -2,23 +2,14 @@ import {
   DecrementoUnarioPosfixadoContext,
   IncrementoUnarioPosfixadoContext,
   IncrementoUnarioPrefixadoContext,
+  ReferenciaParaVariavelContext,
 } from "@portugol-webstudio/antlr";
 
 import { Expressão } from "./Expressão.js";
-import { Node } from "./Node.js";
 import { ReferênciaVarExpr } from "./ReferênciaVarExpr.js";
 
-export class ExpressãoUnária extends Expressão {
-  variável: ReferênciaVarExpr;
-
-  constructor(
-    public ctx: DecrementoUnarioPosfixadoContext | IncrementoUnarioPrefixadoContext | IncrementoUnarioPosfixadoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    const newCtx = Object.assign(ctx, { escopoBiblioteca: () => null });
-
-    this.variável = new ReferênciaVarExpr(newCtx, []);
-  }
+export class ExpressãoUnária<
+  T extends DecrementoUnarioPosfixadoContext | IncrementoUnarioPrefixadoContext | IncrementoUnarioPosfixadoContext,
+> extends Expressão<T> {
+  variável = new ReferênciaVarExpr(this.ctx as unknown as ReferenciaParaVariavelContext);
 }
diff --git "a/packages/parser/src/nodes/Fa\303\247aEnquantoCmd.ts" "b/packages/parser/src/nodes/Fa\303\247aEnquantoCmd.ts"
index 576921e2..e7e2843a 100644
--- "a/packages/parser/src/nodes/Fa\303\247aEnquantoCmd.ts"
+++ "b/packages/parser/src/nodes/Fa\303\247aEnquantoCmd.ts"
@@ -5,27 +5,20 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class FaçaEnquantoCmd extends Comando {
+export class FaçaEnquantoCmd extends Comando<FacaEnquantoContext> {
   condição: Expressão;
   instruções: Array<Expressão | Comando> = [];
 
-  constructor(
-    public ctx: FacaEnquantoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão && child.ctx === ctx.expressao()) {
-        invariant(!this.condição, child.ctx, "Condição já definida");
-        this.condição = child;
-      } else if (child instanceof Comando || child instanceof Expressão) {
-        this.instruções.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão && child.ctx === this.ctx.expressao()) {
+      invariant(!this.condição, child.ctx, "Condição já definida");
+      this.condição = child;
+    } else if (child instanceof Comando || child instanceof Expressão) {
+      this.instruções.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.condição, ctx, "Condição não definida");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Fun\303\247\303\243o.ts" "b/packages/parser/src/nodes/Fun\303\247\303\243o.ts"
index ffecb4d2..875ebd9d 100644
--- "a/packages/parser/src/nodes/Fun\303\247\303\243o.ts"
+++ "b/packages/parser/src/nodes/Fun\303\247\303\243o.ts"
@@ -6,29 +6,22 @@ import { Node } from "./Node.js";
 import { Parâmetro } from "./Parâmetro.js";
 import { Tipo, parseTipoPrimitivo } from "../helpers/Tipo.js";
 
-export class Função extends Node {
-  nome: string;
+export class Função extends Node<DeclaracaoFuncaoContext> {
+  nome = this.ctx.ID().getText();
   parâmetros: Parâmetro[] = [];
-  retorno: Tipo;
+  retorno: Tipo = { primitivo: parseTipoPrimitivo(this.ctx.TIPO()) };
   instruções: Array<Expressão | Comando> = [];
 
-  constructor(
-    public ctx: DeclaracaoFuncaoContext,
-    public children: Node[],
-  ) {
-    super();
-
-    this.nome = ctx.ID().getText();
-    this.retorno = { primitivo: parseTipoPrimitivo(ctx.TIPO()) };
-
-    for (const child of children) {
-      if (child instanceof Parâmetro) {
-        this.parâmetros.push(child);
-      } else if (child instanceof Expressão || child instanceof Comando) {
-        this.instruções.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Parâmetro) {
+      this.parâmetros.push(child);
+    } else if (child instanceof Expressão || child instanceof Comando) {
+      this.instruções.push(child);
+    } else {
+      console.log(child);
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Inclus\303\243oBiblioteca.ts" "b/packages/parser/src/nodes/Inclus\303\243oBiblioteca.ts"
index 3333d386..d300cc81 100644
--- "a/packages/parser/src/nodes/Inclus\303\243oBiblioteca.ts"
+++ "b/packages/parser/src/nodes/Inclus\303\243oBiblioteca.ts"
@@ -3,15 +3,12 @@ import { InclusaoBibliotecaContext } from "@portugol-webstudio/antlr";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class InclusãoBiblioteca extends Node {
+export class InclusãoBiblioteca extends Node<InclusaoBibliotecaContext> {
   nome: string;
   alias?: string;
 
-  constructor(
-    public ctx: InclusaoBibliotecaContext,
-    public children: Node[],
-  ) {
-    super();
+  constructor(public ctx: InclusaoBibliotecaContext) {
+    super(ctx);
 
     const idCtx = ctx.ID();
 
@@ -23,4 +20,8 @@ export class InclusãoBiblioteca extends Node {
       this.alias = idCtx[1].getText();
     }
   }
+
+  addChild(child: Node) {
+    this.unexpectedChild(child);
+  }
 }
diff --git "a/packages/parser/src/nodes/IncrementoUn\303\241rioPrefixadoExpr.ts" "b/packages/parser/src/nodes/IncrementoUn\303\241rioPrefixadoExpr.ts"
index 4bfed4af..da30f3cc 100644
--- "a/packages/parser/src/nodes/IncrementoUn\303\241rioPrefixadoExpr.ts"
+++ "b/packages/parser/src/nodes/IncrementoUn\303\241rioPrefixadoExpr.ts"
@@ -1,13 +1,5 @@
 import { IncrementoUnarioPrefixadoContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoUnária } from "./ExpressãoUnária.js";
-import { Node } from "./Node.js";
 
-export class IncrementoUnárioPrefixadoExpr extends ExpressãoUnária {
-  constructor(
-    public ctx: IncrementoUnarioPrefixadoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class IncrementoUnárioPrefixadoExpr extends ExpressãoUnária<IncrementoUnarioPrefixadoContext> {}
diff --git "a/packages/parser/src/nodes/IncrementoUn\303\241rioP\303\263sfixadoExpr.ts" "b/packages/parser/src/nodes/IncrementoUn\303\241rioP\303\263sfixadoExpr.ts"
index 832099d8..72ce1570 100644
--- "a/packages/parser/src/nodes/IncrementoUn\303\241rioP\303\263sfixadoExpr.ts"
+++ "b/packages/parser/src/nodes/IncrementoUn\303\241rioP\303\263sfixadoExpr.ts"
@@ -1,13 +1,5 @@
 import { IncrementoUnarioPosfixadoContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoUnária } from "./ExpressãoUnária.js";
-import { Node } from "./Node.js";
 
-export class IncrementoUnárioPósfixadoExpr extends ExpressãoUnária {
-  constructor(
-    public ctx: IncrementoUnarioPosfixadoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class IncrementoUnárioPósfixadoExpr extends ExpressãoUnária<IncrementoUnarioPosfixadoContext> {}
diff --git "a/packages/parser/src/nodes/Inicializa\303\247\303\243oMatrizExpr.ts" "b/packages/parser/src/nodes/Inicializa\303\247\303\243oMatrizExpr.ts"
index 6fa567be..08a300e1 100644
--- "a/packages/parser/src/nodes/Inicializa\303\247\303\243oMatrizExpr.ts"
+++ "b/packages/parser/src/nodes/Inicializa\303\247\303\243oMatrizExpr.ts"
@@ -1,23 +1,18 @@
-import { ParserRuleContext } from "antlr4ng";
+import { InicializacaoMatrizContext } from "packages/antlr/lib/PortugolParser.js";
 
 import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 
-export class InicializaçãoMatrizExpr extends Expressão {
+export class InicializaçãoMatrizExpr extends Expressão<InicializacaoMatrizContext> {
   linhas: Expressão[] = [];
 
-  constructor(
-    public ctx: ParserRuleContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        this.linhas.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      this.linhas.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Inicializa\303\247\303\243oVetorExpr.ts" "b/packages/parser/src/nodes/Inicializa\303\247\303\243oVetorExpr.ts"
index ee1320f5..a7bd7017 100644
--- "a/packages/parser/src/nodes/Inicializa\303\247\303\243oVetorExpr.ts"
+++ "b/packages/parser/src/nodes/Inicializa\303\247\303\243oVetorExpr.ts"
@@ -3,21 +3,16 @@ import { InicializacaoArrayContext } from "@portugol-webstudio/antlr";
 import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 
-export class InicializaçãoVetorExpr extends Expressão {
+export class InicializaçãoVetorExpr extends Expressão<InicializacaoArrayContext> {
   valores: Expressão[] = [];
 
-  constructor(
-    public ctx: InicializacaoArrayContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        this.valores.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      this.valores.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git a/packages/parser/src/nodes/InteiroExpr.ts b/packages/parser/src/nodes/InteiroExpr.ts
index 3be3af2d..90496561 100644
--- a/packages/parser/src/nodes/InteiroExpr.ts
+++ b/packages/parser/src/nodes/InteiroExpr.ts
@@ -4,14 +4,11 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class InteiroExpr extends Expressão {
+export class InteiroExpr extends Expressão<NumeroInteiroContext> {
   valor: number;
 
-  constructor(
-    public ctx: NumeroInteiroContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  constructor(public ctx: NumeroInteiroContext) {
+    super(ctx);
 
     const [int, hex] = [ctx.INT(), ctx.HEXADECIMAL()];
     const valor = int?.getText() ?? hex?.getText();
@@ -19,9 +16,9 @@ export class InteiroExpr extends Expressão {
     invariant(valor, ctx);
 
     this.valor = parseInt(valor, hex ? 16 : 10);
+  }
 
-    for (const child of children) {
-      this.unexpectedChild(child);
-    }
+  addChild(child: Node) {
+    this.unexpectedChild(child);
   }
 }
diff --git "a/packages/parser/src/nodes/L\303\263gicoExpr.ts" "b/packages/parser/src/nodes/L\303\263gicoExpr.ts"
index 27939766..1114cfe6 100644
--- "a/packages/parser/src/nodes/L\303\263gicoExpr.ts"
+++ "b/packages/parser/src/nodes/L\303\263gicoExpr.ts"
@@ -3,19 +3,10 @@ import { ValorLogicoContext } from "@portugol-webstudio/antlr";
 import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 
-export class LógicoExpr extends Expressão {
-  valor: boolean;
+export class LógicoExpr extends Expressão<ValorLogicoContext> {
+  valor = this.ctx.getText() === "verdadeiro";
 
-  constructor(
-    public ctx: ValorLogicoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    this.valor = ctx.getText() === "verdadeiro";
-
-    for (const child of children) {
-      this.unexpectedChild(child);
-    }
+  addChild(child: Node) {
+    this.unexpectedChild(child);
   }
 }
diff --git "a/packages/parser/src/nodes/MaisUn\303\241rioExpr.ts" "b/packages/parser/src/nodes/MaisUn\303\241rioExpr.ts"
index 07298718..b8028188 100644
--- "a/packages/parser/src/nodes/MaisUn\303\241rioExpr.ts"
+++ "b/packages/parser/src/nodes/MaisUn\303\241rioExpr.ts"
@@ -9,30 +9,23 @@ import { ReferênciaMatrizExpr } from "./ReferênciaMatrizExpr.js";
 import { ReferênciaVarExpr } from "./ReferênciaVarExpr.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class MaisUnárioExpr extends Expressão {
+export class MaisUnárioExpr extends Expressão<MaisUnarioContext> {
   valor: InteiroExpr | RealExpr | ReferênciaVarExpr | ReferênciaArrayExpr | ReferênciaMatrizExpr;
 
-  constructor(
-    public ctx: MaisUnarioContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (
-        child instanceof ReferênciaVarExpr ||
-        child instanceof ReferênciaArrayExpr ||
-        child instanceof ReferênciaMatrizExpr ||
-        child instanceof InteiroExpr ||
-        child instanceof RealExpr
-      ) {
-        invariant(!this.valor, child.ctx, "Valor já definido");
-        this.valor = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (
+      child instanceof ReferênciaVarExpr ||
+      child instanceof ReferênciaArrayExpr ||
+      child instanceof ReferênciaMatrizExpr ||
+      child instanceof InteiroExpr ||
+      child instanceof RealExpr
+    ) {
+      invariant(!this.valor, child.ctx, "Valor já definido");
+      this.valor = child;
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.valor, ctx, "Valor não definido");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/MenosUn\303\241rioExpr.ts" "b/packages/parser/src/nodes/MenosUn\303\241rioExpr.ts"
index 9f77eec8..39d498a6 100644
--- "a/packages/parser/src/nodes/MenosUn\303\241rioExpr.ts"
+++ "b/packages/parser/src/nodes/MenosUn\303\241rioExpr.ts"
@@ -9,30 +9,23 @@ import { ReferênciaMatrizExpr } from "./ReferênciaMatrizExpr.js";
 import { ReferênciaVarExpr } from "./ReferênciaVarExpr.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class MenosUnárioExpr extends Expressão {
+export class MenosUnárioExpr extends Expressão<MenosUnarioContext> {
   valor: InteiroExpr | RealExpr | ReferênciaVarExpr | ReferênciaArrayExpr | ReferênciaMatrizExpr;
 
-  constructor(
-    public ctx: MenosUnarioContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (
-        child instanceof ReferênciaVarExpr ||
-        child instanceof ReferênciaArrayExpr ||
-        child instanceof ReferênciaMatrizExpr ||
-        child instanceof InteiroExpr ||
-        child instanceof RealExpr
-      ) {
-        invariant(!this.valor, child.ctx, "Valor já definido");
-        this.valor = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (
+      child instanceof ReferênciaVarExpr ||
+      child instanceof ReferênciaArrayExpr ||
+      child instanceof ReferênciaMatrizExpr ||
+      child instanceof InteiroExpr ||
+      child instanceof RealExpr
+    ) {
+      invariant(!this.valor, child.ctx, "Valor já definido");
+      this.valor = child;
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.valor, ctx, "Valor não definido");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Multiplica\303\247\303\243oExpr.ts" "b/packages/parser/src/nodes/Multiplica\303\247\303\243oExpr.ts"
index 22b67475..3e610c08 100644
--- "a/packages/parser/src/nodes/Multiplica\303\247\303\243oExpr.ts"
+++ "b/packages/parser/src/nodes/Multiplica\303\247\303\243oExpr.ts"
@@ -1,13 +1,5 @@
 import { MultiplicacaoContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class MultiplicaçãoExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: MultiplicacaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class MultiplicaçãoExpr extends ExpressãoMatemática<MultiplicacaoContext> {}
diff --git "a/packages/parser/src/nodes/M\303\263duloExpr.ts" "b/packages/parser/src/nodes/M\303\263duloExpr.ts"
index 56ccbd82..1f8d565d 100644
--- "a/packages/parser/src/nodes/M\303\263duloExpr.ts"
+++ "b/packages/parser/src/nodes/M\303\263duloExpr.ts"
@@ -1,13 +1,5 @@
 import { ModuloContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class MóduloExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: ModuloContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class MóduloExpr extends ExpressãoMatemática<ModuloContext> {}
diff --git "a/packages/parser/src/nodes/Nega\303\247\303\243oBitwiseExpr.ts" "b/packages/parser/src/nodes/Nega\303\247\303\243oBitwiseExpr.ts"
index fcdb0c30..23bbda1e 100644
--- "a/packages/parser/src/nodes/Nega\303\247\303\243oBitwiseExpr.ts"
+++ "b/packages/parser/src/nodes/Nega\303\247\303\243oBitwiseExpr.ts"
@@ -4,24 +4,17 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class NegaçãoBitwiseExpr extends Expressão {
+export class NegaçãoBitwiseExpr extends Expressão<NegacaoBitwiseContext> {
   expressão: Expressão;
 
-  constructor(
-    public ctx: NegacaoBitwiseContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        invariant(!this.expressão, child.ctx, "Expressão já definida");
-        this.expressão = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      invariant(!this.expressão, child.ctx, "Expressão já definida");
+      this.expressão = child;
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.expressão, ctx, "Expressão não definida");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Nega\303\247\303\243oExpr.ts" "b/packages/parser/src/nodes/Nega\303\247\303\243oExpr.ts"
index 6d39e015..32502464 100644
--- "a/packages/parser/src/nodes/Nega\303\247\303\243oExpr.ts"
+++ "b/packages/parser/src/nodes/Nega\303\247\303\243oExpr.ts"
@@ -4,24 +4,17 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class NegaçãoExpr extends Expressão {
+export class NegaçãoExpr extends Expressão<NegacaoContext> {
   expressão: Expressão;
 
-  constructor(
-    public ctx: NegacaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        invariant(!this.expressão, child.ctx, "Expressão já definida");
-        this.expressão = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      invariant(!this.expressão, child.ctx, "Expressão já definida");
+      this.expressão = child;
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.expressão, ctx, "Expressão não definida");
+    this.children.push(child);
   }
 }
diff --git a/packages/parser/src/nodes/Node.ts b/packages/parser/src/nodes/Node.ts
index 1805b90b..c5996470 100644
--- a/packages/parser/src/nodes/Node.ts
+++ b/packages/parser/src/nodes/Node.ts
@@ -1,12 +1,13 @@
-import { ParseTree, ParserRuleContext, TerminalNode } from "antlr4ng";
+import { ParseTree } from "antlr4ng";
 
 import { ParseError } from "../helpers/ParseError.js";
 
-export abstract class Node {
-  ctx: ParserRuleContext | TerminalNode | ParseTree;
-  children: Node[];
+export abstract class Node<T extends ParseTree = ParseTree> {
+  children: Node[] = [];
 
-  unexpectedChild(child: Node) {
+  constructor(public ctx: T) {}
+
+  unexpectedChild(child: Node): never {
     const childName = child.ctx.constructor.name.replace("Context", "");
     const parentName = this.ctx.constructor.name.replace("Context", "");
 
@@ -14,9 +15,17 @@ export abstract class Node {
       throw new ParseError(`Expressão inválida: ${child.ctx.getText()}`, child.ctx);
     }
 
+    console.error(
+      new Error(`Encontrado '${childName}' como filho de '${parentName}', não esperado: '${child.ctx.getText()}'`),
+    );
+
     throw new ParseError(
       `Encontrado '${childName}' como filho de '${parentName}', não esperado: '${child.ctx.getText()}'`,
       child.ctx,
     );
   }
+
+  addChild(child: Node) {
+    this.children.push(child);
+  }
 }
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oAndBitwiseExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oAndBitwiseExpr.ts"
index d8b53007..ab25cecb 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oAndBitwiseExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oAndBitwiseExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoAndBitwiseContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoAndBitwiseExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoAndBitwiseContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoAndBitwiseExpr extends ExpressãoMatemática<OperacaoAndBitwiseContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oAndL\303\263gicoExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oAndL\303\263gicoExpr.ts"
index 2db9eed8..3ba06e6f 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oAndL\303\263gicoExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oAndL\303\263gicoExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoELogicoContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoAndLógicoExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoELogicoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoAndLógicoExpr extends ExpressãoMatemática<OperacaoELogicoContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oDiferen\303\247aExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oDiferen\303\247aExpr.ts"
index 56129fe2..33bdfa42 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oDiferen\303\247aExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oDiferen\303\247aExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoDiferencaContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoDiferençaExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoDiferencaContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoDiferençaExpr extends ExpressãoMatemática<OperacaoDiferencaContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oIgualdadeExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oIgualdadeExpr.ts"
index 0cb39255..8fe4e53f 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oIgualdadeExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oIgualdadeExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoIgualdadeContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoIgualdadeExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoIgualdadeContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoIgualdadeExpr extends ExpressãoMatemática<OperacaoIgualdadeContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oMaiorOuIgualQueExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oMaiorOuIgualQueExpr.ts"
index aaa61ef6..572ce882 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oMaiorOuIgualQueExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oMaiorOuIgualQueExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoMaiorIgualContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoMaiorOuIgualQueExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoMaiorIgualContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoMaiorOuIgualQueExpr extends ExpressãoMatemática<OperacaoMaiorIgualContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oMaiorQueExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oMaiorQueExpr.ts"
index 709e2b2d..b9566577 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oMaiorQueExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oMaiorQueExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoMenorContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoMaiorQueExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoMenorContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoMaiorQueExpr extends ExpressãoMatemática<OperacaoMenorContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oMenorOuIgualQueExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oMenorOuIgualQueExpr.ts"
index 0366f13e..9e906066 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oMenorOuIgualQueExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oMenorOuIgualQueExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoMenorIgualContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoMenorOuIgualQueExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoMenorIgualContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoMenorOuIgualQueExpr extends ExpressãoMatemática<OperacaoMenorIgualContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oMenorQueExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oMenorQueExpr.ts"
index c3937b35..60bfde97 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oMenorQueExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oMenorQueExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoMenorContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoMenorQueExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoMenorContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoMenorQueExpr extends ExpressãoMatemática<OperacaoMenorContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oOrBitwiseExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oOrBitwiseExpr.ts"
index 2fbbef76..81b809af 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oOrBitwiseExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oOrBitwiseExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoOrBitwiseContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoOrBitwiseExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoOrBitwiseContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoOrBitwiseExpr extends ExpressãoMatemática<OperacaoOrBitwiseContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oOrL\303\263gicoExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oOrL\303\263gicoExpr.ts"
index 677987a4..a367133a 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oOrL\303\263gicoExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oOrL\303\263gicoExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoOuLogicoContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoOrLógicoExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoOuLogicoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoOrLógicoExpr extends ExpressãoMatemática<OperacaoOuLogicoContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oShiftLeftExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oShiftLeftExpr.ts"
index 2e577376..8a12ee76 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oShiftLeftExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oShiftLeftExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoShiftLeftContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoShiftLeftExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoShiftLeftContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoShiftLeftExpr extends ExpressãoMatemática<OperacaoShiftLeftContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oShiftRightExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oShiftRightExpr.ts"
index 564d2898..681301d0 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oShiftRightExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oShiftRightExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoShiftRightContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoShiftRightExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoShiftRightContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoShiftRightExpr extends ExpressãoMatemática<OperacaoShiftRightContext> {}
diff --git "a/packages/parser/src/nodes/Opera\303\247\303\243oXorExpr.ts" "b/packages/parser/src/nodes/Opera\303\247\303\243oXorExpr.ts"
index e06a35f0..87c71e47 100644
--- "a/packages/parser/src/nodes/Opera\303\247\303\243oXorExpr.ts"
+++ "b/packages/parser/src/nodes/Opera\303\247\303\243oXorExpr.ts"
@@ -1,13 +1,5 @@
 import { OperacaoXorContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class OperaçãoXorExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: OperacaoXorContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class OperaçãoXorExpr extends ExpressãoMatemática<OperacaoXorContext> {}
diff --git a/packages/parser/src/nodes/ParaCmd.ts b/packages/parser/src/nodes/ParaCmd.ts
index c21f545b..10a4582d 100644
--- a/packages/parser/src/nodes/ParaCmd.ts
+++ b/packages/parser/src/nodes/ParaCmd.ts
@@ -5,38 +5,33 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant, getAllChildrenFromContext } from "../helpers/nodes.js";
 
-export class ParaCmd extends Comando {
+export class ParaCmd extends Comando<ParaContext> {
   inicialização?: Expressão | Comando;
   condição?: Expressão;
   incremento?: Expressão;
 
   instruções: Array<Expressão | Comando> = [];
 
-  constructor(
-    public ctx: ParaContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  #inicializaçãoCtx = getAllChildrenFromContext(this.ctx.inicializacaoPara());
+  #condiçãoCtx = getAllChildrenFromContext(this.ctx.condicao());
+  #incrementoCtx = getAllChildrenFromContext(this.ctx.incrementoPara());
 
-    const inicializaçãoCtx = getAllChildrenFromContext(ctx.inicializacaoPara());
-    const condiçãoCtx = getAllChildrenFromContext(ctx.condicao());
-    const incrementoCtx = getAllChildrenFromContext(ctx.incrementoPara());
-
-    for (const child of children) {
-      if ((child instanceof Expressão || child instanceof Comando) && inicializaçãoCtx.includes(child.ctx)) {
-        invariant(!this.inicialização, child.ctx, "Inicialização já definida");
-        this.inicialização = child;
-      } else if (child instanceof Expressão && condiçãoCtx.includes(child.ctx)) {
-        invariant(!this.condição, child.ctx, "Condição já definida");
-        this.condição = child;
-      } else if (child instanceof Expressão && incrementoCtx.includes(child.ctx)) {
-        invariant(!this.incremento, child.ctx, "Incremento já definido");
-        this.incremento = child;
-      } else if (child instanceof Comando || child instanceof Expressão) {
-        this.instruções.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if ((child instanceof Expressão || child instanceof Comando) && this.#inicializaçãoCtx.includes(child.ctx)) {
+      invariant(!this.inicialização, child.ctx, "Inicialização já definida");
+      this.inicialização = child;
+    } else if (child instanceof Expressão && this.#condiçãoCtx.includes(child.ctx)) {
+      invariant(!this.condição, child.ctx, "Condição já definida");
+      this.condição = child;
+    } else if (child instanceof Expressão && this.#incrementoCtx.includes(child.ctx)) {
+      invariant(!this.incremento, child.ctx, "Incremento já definido");
+      this.incremento = child;
+    } else if (child instanceof Comando || child instanceof Expressão) {
+      this.instruções.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git a/packages/parser/src/nodes/PareCmd.ts b/packages/parser/src/nodes/PareCmd.ts
index f01c845c..f8635447 100644
--- a/packages/parser/src/nodes/PareCmd.ts
+++ b/packages/parser/src/nodes/PareCmd.ts
@@ -2,19 +2,9 @@ import { PareContext } from "@portugol-webstudio/antlr";
 
 import { Comando } from "./Comando.js";
 import { Node } from "./Node.js";
-import { invariant } from "../helpers/nodes.js";
 
-export class PareCmd extends Comando {
-  constructor(
-    public ctx: PareContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    invariant(ctx.getText() === "pare", ctx);
-
-    for (const child of children) {
-      this.unexpectedChild(child);
-    }
+export class PareCmd extends Comando<PareContext> {
+  addChild(node: Node) {
+    this.unexpectedChild(node);
   }
 }
diff --git "a/packages/parser/src/nodes/Par\303\242metro.ts" "b/packages/parser/src/nodes/Par\303\242metro.ts"
index 94c3c4cf..7f5d02ec 100644
--- "a/packages/parser/src/nodes/Par\303\242metro.ts"
+++ "b/packages/parser/src/nodes/Par\303\242metro.ts"
@@ -2,49 +2,32 @@ import { ParametroContext, ParametroArrayContext, ParametroMatrizContext } from
 
 import { Node } from "./Node.js";
 import { UnhandledNode } from "./UnhandledNode.js";
-import { invariant } from "../helpers/nodes.js";
 import { Tipo, parseTipoPrimitivo } from "../helpers/Tipo.js";
 
-export class Parâmetro extends Node {
-  nome: string;
-  tipo: Tipo;
-  referência: boolean;
-
-  constructor(
-    public ctx: ParametroContext,
-    public children: Node[],
-  ) {
-    super();
-
-    this.nome = ctx.ID().getText();
-
-    this.tipo = { primitivo: parseTipoPrimitivo(ctx.TIPO()) };
-    this.referência = Boolean(ctx.E_COMERCIAL());
-
-    if (children.length === 1) {
-      const child = children[0];
-
-      invariant(child instanceof UnhandledNode, child.ctx, "Parâmetro inválido");
-    }
-
-    for (const child of children) {
-      if (child instanceof UnhandledNode) {
-        if (child.ctx instanceof ParametroArrayContext && !this.tipo.hasOwnProperty("dimensão")) {
-          this.tipo = {
-            dimensão: "vetor",
-            primitivo: this.tipo.primitivo,
-          };
-        } else if (child.ctx instanceof ParametroMatrizContext && !this.tipo.hasOwnProperty("dimensão")) {
-          this.tipo = {
-            dimensão: "matriz",
-            primitivo: this.tipo.primitivo,
-          };
-        } else {
-          this.unexpectedChild(child);
-        }
+export class Parâmetro extends Node<ParametroContext> {
+  nome = this.ctx.ID().getText();
+  tipo: Tipo = { primitivo: parseTipoPrimitivo(this.ctx.TIPO()) };
+  referência = Boolean(this.ctx.E_COMERCIAL());
+
+  addChild(child: Node) {
+    if (child instanceof UnhandledNode) {
+      if (child.ctx instanceof ParametroArrayContext && !this.tipo.hasOwnProperty("dimensão")) {
+        this.tipo = {
+          dimensão: "vetor",
+          primitivo: this.tipo.primitivo,
+        };
+      } else if (child.ctx instanceof ParametroMatrizContext && !this.tipo.hasOwnProperty("dimensão")) {
+        this.tipo = {
+          dimensão: "matriz",
+          primitivo: this.tipo.primitivo,
+        };
       } else {
         this.unexpectedChild(child);
       }
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git a/packages/parser/src/nodes/RealExpr.ts b/packages/parser/src/nodes/RealExpr.ts
index 0fe210ea..76400bad 100644
--- a/packages/parser/src/nodes/RealExpr.ts
+++ b/packages/parser/src/nodes/RealExpr.ts
@@ -2,21 +2,21 @@ import { NumeroRealContext } from "@portugol-webstudio/antlr";
 
 import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
+import { invariant } from "../helpers/nodes.js";
 
-export class RealExpr extends Expressão {
+export class RealExpr extends Expressão<NumeroRealContext> {
   valor: number;
 
-  constructor(
-    public ctx: NumeroRealContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  constructor(public ctx: NumeroRealContext) {
+    super(ctx);
     const valor = ctx.REAL().getText();
 
     this.valor = parseFloat(valor);
 
-    for (const child of children) {
-      this.unexpectedChild(child);
-    }
+    invariant(!isNaN(this.valor), ctx, "Valor inválido");
+  }
+
+  addChild(child: Node) {
+    this.unexpectedChild(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Refer\303\252nciaArrayExpr.ts" "b/packages/parser/src/nodes/Refer\303\252nciaArrayExpr.ts"
index 5c2038ca..6bd94565 100644
--- "a/packages/parser/src/nodes/Refer\303\252nciaArrayExpr.ts"
+++ "b/packages/parser/src/nodes/Refer\303\252nciaArrayExpr.ts"
@@ -6,27 +6,18 @@ import { ReferênciaVarExpr } from "./ReferênciaVarExpr.js";
 import { ÍndiceArrayExpr } from "./ÍndiceArrayExpr.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class ReferênciaArrayExpr extends Expressão {
-  variável: ReferênciaVarExpr;
+export class ReferênciaArrayExpr extends Expressão<ReferenciaArrayContext> {
+  variável = new ReferênciaVarExpr(this.ctx);
   índice: ÍndiceArrayExpr;
 
-  constructor(
-    public ctx: ReferenciaArrayContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    this.variável = new ReferênciaVarExpr(ctx, []);
-
-    for (const child of children) {
-      if (child instanceof ÍndiceArrayExpr) {
-        invariant(!this.índice, child.ctx, "Índice já definido");
-        this.índice = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof ÍndiceArrayExpr) {
+      invariant(!this.índice, child.ctx, "Índice já definido");
+      this.índice = child;
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.índice, ctx, "Índice não definido");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Refer\303\252nciaMatrizExpr.ts" "b/packages/parser/src/nodes/Refer\303\252nciaMatrizExpr.ts"
index f960ed82..8157bff7 100644
--- "a/packages/parser/src/nodes/Refer\303\252nciaMatrizExpr.ts"
+++ "b/packages/parser/src/nodes/Refer\303\252nciaMatrizExpr.ts"
@@ -1,37 +1,26 @@
-import { ReferenciaMatrizContext } from "@portugol-webstudio/antlr";
+import { ReferenciaMatrizContext } from "packages/antlr/lib/PortugolParser.js";
 
 import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { ReferênciaVarExpr } from "./ReferênciaVarExpr.js";
 import { ÍndiceArrayExpr } from "./ÍndiceArrayExpr.js";
-import { invariant } from "../helpers/nodes.js";
 
-export class ReferênciaMatrizExpr extends Expressão {
-  variável: ReferênciaVarExpr;
+export class ReferênciaMatrizExpr extends Expressão<ReferenciaMatrizContext> {
+  variável = new ReferênciaVarExpr(this.ctx);
   linha: ÍndiceArrayExpr;
   coluna: ÍndiceArrayExpr;
 
-  constructor(
-    public ctx: ReferenciaMatrizContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    this.variável = new ReferênciaVarExpr(ctx, []);
-
-    for (const child of children) {
+  addChild(child: Node) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (child instanceof ÍndiceArrayExpr && !this.linha) {
+      this.linha = child;
       // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      if (child instanceof ÍndiceArrayExpr && !this.linha) {
-        this.linha = child;
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      } else if (child instanceof ÍndiceArrayExpr && !this.coluna) {
-        this.coluna = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+    } else if (child instanceof ÍndiceArrayExpr && !this.coluna) {
+      this.coluna = child;
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.linha, ctx, "Linha não definida");
-    invariant(this.coluna, ctx, "Coluna não definida");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Refer\303\252nciaVarExpr.ts" "b/packages/parser/src/nodes/Refer\303\252nciaVarExpr.ts"
index 70ba8e18..b3042627 100644
--- "a/packages/parser/src/nodes/Refer\303\252nciaVarExpr.ts"
+++ "b/packages/parser/src/nodes/Refer\303\252nciaVarExpr.ts"
@@ -5,26 +5,19 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class ReferênciaVarExpr extends Expressão {
-  nome: string;
+export class ReferênciaVarExpr extends Expressão<ReferenciaParaVariavelContext> {
+  nome = this.ctx.ID().getText();
   escopoBiblioteca?: EscopoBibliotecaExpr;
 
-  constructor(
-    public ctx: ReferenciaParaVariavelContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  addChild(child: Node) {
+    if (child instanceof EscopoBibliotecaExpr) {
+      invariant(!this.escopoBiblioteca, child.ctx, "Escopo de biblioteca já definido");
 
-    this.nome = ctx.ID().getText();
-
-    for (const child of children) {
-      if (child instanceof EscopoBibliotecaExpr) {
-        invariant(!this.escopoBiblioteca, child.ctx, "Escopo de biblioteca já definido");
-
-        this.escopoBiblioteca = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+      this.escopoBiblioteca = child;
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git a/packages/parser/src/nodes/RetorneCmd.ts b/packages/parser/src/nodes/RetorneCmd.ts
index e4200994..f5d05239 100644
--- a/packages/parser/src/nodes/RetorneCmd.ts
+++ b/packages/parser/src/nodes/RetorneCmd.ts
@@ -5,23 +5,18 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class RetorneCmd extends Comando {
+export class RetorneCmd extends Comando<RetorneContext> {
   expressão?: Expressão;
 
-  constructor(
-    public ctx: RetorneContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      invariant(!this.expressão, child.ctx, "Expressão já definida");
 
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        invariant(!this.expressão, child.ctx, "Expressão já definida");
-
-        this.expressão = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+      this.expressão = child;
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git a/packages/parser/src/nodes/SeCmd.ts b/packages/parser/src/nodes/SeCmd.ts
index 9a9e59bc..d7b93964 100644
--- a/packages/parser/src/nodes/SeCmd.ts
+++ b/packages/parser/src/nodes/SeCmd.ts
@@ -6,31 +6,24 @@ import { Node } from "./Node.js";
 import { SenãoCmd } from "./SenãoCmd.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class SeCmd extends Comando {
+export class SeCmd extends Comando<SeContext> {
   condição: Expressão;
   instruções: Array<Expressão | Comando> = [];
   senão?: SenãoCmd;
 
-  constructor(
-    public ctx: SeContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão && child.ctx === ctx.expressao()) {
-        invariant(!this.condição, child.ctx, "Condição já definida");
-        this.condição = child;
-      } else if (child instanceof SenãoCmd) {
-        invariant(!this.senão, child.ctx, "Senão já definido");
-        this.senão = child;
-      } else if (child instanceof Comando || child instanceof Expressão) {
-        this.instruções.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão && child.ctx === this.ctx.expressao()) {
+      invariant(!this.condição, child.ctx, "Condição já definida");
+      this.condição = child;
+    } else if (child instanceof SenãoCmd) {
+      invariant(!this.senão, child.ctx, "Senão já definido");
+      this.senão = child;
+    } else if (child instanceof Comando || child instanceof Expressão) {
+      this.instruções.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.condição, ctx, "Condição não definida");
+    this.children.push(child);
   }
 }
diff --git "a/packages/parser/src/nodes/Sen\303\243oCmd.ts" "b/packages/parser/src/nodes/Sen\303\243oCmd.ts"
index dbb1ee8f..d0619999 100644
--- "a/packages/parser/src/nodes/Sen\303\243oCmd.ts"
+++ "b/packages/parser/src/nodes/Sen\303\243oCmd.ts"
@@ -4,21 +4,16 @@ import { Comando } from "./Comando.js";
 import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 
-export class SenãoCmd extends Comando {
+export class SenãoCmd extends Comando<SenaoContext> {
   instruções: Array<Expressão | Comando> = [];
 
-  constructor(
-    public ctx: SenaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Comando || child instanceof Expressão) {
-        this.instruções.push(child);
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Comando || child instanceof Expressão) {
+      this.instruções.push(child);
+    } else {
+      this.unexpectedChild(child);
     }
+
+    this.children.push(child);
   }
 }
diff --git a/packages/parser/src/nodes/SomaExpr.ts b/packages/parser/src/nodes/SomaExpr.ts
index c48809a4..e630b123 100644
--- a/packages/parser/src/nodes/SomaExpr.ts
+++ b/packages/parser/src/nodes/SomaExpr.ts
@@ -1,13 +1,5 @@
 import { AdicaoContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class SomaExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: AdicaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class SomaExpr extends ExpressãoMatemática<AdicaoContext> {}
diff --git "a/packages/parser/src/nodes/Subtra\303\247\303\243oExpr.ts" "b/packages/parser/src/nodes/Subtra\303\247\303\243oExpr.ts"
index f901028b..5db41cd1 100644
--- "a/packages/parser/src/nodes/Subtra\303\247\303\243oExpr.ts"
+++ "b/packages/parser/src/nodes/Subtra\303\247\303\243oExpr.ts"
@@ -1,13 +1,5 @@
 import { SubtracaoContext } from "@portugol-webstudio/antlr";
 
 import { ExpressãoMatemática } from "./ExpressãoMatemática.js";
-import { Node } from "./Node.js";
 
-export class SubtraçãoExpr extends ExpressãoMatemática {
-  constructor(
-    public ctx: SubtracaoContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class SubtraçãoExpr extends ExpressãoMatemática<SubtracaoContext> {}
diff --git a/packages/parser/src/nodes/UnhandledNode.ts b/packages/parser/src/nodes/UnhandledNode.ts
index dee2543a..e075e24a 100644
--- a/packages/parser/src/nodes/UnhandledNode.ts
+++ b/packages/parser/src/nodes/UnhandledNode.ts
@@ -6,9 +6,11 @@ export class UnhandledNode extends Node {
   constructor(
     public ctx: ParseTree,
     public type: string,
-    public text: string,
-    public children: Node[],
   ) {
-    super();
+    super(ctx);
+  }
+
+  addChild(child: Node) {
+    this.unexpectedChild(child);
   }
 }
diff --git a/packages/parser/src/nodes/VazioExpr.ts b/packages/parser/src/nodes/VazioExpr.ts
index c1761696..e9d47cf7 100644
--- a/packages/parser/src/nodes/VazioExpr.ts
+++ b/packages/parser/src/nodes/VazioExpr.ts
@@ -1,13 +1,3 @@
-import { ParserRuleContext } from "antlr4ng";
-
 import { Expressão } from "./Expressão.js";
-import { Node } from "./Node.js";
 
-export class VazioExpr extends Expressão {
-  constructor(
-    public ctx: ParserRuleContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-  }
-}
+export class VazioExpr extends Expressão {}
diff --git a/packages/parser/src/nodes/index.ts b/packages/parser/src/nodes/index.ts
index 5cf2d922..863d5080 100644
--- a/packages/parser/src/nodes/index.ts
+++ b/packages/parser/src/nodes/index.ts
@@ -298,3 +298,80 @@ export const ContextNodeMap = new Map<new (...args: any[]) => ParserRuleContext,
   [TamanhoArrayContext, Bypass],
   [ValorLogicoContext, LógicoExpr],
 ]);
+
+export const ContextNodeObj: Record<string, new (ctx: any) => Node> = {
+  AdicaoContext: SomaExpr,
+  ArquivoContext: Arquivo,
+  AtribuicaoCompostaDivisaoContext: AtribuiçãoCompostaDivisãoCmd,
+  AtribuicaoCompostaMultiplicacaoContext: AtribuiçãoCompostaMultiplicaçãoCmd,
+  AtribuicaoCompostaSomaContext: AtribuiçãoCompostaSomaCmd,
+  AtribuicaoCompostaSubtracaoContext: AtribuiçãoCompostaSubtraçãoCmd,
+  AtribuicaoContext: AtribuiçãoCmd,
+  CaracterContext: CaractereExpr,
+  CasoContext: CasoCmd,
+  ChamadaFuncaoContext: ChamadaFunçãoExpr,
+  ColunaMatrizContext: Bypass,
+  ComandoContext: Bypass,
+  CondicaoContext: Bypass,
+  DeclaracaoArrayContext: DeclaraçãoVetorExpr,
+  DeclaracaoContext: DeclaraçãoCmd,
+  DeclaracaoFuncaoContext: Função,
+  DeclaracaoMatrizContext: DeclaraçãoMatrizExpr,
+  DeclaracaoVariavelContext: DeclaraçãoVariávelExpr,
+  DecrementoUnarioPosfixadoContext: DecrementoUnárioPósfixadoExpr,
+  DecrementoUnarioPrefixadoContext: DecrementoUnárioPrefixadoExpr,
+  DivisaoContext: DivisãoExpr,
+  EnquantoContext: EnquantoCmd,
+  EscolhaContext: EscolhaCmd,
+  EscopoBibliotecaContext: EscopoBibliotecaExpr,
+  ExpressaoEntreParentesesContext: ExpressãoEntreParênteses,
+  FacaEnquantoContext: FaçaEnquantoCmd,
+  InclusaoBibliotecaContext: InclusãoBiblioteca,
+  IncrementoParaContext: Bypass,
+  IncrementoUnarioPosfixadoContext: IncrementoUnárioPósfixadoExpr,
+  IncrementoUnarioPrefixadoContext: IncrementoUnárioPrefixadoExpr,
+  IndiceArrayContext: ÍndiceArrayExpr,
+  InicializacaoArrayContext: InicializaçãoVetorExpr,
+  InicializacaoMatrizContext: InicializaçãoMatrizExpr,
+  InicializacaoParaContext: Bypass,
+  LinhaMatrizContext: Bypass,
+  ListaComandosContext: Bypass,
+  ListaDeclaracoesContext: Bypass,
+  ListaExpressoesContext: Bypass,
+  ListaParametrosContext: Bypass,
+  MaisUnarioContext: MaisUnárioExpr,
+  MenosUnarioContext: MenosUnárioExpr,
+  ModuloContext: MóduloExpr,
+  MultiplicacaoContext: MultiplicaçãoExpr,
+  NegacaoBitwiseContext: NegaçãoBitwiseExpr,
+  NegacaoContext: NegaçãoExpr,
+  NumeroInteiroContext: InteiroExpr,
+  NumeroRealContext: RealExpr,
+  OperacaoAndBitwiseContext: OperaçãoAndBitwiseExpr,
+  OperacaoDiferencaContext: OperaçãoDiferençaExpr,
+  OperacaoELogicoContext: OperaçãoAndLógicoExpr,
+  OperacaoIgualdadeContext: OperaçãoIgualdadeExpr,
+  OperacaoMaiorContext: OperaçãoMaiorQueExpr,
+  OperacaoMaiorIgualContext: OperaçãoMaiorOuIgualQueExpr,
+  OperacaoMenorContext: OperaçãoMenorQueExpr,
+  OperacaoMenorIgualContext: OperaçãoMenorOuIgualQueExpr,
+  OperacaoOrBitwiseContext: OperaçãoOrBitwiseExpr,
+  OperacaoOuLogicoContext: OperaçãoOrLógicoExpr,
+  OperacaoShiftLeftContext: OperaçãoShiftLeftExpr,
+  OperacaoShiftRightContext: OperaçãoShiftRightExpr,
+  OperacaoXorContext: OperaçãoXorExpr,
+  ParaContext: ParaCmd,
+  ParametroContext: Parâmetro,
+  ParametroFuncaoContext: Bypass,
+  PareContext: PareCmd,
+  ReferenciaArrayContext: ReferênciaArrayExpr,
+  ReferenciaMatrizContext: ReferênciaMatrizExpr,
+  ReferenciaParaVariavelContext: ReferênciaVarExpr,
+  RetorneContext: RetorneCmd,
+  SeContext: SeCmd,
+  SenaoContext: SenãoCmd,
+  StringContext: CadeiaExpr,
+  SubtracaoContext: SubtraçãoExpr,
+  TamanhoArrayContext: Bypass,
+  ValorLogicoContext: LógicoExpr,
+};
diff --git "a/packages/parser/src/nodes/\303\215ndiceArrayExpr.ts" "b/packages/parser/src/nodes/\303\215ndiceArrayExpr.ts"
index a2d0d5eb..debb1e66 100644
--- "a/packages/parser/src/nodes/\303\215ndiceArrayExpr.ts"
+++ "b/packages/parser/src/nodes/\303\215ndiceArrayExpr.ts"
@@ -4,24 +4,17 @@ import { Expressão } from "./Expressão.js";
 import { Node } from "./Node.js";
 import { invariant } from "../helpers/nodes.js";
 
-export class ÍndiceArrayExpr extends Expressão {
+export class ÍndiceArrayExpr extends Expressão<IndiceArrayContext> {
   índice: Expressão;
 
-  constructor(
-    public ctx: IndiceArrayContext,
-    public children: Node[],
-  ) {
-    super(ctx, children);
-
-    for (const child of children) {
-      if (child instanceof Expressão) {
-        invariant(!this.índice, child.ctx, "Índice já definido");
-        this.índice = child;
-      } else {
-        this.unexpectedChild(child);
-      }
+  addChild(child: Node) {
+    if (child instanceof Expressão) {
+      invariant(!this.índice, child.ctx, "Índice já definido");
+      this.índice = child;
+    } else {
+      this.unexpectedChild(child);
     }
 
-    invariant(this.índice, ctx, "Índice não definido");
+    this.children.push(child);
   }
 }
diff --git a/packages/worker/webpack.config.js b/packages/worker/webpack.config.js
index f394787a..f9d8839a 100644
--- a/packages/worker/webpack.config.js
+++ b/packages/worker/webpack.config.js
@@ -1,5 +1,6 @@
 /* eslint-disable */
 const path = require("path");
+const TerserPlugin = require("terser-webpack-plugin");
 
 /** @type {import("webpack").Configuration} */
 module.exports = {
@@ -17,4 +18,15 @@ module.exports = {
       },
     ],
   },
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new TerserPlugin({
+        terserOptions: {
+          keep_classnames: true,
+          keep_fnames: true,
+        },
+      }),
+    ],
+  },
 };