diff --git a/packages/antlr/src/PortugolErrorListener.ts b/packages/antlr/src/PortugolErrorListener.ts
index 74af563a..354f60b9 100644
--- a/packages/antlr/src/PortugolErrorListener.ts
+++ b/packages/antlr/src/PortugolErrorListener.ts
@@ -27,15 +27,14 @@ export class PortugolCodeError extends Error {
       typeof (possibleContext as unknown as { _stop: any })._stop === "object"
     ) {
       const { _start, _stop } = possibleContext as unknown as { _start: any; _stop: any };
+      const { line: startLine, _charPositionInLine: startCol } = _start;
+      let { line: endLine, _charPositionInLine: endCol } = _stop;
 
-      return new PortugolCodeError(
-        message,
-        ctx,
-        _start.line,
-        _start._charPositionInLine + 1,
-        _stop.line,
-        _stop._charPositionInLine + 2,
-      );
+      if (startLine === endLine && startCol === endCol) {
+        endCol += ctx.text.length - 1;
+      }
+
+      return new PortugolCodeError(message, ctx, startLine, startCol, endLine, endCol);
     }
 
     const possibleSymbol: Token | RuleContext | undefined = (ctx as any).symbol || (ctx as any).payload;
@@ -51,9 +50,9 @@ export class PortugolCodeError extends Error {
         message,
         ctx,
         _line,
-        _charPositionInLine + 1,
+        _charPositionInLine,
         _line,
-        _charPositionInLine + 2 + ctx.text.length,
+        _charPositionInLine + ctx.text.length,
       );
     }
 
@@ -73,9 +72,7 @@ export class PortugolErrorListener implements ANTLRErrorListener<Token> {
     exception: RecognitionException | undefined,
   ) {
     const endColumn =
-      offendingSymbol && offendingSymbol.text
-        ? charPositionInLine + offendingSymbol.text.length
-        : charPositionInLine + 1;
+      offendingSymbol && offendingSymbol.text ? charPositionInLine + offendingSymbol.text.length : charPositionInLine;
 
     this.errors.push(
       new PortugolCodeError(
diff --git a/packages/ide/src/app/dialog-open-example/dialog-open-example.component.html b/packages/ide/src/app/dialog-open-example/dialog-open-example.component.html
index c5e73a51..294b51b9 100644
--- a/packages/ide/src/app/dialog-open-example/dialog-open-example.component.html
+++ b/packages/ide/src/app/dialog-open-example/dialog-open-example.component.html
@@ -13,7 +13,7 @@
           <mat-tree [dataSource]="dataSource" [treeControl]="treeControl">
             <mat-tree-node *matTreeNodeDef="let node">
               <li mat-ripple (click)="loadItem(node)" [class.active]="current?.id === node.id">
-                <button mat-icon-button disabled>
+                <button mat-icon-button disabled title="Expandir/retrair">
                   <mat-icon></mat-icon>
                 </button>
                 <span>{{ node.name }}</span>
diff --git a/packages/ide/src/app/dialog-open-example/dialog-open-example.component.ts b/packages/ide/src/app/dialog-open-example/dialog-open-example.component.ts
index fdda03d9..ed6898c9 100644
--- a/packages/ide/src/app/dialog-open-example/dialog-open-example.component.ts
+++ b/packages/ide/src/app/dialog-open-example/dialog-open-example.component.ts
@@ -28,7 +28,7 @@ export class DialogOpenExampleComponent implements OnInit, OnDestroy, AfterViewI
 
   treeControl: NestedTreeControl<ExampleItem>;
   dataSource: MatTreeNestedDataSource<ExampleItem>;
-  current?: ExampleItem;
+  current: ExampleItem | null = null;
   loading = true;
 
   private _loadSubscription$?: Subscription;
diff --git a/packages/ide/src/app/tab-editor/tab-editor.component.ts b/packages/ide/src/app/tab-editor/tab-editor.component.ts
index 77e4df2a..3a95f010 100644
--- a/packages/ide/src/app/tab-editor/tab-editor.component.ts
+++ b/packages/ide/src/app/tab-editor/tab-editor.component.ts
@@ -346,9 +346,9 @@ export class TabEditorComponent implements OnInit, OnDestroy {
         errors.map(error => {
           return {
             startLineNumber: error.startLine,
-            startColumn: error.startCol,
+            startColumn: error.startCol + 1,
             endLineNumber: error.endLine,
-            endColumn: error.endCol,
+            endColumn: error.endCol + 2,
             message: error.message,
             severity: monaco.MarkerSeverity.Error,
           };
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 0c86bd83..c6431c70 100644
--- a/packages/ide/src/app/tab-start/tab-start.component.html
+++ b/packages/ide/src/app/tab-start/tab-start.component.html
@@ -69,9 +69,9 @@
   <hr />
 
   <h4>📰&nbsp;&nbsp;Novidades</h4>
+  <p><strong>26/12/2023:</strong> Melhorias nas verificações de erros (escopos e tipos)</p>
   <p><strong>15/10/2023:</strong> Correção de verificação simples de retorno de função</p>
   <p><strong>11/10/2023:</strong> Correção de quebra de linha após execução da função <code>leia()</code></p>
-  <p><strong>28/09/2023:</strong> Correção de uso excessivo de recursos ao usar atribuições.</p>
 </section>
 
 <footer>
diff --git "a/packages/parser/src/errors/01-estrutura-b\303\241sica.ts" "b/packages/parser/src/errors/01-estrutura-b\303\241sica.ts"
index aa172fdf..53f4acd7 100644
--- "a/packages/parser/src/errors/01-estrutura-b\303\241sica.ts"
+++ "b/packages/parser/src/errors/01-estrutura-b\303\241sica.ts"
@@ -1,6 +1,7 @@
 import { PortugolCodeError } from "@portugol-webstudio/antlr";
 
 import { getAllChildrenFromNode } from "../helpers/nodes.js";
+import { TipoPrimitivo } from "../helpers/Tipo.js";
 import { Arquivo } from "../nodes/Arquivo.js";
 import { RetorneCmd } from "../nodes/RetorneCmd.js";
 
@@ -12,7 +13,7 @@ export function* checarFunçãoInício(arquivo: Arquivo) {
       yield PortugolCodeError.fromContext(funcInicio.ctx, "A função 'inicio' não deve receber parâmetros");
     }
 
-    if (funcInicio.retorno.primitivo !== "vazio") {
+    if (funcInicio.retorno.primitivo !== TipoPrimitivo.VAZIO) {
       yield PortugolCodeError.fromContext(funcInicio.ctx, "A função 'inicio' não deve retornar valores");
     }
   } else {
@@ -22,7 +23,7 @@ export function* checarFunçãoInício(arquivo: Arquivo) {
 
 export function* checarFunçõesComRetorno(arquivo: Arquivo) {
   for (const func of arquivo.funções) {
-    if (func.retorno.primitivo !== "vazio") {
+    if (func.retorno.primitivo !== TipoPrimitivo.VAZIO) {
       if (!getAllChildrenFromNode(func).some(instrução => instrução instanceof RetorneCmd)) {
         yield PortugolCodeError.fromContext(func.ctx, `A função '${func.nome}' deve retornar um valor`);
       }
diff --git "a/packages/parser/src/errors/02-vari\303\241veis.ts" "b/packages/parser/src/errors/02-vari\303\241veis.ts"
index 1880f33a..e019174a 100644
--- "a/packages/parser/src/errors/02-vari\303\241veis.ts"
+++ "b/packages/parser/src/errors/02-vari\303\241veis.ts"
@@ -1,164 +1,116 @@
-import { PortugolCodeError } from "@portugol-webstudio/antlr";
+import { PortugolCodeError } from "packages/antlr/lib/PortugolErrorListener.js";
 
-import { getAllChildrenFromNode } from "../helpers/nodes.js";
-import { Tipo } from "../helpers/Tipo.js";
+import { ResultadoCompatibilidade, TabelaCompatibilidadeAtribuição } from "../helpers/compatibilidade.js";
+import { Escopo } from "../helpers/Escopo.js";
+import { resolverResultadoExpressão } from "../helpers/expressões.js";
 import { Arquivo } from "../nodes/Arquivo.js";
 import { AtribuiçãoCmd } from "../nodes/AtribuiçãoCmd.js";
-import { CadeiaExpr } from "../nodes/CadeiaExpr.js";
-import { CaractereExpr } from "../nodes/CaractereExpr.js";
-import { ChamadaFunçãoExpr } from "../nodes/ChamadaFunçãoExpr.js";
-import { Comando } from "../nodes/Comando.js";
 import { DeclaraçãoCmd } from "../nodes/DeclaraçãoCmd.js";
-import { Expressão } from "../nodes/Expressão.js";
-import { InteiroExpr } from "../nodes/InteiroExpr.js";
-import { LógicoExpr } from "../nodes/LógicoExpr.js";
-import { RealExpr } from "../nodes/RealExpr.js";
+import { EnquantoCmd } from "../nodes/EnquantoCmd.js";
+import { EscolhaCmd } from "../nodes/EscolhaCmd.js";
+import { FaçaEnquantoCmd } from "../nodes/FaçaEnquantoCmd.js";
+import { Função } from "../nodes/Função.js";
+import { Node } from "../nodes/Node.js";
+import { ParaCmd } from "../nodes/ParaCmd.js";
+import { Parâmetro } from "../nodes/Parâmetro.js";
 import { ReferênciaVarExpr } from "../nodes/ReferênciaVarExpr.js";
+import { SeCmd } from "../nodes/SeCmd.js";
 
-interface Escopo {
-  variáveis: Map<string, Tipo>;
-  funções: Map<string, Tipo>;
-}
+export function* checarUsoEscopo(arquivo: Arquivo): Generator<PortugolCodeError> {
+  const escopo = new Escopo();
 
-export function* checarUsoEscopo(arquivo: Arquivo) {
-  const escopo: Escopo = {
-    variáveis: new Map<string, Tipo>(),
-    funções: new Map<string, Tipo>([
-      ["escreva", { primitivo: "vazio" }],
-      ["leia", { primitivo: "cadeia" }],
-      ["limpa", { primitivo: "vazio" }],
-    ]),
-  };
-
-  for (const declr of arquivo.declarações) {
-    if (escopo.variáveis.has(declr.nome)) {
-      yield PortugolCodeError.fromContext(declr.ctx, `A variável '${declr.nome}' foi declarada múltiplas vezes`);
+  function* varrerNós(nós: Node[]) {
+    for (const nó of nós) {
+      yield* varrerNó(nó);
     }
-
-    escopo.variáveis.set(declr.nome, declr.tipo);
   }
 
-  for (const func of arquivo.funções) {
-    if (escopo.funções.has(func.nome)) {
-      yield PortugolCodeError.fromContext(func.ctx, `A função '${func.nome}' foi declarada múltiplas vezes`);
-    }
+  function* varrerNó(nó: Node): Generator<PortugolCodeError> {
+    switch (nó.constructor) {
+      case DeclaraçãoCmd:
+      case Parâmetro:
+        const declr = nó as DeclaraçãoCmd | Parâmetro;
 
-    escopo.funções.set(func.nome, func.retorno);
-  }
+        escopo.variáveis.set(declr.nome, declr.tipo);
+        break;
 
-  for (const func of arquivo.funções) {
-    const escopoFunção: Escopo = {
-      variáveis: new Map(escopo.variáveis),
-      funções: new Map(escopo.funções),
-    };
+      case ReferênciaVarExpr:
+        const ref = nó as ReferênciaVarExpr;
 
-    for (const param of func.parâmetros) {
-      if (escopoFunção.variáveis.has(param.nome)) {
-        yield PortugolCodeError.fromContext(param.ctx, `O parâmetro '${param.nome}' foi declarado múltiplas vezes`);
-      }
+        if (!escopo.hasVariável(ref.nome)) {
+          yield PortugolCodeError.fromContext(ref.ctx, `Variável não declarada: ${ref.nome}`);
+        }
 
-      escopoFunção.variáveis.set(param.nome, param.tipo);
-    }
+        break;
 
-    const instruções: Array<Comando | Expressão> = func.instruções.concat(
-      func.instruções.flatMap(getAllChildrenFromNode) as Array<Comando | Expressão>,
-    );
+      case AtribuiçãoCmd:
+        const attr = nó as AtribuiçãoCmd;
 
-    for (const expr of instruções) {
-      if (expr instanceof DeclaraçãoCmd) {
-        if (escopoFunção.variáveis.has(expr.nome)) {
-          yield PortugolCodeError.fromContext(expr.ctx, `A variável '${expr.nome}' foi declarada múltiplas vezes`);
-        }
+        yield* varrerNós(attr.children);
 
-        escopoFunção.variáveis.set(expr.nome, expr.tipo);
-      } else if (expr instanceof AtribuiçãoCmd) {
-        const nome = expr.variável instanceof ReferênciaVarExpr ? expr.variável.nome : expr.variável.variável.nome;
+        // TODO: bibliotecas
+        if (attr.variável instanceof ReferênciaVarExpr && !attr.variável.escopoBiblioteca) {
+          const svar = escopo.variáveis.get(attr.variável.nome);
 
-        if (!escopoFunção.variáveis.has(nome)) {
-          yield PortugolCodeError.fromContext(expr.ctx, `A variável '${nome}' não foi declarada`);
-        }
-
-        const variável = escopoFunção.variáveis.get(nome);
-
-        if (expr.expressão instanceof ChamadaFunçãoExpr) {
-          if (
-            !expr.expressão.escopoBiblioteca &&
-            expr.expressão.nome !== "leia" &&
-            escopoFunção.funções.get(expr.expressão.nome)?.primitivo !== variável?.primitivo
-          ) {
-            yield PortugolCodeError.fromContext(
-              expr.ctx,
-              `A função '${expr.expressão.nome}' não retorna um valor do tipo '${variável?.primitivo}'`,
-            );
-          }
-        } else if (expr.expressão instanceof ReferênciaVarExpr) {
-          if (escopoFunção.variáveis.get(expr.expressão.nome)?.primitivo !== variável?.primitivo) {
-            yield PortugolCodeError.fromContext(
-              expr.ctx,
-              `A variável '${expr.expressão.nome}' não é do tipo '${variável?.primitivo}'`,
-            );
-          }
-        } else if (expr.expressão instanceof InteiroExpr) {
-          if (variável?.primitivo !== "inteiro") {
-            yield PortugolCodeError.fromContext(
-              expr.ctx,
-              `A variável '${nome}' esperava ser atribuída com um valor do tipo '${variável?.primitivo}', mas recebeu um valor do tipo 'inteiro'`,
-            );
-          }
-        } else if (expr.expressão instanceof RealExpr) {
-          if (variável?.primitivo !== "real") {
-            yield PortugolCodeError.fromContext(
-              expr.ctx,
-              `A variável '${nome}' esperava ser atribuída com um valor do tipo '${variável?.primitivo}', mas recebeu um valor do tipo 'real'`,
-            );
-          }
-        } else if (expr.expressão instanceof CadeiaExpr) {
-          if (variável?.primitivo !== "cadeia") {
-            yield PortugolCodeError.fromContext(
-              expr.ctx,
-              `A variável '${nome}' esperava ser atribuída com um valor do tipo '${variável?.primitivo}', mas recebeu um valor do tipo 'cadeia'`,
-            );
-          }
-        } else if (expr.expressão instanceof CaractereExpr) {
-          if (variável?.primitivo !== "caracter") {
-            yield PortugolCodeError.fromContext(
-              expr.ctx,
-              `A variável '${nome}' esperava ser atribuída com um valor do tipo '${variável?.primitivo}', mas recebeu um valor do tipo 'caracter'`,
-            );
-          }
-        } else if (expr.expressão instanceof LógicoExpr) {
-          if (variável?.primitivo !== "logico") {
-            yield PortugolCodeError.fromContext(
-              expr.ctx,
-              `A variável '${nome}' esperava ser atribuída com um valor do tipo '${variável?.primitivo}', mas recebeu um valor do tipo 'logico'`,
-            );
+          if (!svar) {
+            break;
           }
-        }
-      } else if (expr instanceof ReferênciaVarExpr) {
-        if (!escopoFunção.variáveis.has(expr.nome)) {
-          yield PortugolCodeError.fromContext(expr.ctx, `A variável '${expr.nome}' não foi declarada`);
-        }
-      } else if (expr instanceof ChamadaFunçãoExpr) {
-        if (!expr.escopoBiblioteca && !escopoFunção.funções.has(expr.nome)) {
-          yield PortugolCodeError.fromContext(expr.ctx, `A função '${expr.nome}' não foi declarada`);
-        }
 
-        const args = expr.argumentos;
+          try {
+            const tret = resolverResultadoExpressão(attr.expressão, escopo);
 
-        for (const arg of args) {
-          if (arg instanceof ChamadaFunçãoExpr) {
-            if (!arg.escopoBiblioteca && !escopoFunção.funções.has(arg.nome)) {
-              yield PortugolCodeError.fromContext(arg.ctx, `A função '${arg.nome}' não foi declarada`);
+            if (TabelaCompatibilidadeAtribuição[svar.primitivo][tret] === ResultadoCompatibilidade.INCOMPATÍVEL) {
+              yield PortugolCodeError.fromContext(
+                attr.ctx,
+                `Não é possível atribuir um valor do tipo '${tret}' a uma variável do tipo '${svar.primitivo}'`,
+              );
             }
+          } catch (e) {
+            const message = e instanceof Error ? e.message : "Não foi possível resolver o tipo da expressão";
 
-            const tipo = escopoFunção.funções.get(arg.nome);
-
-            if (tipo?.primitivo === "vazio") {
-              yield PortugolCodeError.fromContext(arg.ctx, `A função '${arg.nome}' não retorna um valor`);
+            if (message === "TODO") {
+              break;
             }
+
+            yield PortugolCodeError.fromContext(attr.ctx, message);
           }
         }
-      }
+
+        // TODO: array e matriz
+
+        break;
+
+      case EnquantoCmd:
+      case EscolhaCmd:
+      case FaçaEnquantoCmd:
+      case Função:
+      case ParaCmd:
+        escopo.push();
+        yield* varrerNós(nó.children);
+        escopo.pop();
+        break;
+
+      case SeCmd:
+        const se = nó as SeCmd;
+
+        escopo.push();
+        yield* varrerNó(se.condição);
+        yield* varrerNós(se.instruções);
+        escopo.pop();
+
+        if (se.senão) {
+          escopo.push();
+          yield* varrerNós(se.senão.instruções);
+          escopo.pop();
+        }
+
+        break;
+
+      default:
+        yield* varrerNós(nó.children);
+        break;
     }
   }
+
+  yield* varrerNó(arquivo);
 }
diff --git a/packages/parser/src/helpers/Escopo.ts b/packages/parser/src/helpers/Escopo.ts
new file mode 100644
index 00000000..918f8bce
--- /dev/null
+++ b/packages/parser/src/helpers/Escopo.ts
@@ -0,0 +1,73 @@
+import { Tipo, TipoPrimitivo } from "./Tipo.js";
+
+interface IEscopo {
+  variáveis: Map<string, Tipo>;
+  funções: Map<string, Tipo>;
+}
+
+export class Escopo {
+  private pilha: IEscopo[] = [];
+
+  constructor(
+    inicial: IEscopo = {
+      variáveis: new Map(),
+      funções: new Map([
+        ["escreva", { primitivo: TipoPrimitivo.VAZIO }],
+        ["leia", { primitivo: TipoPrimitivo.CADEIA }],
+        ["limpa", { primitivo: TipoPrimitivo.VAZIO }],
+      ]),
+    },
+  ) {
+    this.pilha.push(inicial);
+  }
+
+  push() {
+    this.pilha.push({ variáveis: new Map(), funções: new Map() });
+  }
+
+  pop() {
+    if (this.pilha.length === 1) {
+      throw new Error("Não é possível remover o escopo global");
+    }
+
+    this.pilha.pop();
+  }
+
+  get atual(): IEscopo {
+    return this.pilha[this.pilha.length - 1];
+  }
+
+  get global(): IEscopo {
+    return this.pilha[0];
+  }
+
+  get variáveis() {
+    return this.atual.variáveis;
+  }
+
+  get funções() {
+    return this.atual.funções;
+  }
+
+  hasVariável(nome: string) {
+    for (const escopo of this.pilha) {
+      if (escopo.variáveis.has(nome)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  hasFunção(nome: string) {
+    return this.funções.has(nome);
+  }
+
+  getVariável(nome: string) {
+    return this.variáveis.get(nome);
+  }
+
+  getFunção(nome: string) {
+    return this.funções.get(nome);
+  }
+}
diff --git a/packages/parser/src/helpers/Tipo.ts b/packages/parser/src/helpers/Tipo.ts
index 09aeab49..dd152074 100644
--- a/packages/parser/src/helpers/Tipo.ts
+++ b/packages/parser/src/helpers/Tipo.ts
@@ -3,7 +3,15 @@ import { TerminalNode } from "antlr4ts/tree/TerminalNode.js";
 import { InteiroExpr } from "../nodes/InteiroExpr.js";
 import { ReferênciaVarExpr } from "../nodes/ReferênciaVarExpr.js";
 
-export type TipoPrimitivo = "inteiro" | "real" | "cadeia" | "logico" | "vazio" | "caracter";
+export enum TipoPrimitivo {
+  INTEIRO = "inteiro",
+  REAL = "real",
+  CADEIA = "cadeia",
+  LÓGICO = "logico",
+  VAZIO = "vazio",
+  CARACTER = "caracter",
+}
+
 export type Tipo = { primitivo: TipoPrimitivo } & (
   | {}
   | ({ dimensão: "vetor" | "matriz"; primitivo: TipoPrimitivo } & (
@@ -14,7 +22,7 @@ export type Tipo = { primitivo: TipoPrimitivo } & (
 
 export function parseTipoPrimitivo(tipo: TerminalNode | undefined): TipoPrimitivo {
   if (!tipo) {
-    return "vazio";
+    return TipoPrimitivo.VAZIO;
   }
 
   switch (tipo.text) {
@@ -24,7 +32,7 @@ export function parseTipoPrimitivo(tipo: TerminalNode | undefined): TipoPrimitiv
     case "logico":
     case "vazio":
     case "caracter":
-      return tipo.text;
+      return tipo.text as TipoPrimitivo;
 
     default:
       throw new Error(`Tipo desconhecido: ${tipo.text}`);
diff --git a/packages/parser/src/helpers/compatibilidade.ts b/packages/parser/src/helpers/compatibilidade.ts
new file mode 100644
index 00000000..4e35e8c7
--- /dev/null
+++ b/packages/parser/src/helpers/compatibilidade.ts
@@ -0,0 +1,617 @@
+import { TipoPrimitivo } from "./Tipo.js";
+
+/**
+ * Baseado em: https://github.com/UNIVALI-LITE/Portugol-Studio/blob/master/core/src/main/java/br/univali/portugol/nucleo/analise/semantica/TabelaCompatibilidadeTiposPortugol.java
+ */
+
+export enum ResultadoCompatibilidade {
+  /**
+   * Os tipos são compatíveis
+   */
+  COMPATÍVEL,
+
+  /**
+   * Os tipos são incompatíveis
+   */
+  INCOMPATÍVEL,
+
+  /**
+   * Os tipos são compatíveis, mas houve uma conversão implícita
+   */
+  COMPATÍVEL_COM_CONVERSÃO_IMPLÍCITA,
+
+  /**
+   * Os tipos são compatíveis, o tipo de retorno é diferente
+   */
+  COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO,
+}
+
+export type ResultadoCompatibilidadeTipos =
+  | ResultadoCompatibilidade.COMPATÍVEL
+  | ResultadoCompatibilidade.INCOMPATÍVEL
+  | ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_IMPLÍCITA
+  | [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo];
+
+export const TabelaCompatibilidadeChamadaFunção: Record<
+  TipoPrimitivo,
+  Record<TipoPrimitivo, ResultadoCompatibilidadeTipos>
+> = {
+  [TipoPrimitivo.CADEIA]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.CARACTER]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.INTEIRO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_IMPLÍCITA,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.LÓGICO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.REAL]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_IMPLÍCITA,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.VAZIO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+};
+
+export const TabelaCompatibilidadeRetornoFunção: Record<
+  TipoPrimitivo,
+  Record<TipoPrimitivo, ResultadoCompatibilidadeTipos>
+> = {
+  [TipoPrimitivo.CADEIA]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.CARACTER]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.INTEIRO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_IMPLÍCITA,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.LÓGICO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.REAL]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_IMPLÍCITA,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.VAZIO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+};
+
+export const TabelaCompatibilidadeAtribuição: Record<
+  TipoPrimitivo,
+  Record<TipoPrimitivo, ResultadoCompatibilidadeTipos>
+> = {
+  [TipoPrimitivo.CADEIA]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.CARACTER]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.INTEIRO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_IMPLÍCITA,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.LÓGICO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.REAL]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_IMPLÍCITA,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.VAZIO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+};
+
+export const TabelaCompatibilidadeDivisãoMultiplicaçãoSubtração: Record<
+  TipoPrimitivo,
+  Record<TipoPrimitivo, ResultadoCompatibilidadeTipos>
+> = {
+  [TipoPrimitivo.CADEIA]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.CARACTER]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.INTEIRO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.LÓGICO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.REAL]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.REAL],
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.VAZIO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+};
+
+export const TabelaCompatibilidadeDiferençaIgualdade: Record<
+  TipoPrimitivo,
+  Record<TipoPrimitivo, ResultadoCompatibilidadeTipos>
+> = {
+  [TipoPrimitivo.CADEIA]: {
+    [TipoPrimitivo.CADEIA]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.CARACTER]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.INTEIRO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.LÓGICO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.REAL]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.VAZIO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+};
+
+export const TabelaCompatibilidadeEOu: Record<TipoPrimitivo, Record<TipoPrimitivo, ResultadoCompatibilidadeTipos>> = {
+  [TipoPrimitivo.CADEIA]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.CARACTER]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.INTEIRO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.LÓGICO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.REAL]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.VAZIO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+};
+
+export const TabelaCompatibilidadeMaiorMaiorIgualMenorMenorIgual: Record<
+  TipoPrimitivo,
+  Record<TipoPrimitivo, ResultadoCompatibilidadeTipos>
+> = {
+  [TipoPrimitivo.CADEIA]: {
+    [TipoPrimitivo.CADEIA]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.CARACTER]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.INTEIRO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.LÓGICO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.REAL]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.LÓGICO],
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.VAZIO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+};
+
+export const TabelaCompatibilidadeModulo: Record<
+  TipoPrimitivo,
+  Record<TipoPrimitivo, ResultadoCompatibilidadeTipos>
+> = {
+  [TipoPrimitivo.CADEIA]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.CARACTER]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.INTEIRO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.LÓGICO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.REAL]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.VAZIO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+};
+
+export const TabelaCompatibilidadeBitwise: Record<
+  TipoPrimitivo,
+  Record<TipoPrimitivo, ResultadoCompatibilidadeTipos>
+> = {
+  [TipoPrimitivo.CADEIA]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.CARACTER]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.INTEIRO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.LÓGICO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.REAL]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.VAZIO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+};
+
+export const TabelaCompatibilidadeSoma: Record<TipoPrimitivo, Record<TipoPrimitivo, ResultadoCompatibilidadeTipos>> = {
+  [TipoPrimitivo.CADEIA]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.CADEIA],
+    [TipoPrimitivo.INTEIRO]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.CADEIA],
+    [TipoPrimitivo.LÓGICO]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.CADEIA],
+    [TipoPrimitivo.REAL]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.CADEIA],
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.CARACTER]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.CADEIA],
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.INTEIRO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.LÓGICO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.REAL]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: [ResultadoCompatibilidade.COMPATÍVEL_COM_CONVERSÃO_DE_OPERAÇÃO, TipoPrimitivo.REAL],
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.COMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+
+  [TipoPrimitivo.VAZIO]: {
+    [TipoPrimitivo.CADEIA]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.CARACTER]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.INTEIRO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.LÓGICO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.REAL]: ResultadoCompatibilidade.INCOMPATÍVEL,
+    [TipoPrimitivo.VAZIO]: ResultadoCompatibilidade.INCOMPATÍVEL,
+  },
+};
diff --git "a/packages/parser/src/helpers/express\303\265es.ts" "b/packages/parser/src/helpers/express\303\265es.ts"
new file mode 100644
index 00000000..e219a181
--- /dev/null
+++ "b/packages/parser/src/helpers/express\303\265es.ts"
@@ -0,0 +1,259 @@
+import {
+  ResultadoCompatibilidade,
+  TabelaCompatibilidadeBitwise,
+  TabelaCompatibilidadeDiferençaIgualdade,
+  TabelaCompatibilidadeDivisãoMultiplicaçãoSubtração,
+  TabelaCompatibilidadeEOu,
+  TabelaCompatibilidadeModulo,
+  TabelaCompatibilidadeSoma,
+} from "./compatibilidade";
+import { Escopo } from "./Escopo";
+import { TipoPrimitivo } from "./Tipo.js";
+import {
+  CadeiaExpr,
+  CaractereExpr,
+  ChamadaFunçãoExpr,
+  DecrementoUnárioPrefixadoExpr,
+  DecrementoUnárioPósfixadoExpr,
+  DivisãoExpr,
+  ExpressãoEntreParênteses,
+  ExpressãoUnária,
+  IncrementoUnárioPrefixadoExpr,
+  IncrementoUnárioPósfixadoExpr,
+  InteiroExpr,
+  LógicoExpr,
+  MaisUnárioExpr,
+  MenosUnárioExpr,
+  MultiplicaçãoExpr,
+  MóduloExpr,
+  NegaçãoBitwiseExpr,
+  NegaçãoExpr,
+  OperaçãoAndBitwiseExpr,
+  OperaçãoAndLógicoExpr,
+  OperaçãoDiferençaExpr,
+  OperaçãoIgualdadeExpr,
+  OperaçãoOrBitwiseExpr,
+  OperaçãoOrLógicoExpr,
+  OperaçãoShiftLeftExpr,
+  OperaçãoShiftRightExpr,
+  OperaçãoXorExpr,
+  RealExpr,
+  ReferênciaArrayExpr,
+  ReferênciaMatrizExpr,
+  ReferênciaVarExpr,
+  SomaExpr,
+  SubtraçãoExpr,
+  VazioExpr,
+} from "../nodes";
+import { Expressão } from "../nodes/Expressão.js";
+
+export function resolverResultadoExpressão(expressão: Expressão, escopo: Escopo): TipoPrimitivo {
+  switch (expressão.constructor) {
+    case CadeiaExpr:
+      return TipoPrimitivo.CADEIA;
+
+    case CaractereExpr:
+      return TipoPrimitivo.CARACTER;
+
+    case InteiroExpr:
+      return TipoPrimitivo.INTEIRO;
+
+    case LógicoExpr:
+      return TipoPrimitivo.LÓGICO;
+
+    case RealExpr:
+      return TipoPrimitivo.REAL;
+
+    case VazioExpr:
+      return TipoPrimitivo.VAZIO;
+
+    case DivisãoExpr:
+    case MultiplicaçãoExpr:
+    case SubtraçãoExpr: {
+      const div = expressão as DivisãoExpr | MultiplicaçãoExpr | SubtraçãoExpr;
+      const divesq = resolverResultadoExpressão(div.esquerda, escopo);
+      const divdir = resolverResultadoExpressão(div.direita, escopo);
+      const result = TabelaCompatibilidadeDivisãoMultiplicaçãoSubtração[divesq][divdir];
+
+      if (Array.isArray(result)) {
+        return result[1];
+      }
+
+      if (result === ResultadoCompatibilidade.INCOMPATÍVEL) {
+        throw new Error(
+          `Não é possível realizar uma operação de divisão, multiplicação ou subtração entre expressões dos tipos '${divesq}' e '${divdir}'`,
+        );
+      }
+
+      return divesq === TipoPrimitivo.REAL || divdir === TipoPrimitivo.REAL
+        ? TipoPrimitivo.REAL
+        : TipoPrimitivo.INTEIRO;
+    }
+
+    case SomaExpr: {
+      const soma = expressão as SomaExpr;
+      const somaesq = resolverResultadoExpressão(soma.esquerda, escopo);
+      const somadir = resolverResultadoExpressão(soma.direita, escopo);
+      const resultSoma = TabelaCompatibilidadeSoma[somaesq][somadir];
+
+      if (Array.isArray(resultSoma)) {
+        return resultSoma[1];
+      }
+
+      if (resultSoma === ResultadoCompatibilidade.INCOMPATÍVEL) {
+        throw new Error(
+          `Não é possível realizar uma operação de soma entre expressões dos tipos '${somaesq}' e '${somadir}'`,
+        );
+      }
+
+      if (somaesq === TipoPrimitivo.CADEIA || somadir === TipoPrimitivo.CADEIA) {
+        return TipoPrimitivo.CADEIA;
+      }
+
+      if (somaesq === TipoPrimitivo.REAL || somadir === TipoPrimitivo.REAL) {
+        return TipoPrimitivo.REAL;
+      }
+
+      return TipoPrimitivo.INTEIRO;
+    }
+
+    case MóduloExpr: {
+      const mod = expressão as MóduloExpr;
+      const modesq = resolverResultadoExpressão(mod.esquerda, escopo);
+      const moddir = resolverResultadoExpressão(mod.direita, escopo);
+
+      if (TabelaCompatibilidadeModulo[modesq][moddir] === ResultadoCompatibilidade.INCOMPATÍVEL) {
+        throw new Error(
+          `Não é possível realizar uma operação de módulo entre expressões dos tipos '${modesq}' e '${moddir}'`,
+        );
+      }
+
+      if (modesq === TipoPrimitivo.REAL || moddir === TipoPrimitivo.REAL) {
+        return TipoPrimitivo.REAL;
+      }
+
+      return TipoPrimitivo.INTEIRO;
+    }
+
+    case IncrementoUnárioPrefixadoExpr:
+    case IncrementoUnárioPósfixadoExpr:
+    case DecrementoUnárioPrefixadoExpr:
+    case DecrementoUnárioPósfixadoExpr:
+      return resolverResultadoExpressão((expressão as ExpressãoUnária).variável, escopo);
+
+    case ExpressãoEntreParênteses:
+      return resolverResultadoExpressão((expressão as ExpressãoEntreParênteses).expressão, escopo);
+
+    case ReferênciaVarExpr: {
+      const ref = expressão as ReferênciaVarExpr;
+      const svar = escopo.getVariável(ref.nome);
+
+      if (!svar) {
+        throw new Error(`Variável não declarada: ${ref.nome}`);
+      }
+
+      return svar.primitivo;
+    }
+
+    case ReferênciaArrayExpr:
+    case ReferênciaMatrizExpr: {
+      const refarr = expressão as ReferênciaArrayExpr | ReferênciaMatrizExpr;
+      const vararr = escopo.getVariável(refarr.variável.nome);
+
+      if (!vararr) {
+        throw new Error(`Variável não declarada: ${refarr.variável.nome}`);
+      }
+
+      return vararr.primitivo;
+    }
+
+    case OperaçãoIgualdadeExpr:
+    case OperaçãoDiferençaExpr: {
+      const eq = expressão as OperaçãoIgualdadeExpr | OperaçãoDiferençaExpr;
+      const eqesq = resolverResultadoExpressão(eq.esquerda, escopo);
+      const eqdir = resolverResultadoExpressão(eq.direita, escopo);
+      const result = TabelaCompatibilidadeDiferençaIgualdade[eqesq][eqdir];
+
+      if (result === ResultadoCompatibilidade.INCOMPATÍVEL) {
+        throw new Error(
+          `Não é possível realizar uma operação de igualdade ou diferença entre expressões dos tipos '${eqesq}' e '${eqdir}'`,
+        );
+      }
+
+      if (Array.isArray(result)) {
+        return result[1];
+      }
+
+      return TipoPrimitivo.LÓGICO;
+    }
+
+    case OperaçãoAndLógicoExpr:
+    case OperaçãoOrLógicoExpr: {
+      const log = expressão as OperaçãoAndLógicoExpr | OperaçãoOrLógicoExpr;
+      const logesq = resolverResultadoExpressão(log.esquerda, escopo);
+      const logdir = resolverResultadoExpressão(log.direita, escopo);
+
+      if (TabelaCompatibilidadeEOu[logesq][logdir] === ResultadoCompatibilidade.INCOMPATÍVEL) {
+        throw new Error(
+          `Não é possível realizar uma operação de 'e' ou 'ou' entre expressões dos tipos '${logesq}' e '${logdir}'`,
+        );
+      }
+
+      return TipoPrimitivo.LÓGICO;
+    }
+
+    case OperaçãoOrBitwiseExpr:
+    case OperaçãoAndBitwiseExpr:
+    case OperaçãoShiftLeftExpr:
+    case OperaçãoShiftRightExpr:
+    case OperaçãoXorExpr: {
+      const bit = expressão as OperaçãoOrBitwiseExpr | OperaçãoAndBitwiseExpr;
+      const bitesq = resolverResultadoExpressão(bit.esquerda, escopo);
+      const bitdir = resolverResultadoExpressão(bit.direita, escopo);
+
+      if (TabelaCompatibilidadeBitwise[bitesq][bitdir] === ResultadoCompatibilidade.INCOMPATÍVEL) {
+        throw new Error(
+          `Não é possível realizar uma operação bitwise entre expressões dos tipos '${bitesq}' e '${bitdir}'`,
+        );
+      }
+
+      return bitesq === TipoPrimitivo.REAL || bitdir === TipoPrimitivo.REAL
+        ? TipoPrimitivo.REAL
+        : TipoPrimitivo.INTEIRO;
+    }
+
+    case NegaçãoBitwiseExpr:
+    case NegaçãoExpr:
+      return resolverResultadoExpressão((expressão as NegaçãoBitwiseExpr | NegaçãoExpr).expressão, escopo);
+
+    case MaisUnárioExpr:
+    case MenosUnárioExpr: {
+      const un = expressão as MaisUnárioExpr | MenosUnárioExpr;
+      const unvar = resolverResultadoExpressão(un.valor, escopo);
+
+      if (unvar === TipoPrimitivo.REAL) {
+        return TipoPrimitivo.REAL;
+      }
+
+      return TipoPrimitivo.INTEIRO;
+    }
+
+    case ChamadaFunçãoExpr: {
+      const chamada = expressão as ChamadaFunçãoExpr;
+      const fun = escopo.getFunção(chamada.nome);
+
+      if (chamada.escopoBiblioteca) {
+        throw new Error("TODO"); // TODO
+      }
+
+      if (!fun) {
+        throw new Error(`Função não declarada: ${chamada.nome}`);
+      }
+
+      return fun.primitivo;
+    }
+
+    default:
+      return TipoPrimitivo.VAZIO;
+  }
+}