Homework: Program and Statement renameInstruction

This homework gives you the opportunity to review the earlier class activity and make sure you understand how to refactor a Program/Statement.

1. Using recursion, complete the body of the following static method.

   /**
    * Refactors the given {@code Statement} by renaming every occurrence of
    * instruction {@code oldName} to {@code newName}. Every other statement is
    * left unmodified.
    *
    * @param s
    *            the {@code Statement}
    * @param oldName
    *            the name of the instruction to be renamed
    * @param newName
    *            the new name of the renamed instruction
    * @updates s
    * @requires [newName is a valid IDENTIFIER]
    * @ensures <pre>
    * s = [#s refactored so that every occurrence of instruction oldName
    *   is replaced by newName]
    * </pre>
    */
   public static void renameInstruction(Statement s, String oldName,
           String newName) {...}
   

2. Using the method above, complete the body of the following static method.

   /**
    * Refactors the given {@code Program} by renaming instruction
    * {@code oldName}, and every call to it, to {@code newName}. Everything
    * else is left unmodified.
    *
    * @param p
    *            the {@code Program}
    * @param oldName
    *            the name of the instruction to be renamed
    * @param newName
    *            the new name of the renamed instruction
    * @updates p
    * @requires <pre>
    * oldName is in DOMAIN(p.context)  and
    * [newName is a valid IDENTIFIER]  and
    * newName is not in DOMAIN(p.context)
    * </pre>
    * @ensures <pre>
    * p = [#p refactored so that instruction oldName and every call
    *   to it are replaced by newName]
    * </pre>
    */
   public static void renameInstruction(Program p, String oldName,
           String newName) {...}
   

3. You may hand-draw your answer to this question. Recalling how much we care that you use correct punctuation when you write objects' values, and using the notation of Slides 9-12 in Program, but fully drawing each abstract syntax tree involved, show the value of p at the end of the following code snippet.

    1  Program p = new Program1();
    2  Map<String, Statement> context = p.newContext();
    3  Statement block = p.newBody();
    4  Statement s = block.newInstance();
    5  p.setName("Get-to-Edge-and-Wait-for-Infection");
    6  s.assembleCall("walk");
    7  block.addToBlock(0, s);
    8  s.assembleCall("run");
    9  block.addToBlock(block.lengthOfBlock(), s);
   10  s.assembleWhile(Condition.NEXT_IS_NOT_WALL, block);
   11  block.addToBlock(0, s);
   12  p.swapBody(block);
   13  s.assembleCall("move");
   14  block.addToBlock(0, s);
   15  s.assembleCall("move");
   16  block.addToBlock(block.lengthOfBlock(), s);
   17  context.add("run", block);
   18  s.assembleCall("move");
   19  block = block.newInstance();
   20  block.addToBlock(0, s);
   21  context.add("walk", block);
   22  p.swapContext(context);
   

4. Consider the occurrence on line 19 of the code snippet above of block = block.newInstance(). What would probably have happened if that statement had been replaced by block.clear()? In other words, what is the difference between the two statements? You may hand-draw a diagram to show the difference. (Hint: which are the only two lines in the code snippet in which the statement executed would introduce an alias to a mutable object? (Hint: all contracts in our components catalog advertise every introduction of an alias to a mutable object.))