Example #1
0
def makeSequenceCreationOrConstant(sequence_kind, elements, source_ref):
    # Sequence creation. Tries to avoid creations with only constant
    # elements. Would be caught by optimization, but would be useless churn. For
    # mutable constants we cannot do it though.

    # Due to the many sequence types, there is a lot of cases here
    # pylint: disable=R0912

    for element in elements:
        if not element.isExpressionConstantRef():
            constant = False
            break
    else:
        constant = True

    sequence_kind = sequence_kind.upper()

    if Options.isFullCompat() and elements:
        source_ref = elements[-1].getSourceReference()

    # Note: This would happen in optimization instead, but lets just do it
    # immediately to save some time.
    if constant:
        if sequence_kind == "TUPLE":
            const_type = tuple
        elif sequence_kind == "LIST":
            const_type = list
        elif sequence_kind == "SET":
            const_type = set
        else:
            assert False, sequence_kind

        return ExpressionConstantRef(
            constant      = const_type(
                element.getConstant()
                for element in
                elements
            ),
            source_ref    = source_ref,
            user_provided = True
        )
    else:
        if sequence_kind == "TUPLE":
            return ExpressionMakeTuple(
                elements   = elements,
                source_ref = source_ref
            )
        elif sequence_kind == "LIST":
            return ExpressionMakeList(
                elements   = elements,
                source_ref = source_ref
            )
        elif sequence_kind == "SET":
            return ExpressionMakeSet(
                elements   = elements,
                source_ref = source_ref
            )
        else:
            assert False, sequence_kind
Example #2
0
def buildSequenceCreationNode(provider, node, source_ref):
    # Sequence creation. Tries to avoid creations with only constant elements. Would be
    # caught by optimization, but would be useless churn. For mutable constants we cannot
    # do it though.

    elements = buildNodeList(provider, node.elts, source_ref)

    for element in elements:
        if not element.isExpressionConstantRef() or element.isMutable():
            constant = False
            break
    else:
        constant = True

    sequence_kind = getKind(node).upper()

    # Note: This would happen in optimization instead, but lets just do it immediately to
    # save some time.
    if constant:
        if sequence_kind == "TUPLE":
            const_type = tuple
        elif sequence_kind == "LIST":
            const_type = list
        elif sequence_kind == "SET":
            const_type = set
        else:
            assert False, sequence_kind

        return ExpressionConstantRef(constant=const_type(
            element.getConstant() for element in elements),
                                     source_ref=source_ref)
    else:
        if sequence_kind == "TUPLE":
            return ExpressionMakeTuple(elements=elements,
                                       source_ref=source_ref)
        elif sequence_kind == "LIST":
            return ExpressionMakeList(elements=elements, source_ref=source_ref)
        elif sequence_kind == "SET":
            return ExpressionMakeSet(elements=elements, source_ref=source_ref)
        else:
            assert False, sequence_kind