Handling Qualified Method Invocations

Handling Qualified Method Invocations

1. The scheme I have described does not handle the processing of invocations of the form:

          obj . M ( arguments ) 
         

   • The interpretation of `M' in such an invocation should not change when we enter a new scope unless the type of value produced by the expression obj changes.. In particular, it should not matter if the same symbol M is redeclared as the name of a new variable, class or method in the new scope.

2. When the semantic processor encounters a subtree corresponding to a selection like:

   
             obj . M
   	

   it needs some way to locate a binding that associates the name M with the appropriate declaration descriptor for the method (It can't just look on the top of the stack hanging off of M's identifier descriptor).

3. The key to qualified method component names is to realize that a method name alone is potentially ambiguous. Only when paired with some particular class can a component name be interpreted unambiguously.

   • Consider how one would interpret the name `M' in a context where there where 2 distinct classes that included a method named `M'.

                 C1 x;
                 C2 y;
                 C2 z;
                 . . . x.M() . . .     y.M() . . .     z.M() . . .
                 

   • It is not the identity of the variable from which field is selected but the identity of the type of the variable that matters.
   Thus, there should be one declaration descriptor (and one binding?) for each 'structure type/component name' pair.

4. There are many ways to solve this problem.

   Approach 1

   We will already have a linked list of method declaration descriptors pointed to by each class' declaration descriptor. To process x.M do a linear search for "M" in the linked list attached to the declaration descriptor for x's class.

   This is simple, but linear lookup may not be efficient enough.

   Approach 2

   Hang a hash table of field declaration descriptors off of each class' declaration descriptor (or an AVL tree or a ...).

   This will tend to be complicated and space inefficient.

   Compromise Approach

   Employ a single dictionary structure (hash table or binary tree) in which the search keys are class/ method name pairs.

   • The keys used to look up items in this table will actually be pairs composed of a pointer to the class' declaration descriptor and a pointer to the method name's identifier descriptor.

   • The semantic processor will have access to both parts of the needed pair when it processes a selection like obj.M.

   • We will use a hash table for this purpose
   • Note that we will have to add a distinct entry to this hash table for every class by which a method is inherited.

5. Overview of required processing:

   • When processing a class' body one must:

     1. Create a declaration descriptor for the class itself.

     2. For each method specified (or inherited), create a binding between the method name and its declaration descriptor and enter it into the method hash table using as the class-descriptor/ identifier-descriptor pair as key.

   • When processing a reference to a component one must:

     1. Determine the type of the object from which the component is being selected.

     2. Look up the pair composed of the variable's type and the field name in the hash table. (Note: the type here must be a class and we will use the class descriptor rather than the type descriptor).

Handling Qualified Method Invocations