public YieldAssignment(String left, bool isVar, String targetType, Expression right)
 {
     Left = left;
     IsVar = isVar;
     TargetType = targetType;
     Right = right;
 }

 public override Yielding Copy(string renameSuffix)
 {
     Expression[] valuesCopy = new Expression[Values.Length];
     for(int i = 0; i < Values.Length; ++i)
         valuesCopy[i] = Values[i].Copy(renameSuffix);
     Expression[] sourceNamesCopy = new Expression[SourceNames.Length];
     for(int i = 0; i < SourceNames.Length; ++i)
         sourceNamesCopy[i] = SourceNames[i].Copy(renameSuffix);
     return new DebugHighlightStatement(Message.Copy(renameSuffix), Values, SourceNames);
 }

 public IndexAccessEquality(IndexDescription index, 
     PatternElement neededElement, bool variablesNeeded,
     Expression expr)
     : base(index, neededElement, variablesNeeded)
 {
     Expr = expr;
 }

        ////////////////////////////////////////////////////////////////////////////

        /// <summary>
        /// Instantiates a new PatternVariable object.
        /// </summary>
        /// <param name="type">The GrGen type of the variable.</param>
        /// <param name="name">The name of the variable.</param>
        /// <param name="unprefixedName">Pure name of the variable as specified in the .grg without any prefixes.</param>
        /// <param name="parameterIndex">Specifies to which rule parameter this variable corresponds.</param>
        /// <param name="defToBeYieldedTo">Iff true the element is only defined in its PointOfDefinition pattern,
        ///     it gets matched in another, nested or called pattern which yields it to the containing pattern.</param>
        /// <param name="initialization">The initialization expression for the variable if some was defined, otherwise null.</param>
        public PatternVariable(VarType type, String name, String unprefixedName,
            int parameterIndex, bool defToBeYieldedTo, Expression initialization)
        {
            this.type = type;
            this.name = name;
            this.unprefixedName = unprefixedName;
            this.ParameterIndex = parameterIndex;
            this.defToBeYieldedTo = defToBeYieldedTo;
            this.initialization = initialization;
        }

        ////////////////////////////////////////////////////////////////////////////

        /// <summary>
        /// Constructs a PatternGraphEmbedding object.
        /// </summary>
        /// <param name="name">The name of the usage of the subpattern.</param>
        /// <param name="matchingPatternOfEmbeddedGraph">The embedded subpattern.</param>
        /// <param name="connections">An array with the expressions defining how the subpattern is connected
        /// to the containing pattern (graph elements and basic variables) .</param>
        /// <param name="yields">An array with the def elements and variables 
        /// from the containing pattern yielded to from the subpattern.</param>
        /// <param name="neededNodes">An array with names of nodes needed by this embedding.</param>
        /// <param name="neededEdges">An array with names of edges needed by this embedding.</param>
        /// <param name="neededVariables">An array with names of variables needed by this embedding.</param>
        /// <param name="neededVariableTypes">An array with types of variables needed by this embedding.</param>
        public PatternGraphEmbedding(String name, LGSPMatchingPattern matchingPatternOfEmbeddedGraph,
                Expression[] connections, String[] yields,
                String[] neededNodes, String[] neededEdges,
                String[] neededVariables, VarType[] neededVariableTypes)
        {
            this.name = name;
            this.matchingPatternOfEmbeddedGraph = matchingPatternOfEmbeddedGraph;
            this.connections = connections;
            this.yields = yields;
            this.neededNodes = neededNodes;
            this.neededEdges = neededEdges;
            this.neededVariables = neededVariables;
            this.neededVariableTypes = neededVariableTypes;

            this.matchingPatternOfEmbeddedGraph.uses += 1;
        }

        ////////////////////////////////////////////////////////////////////////////

        /// <summary>
        /// Constructs a PatternCondition object.
        /// </summary>
        /// <param name="conditionExpression">The condition expression to evaluate.</param>
        /// <param name="neededNodes">An array of node names needed by this condition.</param>
        /// <param name="neededEdges">An array of edge names needed by this condition.</param>
        /// <param name="neededVariables">An array of variable names needed by this condition.</param>
        /// <param name="neededVariableTypes">An array of variable types (corresponding to the variable names) needed by this condition.</param>
        public PatternCondition(Expression conditionExpression, 
            String[] neededNodes, String[] neededEdges, String[] neededVariables, VarType[] neededVariableTypes)
        {
            ConditionExpression = conditionExpression;
            NeededNodes = neededNodes;
            NeededEdges = neededEdges;
            NeededVariables = neededVariables;
            NeededVariableTypes = neededVariableTypes;
        }

 public IndexAccessDescending(IndexDescription index, 
     PatternElement neededElement, bool variablesNeeded,
     Expression from, bool includingFrom,
     Expression to, bool includingTo)
     : base(index, neededElement, variablesNeeded)
 {
     From = from;
     IncludingFrom = includingFrom;
     To = to;
     IncludingTo = includingTo;
 }

 public MapAdd(String left, Expression key, Expression value)
     : base(left, key)
 {
     Value = value;
 }

 public SetAdd(String left, Expression value)
     : base(left, value)
 {
 }

 public DequeRemove(String left, Expression right)
     : base(left, right)
 {
 }

 public ArrayRemove(String left, Expression right)
     : base(left, right)
 {
 }

 public SetMapRemove(String left, Expression right)
     : base(left, right)
 {
 }

 public RecordStatement(Expression toRecord)
 {
     ToRecordExpression = toRecord;
 }

 public YieldMethod(String left, Expression right)
 {
     Left = left;
     Right = right;
 }

 public YieldAssignmentIndexed(String left, Expression right, Expression index)
 {
     Left = left;
     Right = right;
     Index = index;
 }

 public ForFunction(String variable, String unprefixedVariable, String variableType, Expression function, Yielding[] statements)
 {
     Variable = variable;
     UnprefixedVariable = unprefixedVariable;
     VariableType = variableType;
     Function = function;
     Statements = statements;
 }

 public DequeAdd(String left, Expression value, Expression index)
     : base(left, value)
 {
     Index = index;
 }

 public UniqueLookup(PatternElement neededElement, bool variablesNeeded, Expression expr)
 {
     NeededElement = neededElement;
     VariablesNeeded = variablesNeeded;
     Expr = expr;
 }

 public SetMapUnion(String left, Expression right)
     : base(left, right)
 {
 }

 public SetMapIntersect(String left, Expression right)
     : base(left, right)
 {
 }