Type Checking


The compiler must perform static checking (checking done at compiler time).This ensures that certain types of programming errors will be detected and reported.

A compiler must check that the source program follows both the syntactic and semantic conversions of the source language. This checking is called static checking example of static checks include.

Some example of static checks:


A compiler should report an error if an operator is applied to an incompatible operand.

Flow-of-control checks:

Statements that cause flow of control to leave a construct must have some place to which to transfer flow of control.

For example, branching to non-existent labels.


Objects should be defined only once. This is true in many languages.

Name-related checks:

Sometimes, the same name must appear two or more times.

For example, in Ada the name of a block must appear both at the beginning of the block and at the end.

Type System:

The type analysis and type checking is an important activity done in the semantic analysis phase.

The need for type checking is

  • To detect the errors arising in the expression due to incompatible operand.
  • To generate intermediate code for expressions andstatements. Typically language supports two types of data types- basic and constructed.

The basic data type are- integer, character, and real, Boolean, enumerated data type. And Arrays, record (structure),set and pointer are the constructed types. The constructed data types are build using basic data types.

Position of Type checkingType Expression
  • Type of a language construct is either a basic type or is formed by applying an operator.
  • A type system is a collection of rules for assigning type expression to the various parts of a program.
  • A type checker implements a type system.
  • Different type system may be used by different compilers or processors of the system Language.
  • Checking done by a compiler is said to be static checking of types, while checking done when the target program runs is terminal dynamic checking of types.
  • A source type system eliminates the need for dynamic checking for type errors because it allows us to determine statically that these errors cannot occur when the target program runs.
  • Type checking should have a property of error recovery.