/// <summary>
        /// Create IteratorDescriptor for each global value.  This pre-visit is necessary because a global early
        /// in the list may reference a global later in the list and therefore expect its IteratorDescriptor to already
        /// be initialized.
        /// </summary>
        private void PrepareGlobalValues(QilList globalIterators) {
            MethodInfo methGlobal;
            IteratorDescriptor iterInfo;

            foreach (QilIterator iter in globalIterators) {
                Debug.Assert(iter.NodeType == QilNodeType.Let || iter.NodeType == QilNodeType.Parameter);

                // Get metadata for method which computes this global's value
                methGlobal = XmlILAnnotation.Write(iter).FunctionBinding;
                Debug.Assert(methGlobal != null, "Metadata for global value should have already been computed");

                // Create an IteratorDescriptor for this global value
                iterInfo = new IteratorDescriptor(this.helper);

                // Iterator items will be stored in a global location
                iterInfo.Storage = StorageDescriptor.Global(methGlobal, GetItemStorageType(iter), !iter.XmlType.IsSingleton);

                // Associate IteratorDescriptor with parameter
                XmlILAnnotation.Write(iter).CachedIteratorDescriptor = iterInfo;
            }
        }

 protected override QilNode VisitSequence(QilList n) { return NoReplace(n); }

 public QilFunction Function(QilList args, QilNode defn, QilNode sideEffects) {
     Debug.Assert(args.NodeType == QilNodeType.FormalParameterList);
     return f.Function(args, defn, sideEffects, defn.XmlType);
 }

 public QilNode Choice(QilNode expr, QilList branches) {
     if (! debug) {
         switch (branches.Count) {
         case 1:
             // If expr has no side effects, it will be eliminated by optimizer
             return f.Loop(f.Let(expr), branches[0]);
         case 2:
             return f.Conditional(f.Eq(expr, f.LiteralInt32(0)), branches[0], branches[1]);
         }
     }
     return f.Choice(expr, branches);
 }

 public XmlQueryType CheckBranchList(QilList node) {
     return node.XmlType;
 }

 public XmlQueryType CheckFormalParameterList(QilList node) {
     foreach (QilNode child in node)
         CheckClassAndNodeType(child, typeof(QilParameter), QilNodeType.Parameter);
     return node.XmlType;
 }

 public XmlQueryType CheckGlobalParameterList(QilList node) {
     foreach (QilNode child in node) {
         CheckClassAndNodeType(child, typeof(QilParameter), QilNodeType.Parameter);
         Check(((QilParameter)child).Name != null, child, "Global parameter's name is null");
     }
     return node.XmlType;
 }

 public XmlQueryType CheckFunctionList(QilList node) {
     foreach (QilNode child in node)
         CheckClassAndNodeType(child, typeof(QilFunction), QilNodeType.Function);
     return node.XmlType;
 }

 protected override QilNode VisitBranchList(QilList n) { return NoReplace(n); }

 protected override QilNode VisitSortKeyList(QilList n) { return NoReplace(n); }

 protected override QilNode VisitFormalParameterList(QilList n) { return NoReplace(n); }

 protected override QilNode VisitGlobalVariableList(QilList n) { return NoReplace(n); }

 protected override QilNode VisitFunctionList(QilList n) { return NoReplace(n); }

 public XmlQueryType CheckGlobalVariableList(QilList node) {
     foreach (QilNode child in node)
         CheckClassAndNodeType(child, typeof(QilIterator), QilNodeType.Let);
     return node.XmlType;
 }

 protected virtual QilNode VisitFunctionList(QilList n) { return VisitChildren(n); }

 public XmlQueryType CheckActualParameterList(QilList node) {
     return node.XmlType;
 }

 protected virtual QilNode VisitGlobalVariableList(QilList n) { return VisitChildren(n); }

 public XmlQueryType CheckSortKeyList(QilList node) {
     foreach (QilNode child in node)
         CheckClassAndNodeType(child, typeof(QilSortKey), QilNodeType.SortKey);
     return node.XmlType;
 }

 protected virtual QilNode VisitFormalParameterList(QilList n) { return VisitChildren(n); }

 public XmlQueryType CheckSequence(QilList node) {
     return node.XmlType;
 }