In an object-oriented program, a message is sent to an object to invoke the method defined for the class of the object. In our language, expressions are evaluated within the scope of a base object (the object receiving the message) and possibly a context object (the object defining the current implementation of the method). The run-time environment includes a method map , a collection of context method maps , and an object store . As our expressions do not alter object state, the store is static.
The semantics of expressions is given by the judgment . The expression is evaluated with base object , within the scope of context object , in the current run-time environment of the dynamic method map , the collection of context method maps , and static object store . The expression evaluates to the object . The judgments for epsilon, identifier, self and context expression are simply:
Method invocation is the only composite expression. The evaluation of expression is given by the following rule:
The reference is evaluated to produce the receiver object . The reference is evaluated to produce the context object that will modify the dynamic method map for the duration of the call. The dynamic method map yields the current method implementation and its defining context object for the signature . The dynamic method map is updated based on the implementations given in the static map defined by the collection of context method maps for the class of the context object . Finally, the expression is evaluated for the receiver object , within the scope of the context object , given the new run-time environment consisting of the store , the collection of context method maps , and the updated dynamic method map . The result is the object .
Notice that the lookup of the implementation of method is performed before the update of the dynamic method map . An alternative semantics is to first do the update of and then do the lookup. We feel that we have chosen the more natural possibility.