Comprobación de tipos en el diseño del compilador

La verificación de tipos es el proceso de verificar y hacer cumplir las restricciones de tipos en los valores. Un compilador debe verificar que el programa fuente siga las convenciones sintácticas y semánticas del lenguaje fuente y también debe verificar las reglas de tipo del lenguaje. Permite al programador limitar qué tipos se pueden usar en ciertas circunstancias y asigna tipos a valores. El verificador de tipos determina si estos valores se usan apropiadamente o no.

Verifica el tipo de objetos e informa un error de tipo en el caso de una violación, y se corrigen los tipos incorrectos. Cualquiera que sea el compilador que usemos, mientras compila el programa, tiene que seguir las reglas de tipo del lenguaje. Cada idioma tiene su propio conjunto de reglas de tipo para el idioma. Sabemos que el compilador mantiene y calcula la información sobre los tipos de datos.

El compilador mantiene y calcula la información sobre tipos de datos como INTEGER, FLOAT, CHARACTER y todos los demás tipos de datos. El compilador contiene módulos, donde el verificador de tipos es un módulo de un compilador y su tarea es la verificación de tipos.

Coerción

La conversión de un tipo a otro tipo se conoce como implícita si el compilador debe realizarla automáticamente. Las conversiones de tipos implícitas también se denominan coerción y la coerción está limitada en muchos idiomas.

Ejemplo : un número entero se puede convertir en real, pero el real no se convierte en número entero.

Se dice que la conversión es explícita si el programador escribe algo para hacer la conversión.

Tareas:

1. tiene que permitir «La indexación es solo en una array» 
2. tiene que verificar el rango de tipos de datos utilizados
3. INTEGER (int) tiene un rango de -32,768 a +32767
4. FLOAT tiene un rango de 1.2E-38 a 3.4E+38. 

Tipos de comprobación de tipo:

Hay dos tipos de verificación de tipos:

1. Comprobación de tipo estático.
2. Comprobación dinámica de tipos.

Comprobación de tipo estático:

La verificación de tipo estático se define como la verificación de tipo realizada en tiempo de compilación. Comprueba las variables de tipo en tiempo de compilación, lo que significa que el tipo de variable se conoce en el momento de la compilación. Generalmente examina el texto del programa durante la traducción del programa. Usando las reglas de tipo de un sistema, un compilador puede inferir del texto fuente que una función (fun) se aplicará a un operando (a) del tipo correcto cada vez que se evalúe la expresión fun(a).

Los ejemplos de comprobaciones estáticas incluyen:

• Comprobaciones de tipo: un compilador debe informar un error si se aplica un operador a un operando incompatible. Por ejemplo, si se suman una variable de array y una variable de función.
• Las comprobaciones de flujo de control: las declaraciones que hacen que el flujo de control abandone una construcción deben tener un lugar al que transferir el flujo de control. Por ejemplo, una declaración de interrupción en C hace que el control deje la instrucción envolvente más pequeña mientras, para o interruptor, se produce un error si dicha instrucción envolvente no existe.
• Verificaciones de unicidad: hay situaciones en las que un objeto debe definirse solo una vez. Por ejemplo, en Pascal, un identificador debe declararse de forma única, las etiquetas en una declaración de caso deben ser distintas y, de lo contrario, es posible que no se represente una declaración en un tipo de escalador.
• Comprobaciones relacionadas con el nombre: en ocasiones, el mismo nombre puede aparecer dos o más veces. Por ejemplo, en Ada, un ciclo puede tener un nombre que aparece al principio y al final de la construcción. El compilador debe verificar que se use el mismo nombre en ambos lugares.

Los beneficios de la verificación de tipos estáticos:

1. Protección contra errores de tiempo de ejecución.
2. Atrapa errores sintácticos como palabras falsas o puntuación adicional.
3. Atrapa nombres incorrectos como matemáticas y nombres predefinidos.
4. Detecta tipos de argumentos incorrectos.
5. Atrapa el número incorrecto de argumentos.
6. Atrapa tipos de devolución incorrectos, como devolver «70», de una función que se declara para devolver un int.

Comprobación dinámica de tipos:

La comprobación dinámica de tipos se define como la comprobación de tipos que se realiza en tiempo de ejecución. En la Comprobación dinámica de tipos, los tipos se asocian con valores, no con variables. Las implementaciones de objetos de tiempo de ejecución de lenguajes con verificación de tipo dinámica generalmente se asocian entre sí a través de una etiqueta de tipo, que es una referencia a un tipo que contiene su información de tipo. La escritura dinámica es más flexible. Un sistema de tipo estático siempre restringe lo que se puede expresar convenientemente. La escritura dinámica da como resultado programas más compactos, ya que es más flexible y no requiere que se escriban los tipos. La programación con un sistema de tipo estático a menudo requiere más esfuerzo de diseño e implementación.

Los lenguajes como Pascal y C tienen verificación de tipo estático. La comprobación de tipos se utiliza para comprobar la corrección del programa antes de su ejecución. El objetivo principal de la verificación de tipos es verificar la corrección y las asignaciones de tipos de datos y la conversión de tipos de los tipos de datos, ya sea sintácticamente correcto o no antes de su ejecución.
La comprobación de tipos estáticos también se utiliza para determinar la cantidad de memoria necesaria para almacenar la variable.

El diseño del verificador de tipos depende de:

1. Estructura sintáctica de las construcciones del lenguaje.
2. Las expresiones de las lenguas.
3. Las reglas para asignar tipos a construcciones (reglas semánticas).
    

La posición del verificador de tipo en el compilador:

Los flujos de tokens del analizador léxico se pasan al PARSER. El PARSER generará un árbol de sintaxis. Cuando un programa (código fuente) se convierte en un árbol de sintaxis, el verificador de tipos juega un papel crucial. Entonces, al ver el árbol de sintaxis, puede saber si cada tipo de datos está manejando la variable correcta o no. El verificador de tipos verificará y, si hay alguna modificación presente, la modificará. Produce un árbol de sintaxis, y después de eso, se realiza la generación de CÓDIGO INTERMEDIO. 

Sobrecarga:

Un símbolo de Sobrecarga es aquel que tiene diferentes operaciones dependiendo de su contexto.

La sobrecarga es de dos tipos:

1. Sobrecarga del operador 
2. Sobrecarga de funciones

Sobrecarga de operadores: En Matemáticas, la expresión aritmética “x+y” tiene el operador de suma ‘+’ está sobrecargada porque ‘+’ en “x+y” tiene diferentes operadores cuando ‘x’ e ‘y’ son números enteros, números complejos, reales y arrays.

Ejemplo: En Ada, los paréntesis ‘()’ están sobrecargados, el i ^-ésimo elemento de la expresión A(i) de un Array A tiene un significado diferente, como una ‘llamada a la función ‘A’ con el argumento ‘i’ o un conversión explícita de la expresión i al tipo ‘A’. En la mayoría de los idiomas, los operadores aritméticos están sobrecargados.

Sobrecarga de funciones: el verificador de tipos resuelve la sobrecarga de funciones en función de los tipos de argumentos y números.

Ejemplo: 

E-->E1(E2)
               {
                  E.type:= if E2.type = s 
                  E1.type = s -->t then t
                                 else type_error 
               }