Semantic Processing Subphase Ordering

Semantic Processing Subphase Ordering

1. The fact that Woolite supports arbitrarily deep nesting of class definitions and allows forward references to declarations (except in extends clauses) makes it necessary to make several partial sub-passes over the syntax tree and to think very carefully about what processing to perform during each pass.
2. For example, consider the simple program shown in Figure *. Even though this program only includes three declarations at the top level, it is enough to show that several "obvious" strategies for processing the declarations won't work.

   class Program {
         Forward x;
         
         class Forward {
               int counter;
            
               void relay() {
                     x.action();
                }
                
                void action() {
                    counter = counter + 1;
                }
                
                void init() {
                    counter = 0;
                }
                
                int get() {
                    return counter;
                 }
            }
            
            int main() {
                x = new Forward;
                x.relay();
                return x.get();
            }
    }
    

   Coping with forward references
    
   • If you try processing the declarations in order, you get into trouble immediately. When you go to process the declaration of the variable x, you discover that it is supposed to be of type Forward, but you haven't processed the declaration of Forward yet. You will want to put a pointer to the declaration descriptor for Forward into the declaration descriptor for x, but the descriptor for Forward won't even exist yet.

   • If you try to process the declaration of Forward before x, however, you will just run into a different problem. Forward references x in its relay method. If there is no declaration descriptor or binding for x, how can you resolve this reference to x?
   • If you try the last possibility, processing the method main first, you again encounter references to x before you have created its declaration descriptor.
3. In addition to these (relatively simple) issues raised by forward references, the ability to invoke a method on an object leads to a form of vertical forward reference through which it appears to become necessary to process inner scopes before outer scopes.
   • Consider the program in Figure *.

     class FourDeep {
     
         class A {
             int meth() {
                 B x;
                 x = new B;
                 return x.meth().meth();
             }
          }
     
     
         class B {
     
             class C {
                 int meth() {
                     return 4;
                 }
              }
     
             C meth () {
                 return new C;
             }
         }
     
          int main() {
             A y;
     
             y = new A;
             return y.meth();
          }
     }
     

     Accessing methods from inner scopes
      
4. To deal with this, your semantic processing phase will make two passes over the syntax tree.
   • During the first pass, you will completely ignore method bodies.
   • This pass will have two goals:
     1. to build (partial) declaration descriptors for each class, instance variable, and method declaration in the program.
     2. to construct the hash table that maps class/method-name pairs to method declaration descriptors
   • During this first pass, you will construct scopes and place lots of bindings, but you will discard all this information as your traversal exits scopes.
   • During the second pass, you will again traverse the tree, this time processing method bodies.
   • While you will have to rebuild all the bindings and scopes you built in the first pass, you won't have to revisits the parts of the syntax tree examined during the first pass (class and method headers, and instance variable declarations). Instead, you can access the declaration descriptors you constructed from these elements of the tree from other declaration descriptors and simply create new bindings to refer to them.

Semantic Processing Subphase Ordering