Remove support for TupleArgs.

They're not used in our test corpus, and were removed in Python 3.

opy/compiler2/pyassem.py

@@ -33,25 +33,6 @@ def _NameToIndex(name, L):
    return end


# NOTE: Similar to ast.flatten().
def flatten(tup):
    elts = []
    for elt in tup:
        if isinstance(elt, tuple):
            elts.extend(flatten(elt))
        else:
            elts.append(elt)
    return elts


def getArgCount(args):
    n = len(args)
    for arg in args:
        if isinstance(arg, TupleArg):
            n -= len(flatten(arg.names))
    return n


def ComputeStackDepth(blocks, entry_block, exit_block):
    """Compute the max stack depth.

@@ -424,10 +405,7 @@ def setArgs(self, args):
        assert not self.varnames   # Nothing should have been added
        if args:
            self.varnames = list(args)
            for i, var in enumerate(self.varnames):
                if isinstance(var, TupleArg):
                    self.varnames[i] = var.getName()
            self.argcount = getArgCount(args)
            self.argcount = len(args)

    def setDocstring(self, doc):
        self.docstring = doc
@@ -605,17 +583,6 @@ def Get(self, opname):
      return self._converters.get(opname, None)


class TupleArg(object):
    """Helper for marking func defs with nested tuples in arglist"""
    def __init__(self, count, names):
        self.count = count
        self.names = names
    def __repr__(self):
        return "TupleArg(%s, %s)" % (self.count, self.names)
    def getName(self):
        return ".%d" % self.count


class LineAddrTable(object):
    """lnotab

opy/compiler2/pycodegen.py

@@ -1299,21 +1299,12 @@ def visitDiscard(self, node):
# def fxn(a, (b, c), d):
#    pass

def _GenerateArgList(arglist):
    """Generate an arg list marking TupleArgs"""
    args = []
    extra = []
    count = 0
    for i, elt in enumerate(arglist):
        if isinstance(elt, str):
            args.append(elt)
        elif isinstance(elt, tuple):
            args.append(pyassem.TupleArg(i * 2, elt))
            extra.extend(pyassem.flatten(elt))
            count += 1
        else:
            raise ValueError("unexpect argument type: %s" % elt)
    return args + extra, count
def _CheckNoTupleArgs(func):
    for i, arg in enumerate(func.argnames):
        if isinstance(arg, tuple):
            raise RuntimeError(
                'Tuple args are not supported: %s in function %s' %
                (arg, func.name))


class _FunctionCodeGenerator(CodeGenerator):
@@ -1329,10 +1320,10 @@ def __init__(self, func, scopes, obj_name, class_name, mod):
        self.class_name = class_name
        self.module = mod

        self.args, self.hasTupleArg = _GenerateArgList(func.argnames)
        _CheckNoTupleArgs(func)
        self.graph = pyassem.PyFlowGraph(obj_name, func.filename,
                                         optimized=1)
        self.graph.setArgs(self.args)
        self.graph.setArgs(func.argnames)
        CodeGenerator.__init__(self)

    def get_module(self):
@@ -1341,7 +1332,7 @@ def get_module(self):
    def FindLocals(self):
        func = self.func 

        lnf = LocalNameFinder(set(self.args))
        lnf = LocalNameFinder(set(self.func.argnames))
        walk(func.code, lnf)
        self.locals.push(lnf.getLocals())

@@ -1350,26 +1341,13 @@ def FindLocals(self):
        if func.kwargs:
            self.graph.setFlag(CO_VARKEYWORDS)
        self.set_lineno(func)
        if self.hasTupleArg:
            for i, arg in enumerate(func.argnames):
                if isinstance(arg, tuple):
                    self.emit('LOAD_FAST', '.%d' % (i * 2))
                    self.unpackSequence(arg)

    def Finish(self, isLambda=False):
        self.graph.startExitBlock()
        if not isLambda:
            self.emit('LOAD_CONST', None)
        self.emit('RETURN_VALUE')

    def unpackSequence(self, tup):
        self.emit('UNPACK_SEQUENCE', len(tup))
        for elt in tup:
            if isinstance(elt, tuple):
                self.unpackSequence(elt)
            else:
                self._nameOp('STORE', elt)


class FunctionCodeGenerator(_FunctionCodeGenerator):