Python 3 preparation: avoid implicit tuple parameter unpacking.

Tool-assisted patch.

Author: jsm28

roundup/cgi/TAL/TALInterpreter.py

@@ -265,12 +265,13 @@ def do_startEndTag(self, stuff):
         self.do_startTag(stuff, self.endsep, self.endlen)
     bytecode_handlers["startEndTag"] = do_startEndTag
 
-    def do_startTag(self, (name, attrList),
+    def do_startTag(self, name_attrList,
                     end=">", endlen=1, _len=len):
         # The bytecode generator does not cause calls to this method
         # for start tags with no attributes; those are optimized down
         # to rawtext events.  Hence, there is no special "fast path"
         # for that case.
+        (name, attrList) = name_attrList
         L = ["<", name]
         append = L.append
         col = self.col + _len(name) + 1
@@ -390,8 +391,9 @@ def no_tag(self, start, program):
         self.restoreOutputState(state)
         self.interpret(program)
 
-    def do_optTag(self, (name, cexpr, tag_ns, isend, start, program),
+    def do_optTag(self, args_tuple,
                   omit=0):
+        (name, cexpr, tag_ns, isend, start, program) = args_tuple
         if tag_ns and not self.showtal:
             return self.no_tag(start, program)
 
@@ -411,7 +413,8 @@ def do_optTag_tal(self, stuff):
             self.do_optTag(stuff)
     bytecode_handlers["optTag"] = do_optTag
 
-    def do_rawtextBeginScope(self, (s, col, position, closeprev, dict)):
+    def do_rawtextBeginScope(self, args_tuple):
+        (s, col, position, closeprev, dict) = args_tuple
         self._stream_write(s)
         self.col = col
         self.position = position
@@ -424,7 +427,8 @@ def do_rawtextBeginScope(self, (s, col, position, closeprev, dict)):
             self.engine.beginScope()
             self.scopeLevel = self.scopeLevel + 1
 
-    def do_rawtextBeginScope_tal(self, (s, col, position, closeprev, dict)):
+    def do_rawtextBeginScope_tal(self, args_tuple):
+        (s, col, position, closeprev, dict) = args_tuple
         self._stream_write(s)
         self.col = col
         engine = self.engine
@@ -458,11 +462,13 @@ def do_endScope(self, notused=None):
     def do_setLocal(self, notused):
         pass
 
-    def do_setLocal_tal(self, (name, expr)):
+    def do_setLocal_tal(self, name_expr):
+        (name, expr) = name_expr
         self.engine.setLocal(name, self.engine.evaluateValue(expr))
     bytecode_handlers["setLocal"] = do_setLocal
 
-    def do_setGlobal_tal(self, (name, expr)):
+    def do_setGlobal_tal(self, name_expr):
+        (name, expr) = name_expr
         self.engine.setGlobal(name, self.engine.evaluateValue(expr))
     bytecode_handlers["setGlobal"] = do_setLocal
 
@@ -560,7 +566,8 @@ def do_insertTranslation(self, stuff):
     def do_insertStructure(self, stuff):
         self.interpret(stuff[2])
 
-    def do_insertStructure_tal(self, (expr, repldict, block)):
+    def do_insertStructure_tal(self, expr_repldict_block):
+        (expr, repldict, block) = expr_repldict_block
         structure = self.engine.evaluateStructure(expr)
         if structure is None:
             return
@@ -599,10 +606,12 @@ def insertXMLStructure(self, text, repldict):
         program, macros = gen.getCode()
         self.interpret(program)
 
-    def do_loop(self, (name, expr, block)):
+    def do_loop(self, name_expr_block):
+        (name, expr, block) = name_expr_block
         self.interpret(block)
 
-    def do_loop_tal(self, (name, expr, block)):
+    def do_loop_tal(self, name_expr_block):
+        (name, expr, block) = name_expr_block
         iterator = self.engine.setRepeat(name, expr)
         while iterator.next():
             self.interpret(block)
@@ -617,22 +626,26 @@ def translate(self, msgid, default, i18ndict, obj=None):
         return self.engine.translate(self.i18nContext.domain,
                                      msgid, i18ndict, default=default)
 
-    def do_rawtextColumn(self, (s, col)):
+    def do_rawtextColumn(self, s_col):
+        (s, col) = s_col
         self._stream_write(s)
         self.col = col
     bytecode_handlers["rawtextColumn"] = do_rawtextColumn
 
-    def do_rawtextOffset(self, (s, offset)):
+    def do_rawtextOffset(self, s_offset):
+        (s, offset) = s_offset
         self._stream_write(s)
         self.col = self.col + offset
     bytecode_handlers["rawtextOffset"] = do_rawtextOffset
 
-    def do_condition(self, (condition, block)):
+    def do_condition(self, condition_block):
+        (condition, block) = condition_block
         if not self.tal or self.engine.evaluateBoolean(condition):
             self.interpret(block)
     bytecode_handlers["condition"] = do_condition
 
-    def do_defineMacro(self, (macroName, macro)):
+    def do_defineMacro(self, macroName_macro):
+        (macroName, macro) = macroName_macro
         macs = self.macroStack
         if len(macs) == 1:
             entering = macs[-1][2]
@@ -645,7 +658,8 @@ def do_defineMacro(self, (macroName, macro)):
         self.interpret(macro)
     bytecode_handlers["defineMacro"] = do_defineMacro
 
-    def do_useMacro(self, (macroName, macroExpr, compiledSlots, block)):
+    def do_useMacro(self, args_tuple):
+        (macroName, macroExpr, compiledSlots, block) = args_tuple
         if not self.metal:
             self.interpret(block)
             return
@@ -670,13 +684,15 @@ def do_useMacro(self, (macroName, macroExpr, compiledSlots, block)):
         self.popMacro()
     bytecode_handlers["useMacro"] = do_useMacro
 
-    def do_fillSlot(self, (slotName, block)):
+    def do_fillSlot(self, slotName_block):
         # This is only executed if the enclosing 'use-macro' evaluates
         # to 'default'.
+        (slotName, block) = slotName_block
         self.interpret(block)
     bytecode_handlers["fillSlot"] = do_fillSlot
 
-    def do_defineSlot(self, (slotName, block)):
+    def do_defineSlot(self, slotName_block):
+        (slotName, block) = slotName_block
         if not self.metal:
             self.interpret(block)
             return
@@ -697,10 +713,12 @@ def do_defineSlot(self, (slotName, block)):
         self.interpret(block)
     bytecode_handlers["defineSlot"] = do_defineSlot
 
-    def do_onError(self, (block, handler)):
+    def do_onError(self, block_handler):
+        (block, handler) = block_handler
         self.interpret(block)
 
-    def do_onError_tal(self, (block, handler)):
+    def do_onError_tal(self, block_handler):
+        (block, handler) = block_handler
         state = self.saveState()
         self.stream = stream = self.StringIO()
         self._stream_write = stream.write