The parser ensures that the input program is syntactically correct, but there are other kinds of correctness that it cannot (or usually does not) enforce. For example:

• A variable should not be declared more than once in the same scope.
• A variable should not be used before being declared.
• The type of the left-hand side of an assignment should match the type of the right-hand side.
• Methods should be called with the right number and types of arguments.

The next phase of the compiler after the parser, sometimes called the static semantic analyzer is in charge of checking for these kinds of errors. The checks can be done in two phases, each of which involves traversing the abstract-syntax tree created by the parser:

1. For each scope in the program: Process the declarations, adding new entries to the symbol table and reporting any variables that are multiply declared; process the statements, finding uses of undeclared variables, and updating the "ID" nodes of the abstract-syntax tree to point to the appropriate symbol-table entry.
2. Process all of the statements in the program again, using the symbol-table information to determine the type of each expression, and finding type errors.

The purpose of the symbol table is to keep track of names declared in the program. This includes names of classes, fields, methods, and variables. Each symbol table entry associates a set of attributes with one name; for example:

• which kind of name it is
• what is its type
• what is its nesting level
• where will it be found at runtime.

In most languages, the same name can be declared multiple times if the declarations occur in different scopes, and/or involve different kinds of names. For example, in Java you can use the same name for a class, a field of the class, a method of the class, and a local variable of the method (this is not recommended, but it is legal):

class Test {
  int Test;
  
  void Test(  ) {
      double Test;  // could also be declared int
  }
}

In both Java and C++ (but not in Pascal or C), you can use the same name for more than one method as long as the number and/or types of parameters are unique.

In Java you cannot declare a variable x in a method if there is also a parameter named x, or another variable named x declared in an enclosing block or for loop. However, such declarations are allowed in C++. For example, the following is a legal C++ function, but not a legal Java method:

void f( int k ) {   // k is a parameter
   int k = 0;       // also a local variable

   while (...) {
      int k = 1;   // and another local variable, inside the loop
      ...
   }
}

In the example given above, the outermost scope includes just the name "f", and function f itself has three (nested) scopes:

1. The outer scope for f just includes parameter k.
2. The next scope is for the body of f, and includes the variable k that is initialized to 0.
3. The innermost scope is for the body of the while loop, and includes the variable k that is initialized to 1.

In addition to the assumptions listed at the end of the previous section, we will assume that:

• The symbol table will be used to answer two questions:
  1. Given a declaration of a name, is there already a declaration of the same name in the current scope (i.e., is it multiply declared)?
  2. Given a use of a name, to which declaration does it correspond (using the "most closely nested" rule), or is it undeclared?
  3. The symbol table is only needed to answer those two questions (i.e., once all declarations have been processed to build the symbol table, and all uses have been processed to link each ID node in the abstract-syntax tree with the corresponding symbol-table entry, the symbol table itself is no longer needed).

1. Look up a name in the current scope only (to check if it is multiply declared).
2. Look up a name in the current and enclosing scopes (to check for a use of an undeclared name, and to link a use with the corresponding symbol-table entry).
3. Insert a new name into the symbol table with its attributes.
4. Do what must be done when a new scope is entered.
5. Do what must be done when a scope is exited.

• the symbol name
• its type
• the nesting level of its declaration

The idea behind this approach is that the symbol table consists of a list of hashtables, one for each currently visible scope. When processing a scope S, the structure of the symbol table is:

front of list           end of list
           _      _      _
          |_|--->|_|--->|_| 

           |      _________
           |           |
        declarations   |
        made in S     declarations made in scopes that enclose S; each hashtable
	              in the list corresponds to one scope (i.e., contains all
		      of the declarations for that scope)

void f(int a, int b) {
   double x;
   while (...) {
      int x, y;
      ...
   }

void g() {
   f();
}

+-----------+    +--------------+    +---------------------------+
| x: int, 3 |--->| a: int, 2    |--->| f: (int x int) -> void, 1 |
| y: int, 3 |    | b: int, 2    |    +---------------------------+
+-----------+    | x: double, 2 |
                 +--------------+    

Here are the operations that need to be performed on scope entry/exit, and to process a declaration/use:

1. On scope entry: increment the current level number and add a new empty hashtable to the front of the list.
2. To process a declaration of x: look up x in the first table in the list. If it is there, then issue a "multiply declared variable" error; otherwise, add x to the first table in the list.
3. To process a use of x: look up x starting in the first table in the list; if it is not there, then look up x in each successive table in the list. If it is not in any table then issue an "undeclared variable" error.
4. On scope exit, remove the first table from the list and decrement the current level number.

Here are the times required for each operation:

1. Scope entry: time to initialize a new, empty hashtable; this is probably proportional to the size of the hashtable.
2. Process a declaration: using hashing, constant expected time (O(1)).
3. Process a use: using hashing to do the lookup in each table in the list, the worst-case time is O(depth of nesting), when every table in the list must be examined.
4. Scope exit: time to remove a table from the list, which should be O(1) if garbage collection is ignored.

Method 2: Hashtable of Lists

The idea behind this approach is that when processing a scope S, the structure of the symbol table is:

+-----------------------------+
|          _      _      _    |
|  x:     |_|--->|_|--->|_|   |
|          _                  |
|  y:     |_|		      |
|          _      _	      |
|  z:     |_|--->|_|	      |
|                             |
+-----------------------------+

For example, given this code:

void f(int a) {
   double x;
   while (...) {
      int x, y;
      ...
   }

void g() {
   f();
}

+-------------------------------------+
|         +----------------+          |
|  f:     | int -> void, 1 |          |
|         +----------------+          |
|                                     |
|         +--------+                  |
|  a:     | int, 2 |                  |
|         +--------+                  |
|                                     |
|         +--------+    +----------+  |
|  x:     | int, 3 |--->| double, 2|  |
|         +--------+    +----------+  |
|                                     |
|         +--------+                  |
|  y:     | int, 3 |                  |
|         +--------+                  |
|                                     |
+-------------------------------------+

Note that the level-number attribute stored in each list item enables us to determine whether the most closely enclosing declaration was made in the current scope or in an enclosing scope.

Here are the operations that need to be performed on scope entry/exit, and to process a declaration/use:

1. On scope entry: increment the current level number.
2. To process a declaration of x: look up x in the symbol table. If x is there, fetch the level number from the first list item. If that level number = the current level then issue a "multiply declared variable" error; otherwise, add a new item to the front of the list with the appropriate type and the current level number.
3. To process a use of x: look up x in the symbol table. If it is not there, then issue an "undeclared variable" error.
4. On scope exit, scan all entries in the symbol table, looking at the first item on each list. If that item's level number = the current level number, then remove it from its list (and if the list becomes empty, remove the entire symbol-table entry). Finally, decrement the current level number.

1. Scope entry: time to increment the level number, O(1).
2. Process a declaration: using hashing, constant expected time (O(1)).
3. Process a use: using hashing, constant expected time (O(1)).
4. Scope exit: time proportional to the number of names in the symbol table (or perhaps even the size of the hashtable if no auxiliary information is maintained to allow iteration through the non-empty hashtable buckets).

As mentioned in the Introduction, the job of the type-checking phase is to:

• Determine the type of each expression in the program (each node in the AST that corresponds to an expression).
• Find type errors.