def computeExpression(self, constraint_collection):
        pos_arg = self.getPositionalArgument()
        pairs = self.getNamedArgumentPairs()

        if pos_arg is None:
            new_node = ExpressionMakeDict(
                pairs      = self.getNamedArgumentPairs(),
                source_ref = self.source_ref
            )

            # This cannot raise anymore than its arguments, as the keys will
            # be known as hashable, due to being Python parameters before.

            return (
                new_node,
                "new_expression",
                "Replace 'dict' built-in call dictionary creation from arguments."
            )

        pos_iteration_length = pos_arg.getIterationLength()

        if pos_iteration_length == 0:
            new_node = ExpressionMakeDict(
                pairs      = self.getNamedArgumentPairs(),
                source_ref = self.source_ref
            )

            # Maintain potential side effects from the positional arguments.
            new_node = wrapExpressionWithNodeSideEffects(
                old_node = ExpressionBuiltinIter1(
                    value      = pos_arg,
                    source_ref = self.source_ref
                ),
                new_node = new_node
            )

            # Just in case, the iteration may do that.
            if pos_arg.mayRaiseExceptionIter(BaseException):
                constraint_collection.onExceptionRaiseExit(BaseException)

            return (
                new_node,
                "new_expression",
                "Replace 'dict' built-in call dictionary creation from arguments."
            )

        if pos_iteration_length is not None and \
           pos_iteration_length + len(pairs) < 256 and \
           self.hasOnlyConstantArguments():
            if pos_arg is not None:
                pos_args = (
                    pos_arg,
                )
            else:
                pos_args = None

            return constraint_collection.getCompileTimeComputationResult(
                node        = self,
                computation = lambda : builtin_dict_spec.simulateCall(
                    (pos_args, self.getNamedArgumentPairs())
                ),
                description = "Replace 'dict' call with constant arguments."
            )
        else:
            constraint_collection.onExceptionRaiseExit(BaseException)

            return self, None, None
dataset/ETHPy150Open kayhayen/Nuitka/nuitka/nodes/BuiltinDictNodes.py/ExpressionBuiltinDict.computeExpression/original