def makeDictCreationOrConstant(keys, values, lazy_order, source_ref): # Create dictionary node. Tries to avoid it for constant values that are not # mutable. assert len(keys) == len(values) for key, value in zip(keys, values): if not key.isExpressionConstantRef(): constant = False break if not value.isExpressionConstantRef(): constant = False break else: constant = True # Note: This would happen in optimization instead, but lets just do it # immediately to save some time. if constant: # Unless told otherwise, create the dictionary in its full size, so # that no growing occurs and the constant becomes as similar as possible # before being marshaled. result = ExpressionConstantRef( constant = Constants.createConstantDict( lazy_order = not lazy_order, keys = [ key.getConstant() for key in keys ], values = [ value.getConstant() for value in values ] ), source_ref = source_ref, user_provided = True ) else: result = ExpressionMakeDict( pairs = [ ExpressionKeyValuePair( key = key, value = value, source_ref = key.getSourceReference() ) for key, value in zip(keys, values) ], lazy_order = lazy_order, source_ref = source_ref ) if values: result.setCompatibleSourceReference( source_ref = values[-1].getCompatibleSourceReference() ) return result
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() # 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 result = ExpressionConstantRef(constant=const_type( element.getConstant() for element in elements), source_ref=source_ref, user_provided=True) else: if sequence_kind == "TUPLE": result = ExpressionMakeTuple(elements=elements, source_ref=source_ref) elif sequence_kind == "LIST": result = ExpressionMakeList(elements=elements, source_ref=source_ref) elif sequence_kind == "SET": result = ExpressionMakeSet(elements=elements, source_ref=source_ref) else: assert False, sequence_kind if elements: result.setCompatibleSourceReference( source_ref=elements[-1].getCompatibleSourceReference()) return result
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() # 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 result = ExpressionConstantRef( constant = const_type( element.getConstant() for element in elements ), source_ref = source_ref, user_provided = True ) else: if sequence_kind == "TUPLE": result = ExpressionMakeTuple( elements = elements, source_ref = source_ref ) elif sequence_kind == "LIST": result = ExpressionMakeList( elements = elements, source_ref = source_ref ) elif sequence_kind == "SET": result = ExpressionMakeSet( elements = elements, source_ref = source_ref ) else: assert False, sequence_kind if elements: result.setCompatibleSourceReference( source_ref = elements[-1].getCompatibleSourceReference() ) return result