Method visit_Assign

python/cudaq/kernel/ast_bridge.py:1984–2322

Map an assign operation in the AST to an equivalent variable value assignment in the MLIR. This method handles assignments, item updates, as well as deconstruction. For all assignments, the variable name will be used as a key for the symbol table, mapping to the corr

(self, node)

        self.pushValue(lambdaFct)

    def visit_Assign(self, node):
        """Map an assign operation in the AST to an equivalent variable value
        assignment in the MLIR. This method handles assignments, item updates,
        as well as deconstruction.

        For all assignments, the variable name will be used as a key for the
        symbol table, mapping to the corresponding MLIR Value. Quantum values,
        measurements results, `cc.callable`, and `cc.stdvec` will be stored as
        values in the symbol table.  For all other values, the variable will be
        allocated with a `cc.alloca` op, and the pointer will be stored in
        the symbol table.
        """

        def storedAsValue(val):
            varTy = val.type
            if cc.PointerType.isinstance(varTy):
                varTy = cc.PointerType.getElementType(varTy)
            # If `buildingFunctionBody` is not set we are processing function
            # arguments. Function arguments are always passed by value,
            # except states. We can treat non-container function arguments
            # like any local variable and create a stack slot for them.
            # For container types, on the the other hand, we need to preserve
            # them as values in the symbol table to make sure we can detect
            # any access to reference types that are function arguments, or
            # function argument items.
            containerFuncArg = (not self.buildingFunctionBody and
                                (cc.StructType.isinstance(varTy) or
                                 cc.StdvecType.isinstance(varTy)))
            # FIXME: Consider storing vectors and callables as pointers like
            # other variables.
            # A local `!cc.stdvec<!cc.measure_handle>` is backed by a stack slot
            # (like a scalar `!cc.measure_handle`) so it can be reassigned from a
            # child block. Function-argument handle vectors stay value-backed via
            # `containerFuncArg`; every other vector stays value-backed so
            # reassigning a general list across scopes is still rejected.
            # See https://github.com/NVIDIA/cuda-quantum/issues/4601.
            # Discriminated measurement results (`i1` / `stdvec<i1>` produced by
            # `quake.discriminate`) are stored like any other value: the
            # `!cc.measure_handle` type now carries the "is a measurement"
            # distinction, so they no longer need a value-storage carve-out to
            # preserve their discriminate origin.
            isLocalHandleVec = (cc.StdvecType.isinstance(varTy) and
                                cc.MeasureHandleType.isinstance(
                                    cc.StdvecType.getElementType(varTy)))
            storeAsVal = (containerFuncArg or self.isQuantumType(varTy) or
                          cc.CallableType.isinstance(varTy) or
                          (cc.StdvecType.isinstance(varTy) and
                           not isLocalHandleVec))
            # Nothing should ever produce a pointer to a type we store as value
            # in the symbol table.
            assert (not storeAsVal or not cc.PointerType.isinstance(val.type))
            return storeAsVal

        def process_assignment(target, value):

            if isinstance(target, ast.Tuple):

                if (isinstance(value, ast.Tuple) or