More on Order of Declaration Processing

More on Order of Declaration Processing

1. Last week (and in the handout for the first phase), I explained that it is necessary to make (at least) two complete passes over the abstract syntax tree to correctly process the declarations in a Woolite program.
   • The goal of the first pass is to build correct declaration descriptors for all methods including information about return types and formal parameter types and to insert appropriate bindings in the hash table that maps class/name pairs to method declaration descriptors.
   • Even though the main goal is to create declaration descriptors for methods and enter them in the hash table for resolving qualified method invocations, you will also need to build declaration descriptors for class and methods and maintain scope information:
     • The return types and parameter types of methods may involve classes, so we clearly need to have created declaration descriptors for classes so that we can use them to describe these types.
     • In order to interpret the names used as return types and formal types, we need to follow normal scope rules.
     • According to normal scope rules, variable and method declarations in an inner scope can hide class declarations from outer scopes. As a result, to ensure we interpret method return and parameter types correctly, we must include such declarations in our system for representing the names accessible in a scope.
     • For similar reasons, your processing during the first pass will have to account for the inheritance of methods (since such method names might hide class names defined in surrounding scopes).
     During this first pass, you can ignore method bodies and local variables.
   • The goal of the second pass will be to use process the code and local variable declarations in method bodies.
     • The hash table built during the first phase will provide all the information needed to handle qualified method invocations
     • In order to handle unqualified references to method, type, and variable names you will need to (painfully) reconstruct the lists and stacks used to keep track of the meanings of names and you revisit the various scopes in the program.
2. Even within the first pass, processing order is critical.

3. During the first pass of semantic analysis of a program, for each class you need to:
   1. Create a declaration descriptor for each declaration found in the class (i.e. the top level declaration, not those nested in nested class declarations).
   2. Put the declaration "in scope" by adding it to the correct scope's list of bindings and the correct identifier's stack of bindings.
   3. Set (many of) the fields of each declaration descriptor that are independent of the correct meanings of other names in its scope:
      • The type of declaration,
      • Its declaration level,
      • The line number it occurred on and the identifier involved,
      • etc.
   4. Put bindings for the methods declared in the hash table that maps class/name pairs to method declarations
   5. Add the declarations of inherited methods to the scope for the class.
   6. Add entries for inherited methods paired with the enclosing class to the method hash table.
   7. Set (many of) the fields of each declaration descriptor that depend its type and on the correct meanings of other names in its scope (primarily type names):
      • Method return types,
      • Method formal parameter types,
      • Instance variable types,
   8. Check to see whether method declarations that attempt to override inherited methods have matching return and parameter types.
4. These tasks can be completed in many different orders, but there are many constraints that require certain tasks be performed before others. To understand the constraints, consider the class "Nasty" shown in Figure * below.

   class Nasty {
   
       A var;
   
       class A {
           int meth() {
               Bad x;
               x = new Bad;
               return x.meth().meth();
           }
            void C() { . . . }
        }
   
       class Bad {
           C meth () {   return new C;    }
   
           int C;
       }
   
       class C extends A {
             C meth3() {  return var;  }
        }
   
        int meth2( C p ) {
           A y;
           y = new A;
           return y.meth();
        }
   }
   

    
5. First, it should be clear that we cannot perform step (g) until step (a) has been completed since we obviously cannot use a classes declaration descriptor to represent a variable's type or a return type if the declaration descriptor hasn't been created.
   • Consider the declaration of the variable var. If we try to process declarations in order, and try to store var's type in its descriptor before we have created a descriptor fo A, we cannot possible succeed!
6. Similarly, we cannot perform step (g) until step (b) has been completed, since without putting the declarations "in scope" we will have no way of finding the correct declaration descriptor for a class name while processing a type description.
   • Again, we would not be able to process the class name A in the declaration of var.
   • The class Bad illustrates a more subtle reason for performing step (b) on all of a class' declarations before worrying about step (g). The first declaration in this class looks fine at first. It defines a class that returns an object of class C. The second declaration in Bad, however, associated a new meaning with C as a variable rather than a class. A variable name cannot be used as a return type. The declaration of meth should therefore be detected as an error. This can only be done if the return type of meth is processed after all the declarations made in Bad have been added to the scope.
7. This suggest that "pass 1" must include at least two subpasses.
   • During the first we will create declaration descriptors for every declaration in a class and put all the descriptors "in scope" by creating appropriate bindings. While we are doing this, we might as well do as much of step (c) as possible (or as much as we feel like).
   • During the second subpass, we will fill in the details described in step (g).
8. Performing step (d) is the real goal of the first pass. Since all it requires is that the method declaration descriptors exist (and not that they be completely filled in), we might as well do it on the first subpass.
9. Because it may change the meanings of names within the scope of a class, it is also necessary to perform step (e) before step (g).
   • This time, consider class C which extends A. Because it extends A, class C effectively contains a declaration of the method C which hides the name of the class itself within the scope which is the class body. As a result, the definition of meth3 within C is invalid. In this context the "C" used to specify its return type must be interpreted as the name of the method inherited from class A.
10. Since we will have to scan through all the superclasses to add inherited methods to the scope (i.e. perform step (e)), we might as well add the methods to the hash table while we are at it (i.e. perform step (f).
11. Finally, step (h) cannot be performed before step (g) for a given method since to determine whether an inherited method and a method defined within a class represent method overriding or a name conflict we have to know the return type and parameter types of both method declarations.

More on Order of Declaration Processing