The Labs \ Source Viewer \ SSCLI \ System.Xml.Xsl.IlGen \ EqualityIndexVisitor

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlILOptimizerVisitor.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. using System;
  16. using System.Collections;
  17. using System.Collections.Generic;
  18. using System.Diagnostics;
  19. using System.Xml;
  20. using System.Xml.XPath;
  21. using System.Xml.Schema;
  22. using TypeFactory = System.Xml.Xsl.XmlQueryTypeFactory;
  23. using System.Xml.Xsl.Qil;
  24. using System.Xml.Xsl.Runtime;
  25. namespace System.Xml.Xsl.IlGen
  26. {
  27.    
  28.     /// <summary>
  29.     /// </summary>
  30.     internal class XmlILOptimizerVisitor : QilPatternVisitor
  31.     {
  32.         private static readonly QilPatterns PatternsNoOpt, PatternsOpt;
  33.         private QilExpression qil;
  34.         private XmlILElementAnalyzer elemAnalyzer;
  35.         private XmlILStateAnalyzer contentAnalyzer;
  36.         private XmlILNamespaceAnalyzer nmspAnalyzer;
  37.         private NodeCounter nodeCounter = new NodeCounter();
  38.         private SubstitutionList subs = new SubstitutionList();
  39.        
  40.         static XmlILOptimizerVisitor()
  41.         {
  42.             // Enable all normalizations and annotations for Release code
  43.             // Enable all patterns for Release code
  44.             PatternsOpt = new QilPatterns((int)XmlILOptimization.Last_, true);
  45.            
  46.             // Only enable Required and OptimizedConstruction pattern groups
  47.             // Only enable Required patterns
  48.             PatternsNoOpt = new QilPatterns((int)XmlILOptimization.Last_, false);
  49.            
  50.             PatternsNoOpt.Add((int)XmlILOptimization.FoldNone);
  51.             PatternsNoOpt.Add((int)XmlILOptimization.EliminatePositionOf);
  52.             PatternsNoOpt.Add((int)XmlILOptimization.EliminateTypeAssert);
  53.             PatternsNoOpt.Add((int)XmlILOptimization.EliminateIsType);
  54.             PatternsNoOpt.Add((int)XmlILOptimization.EliminateIsEmpty);
  55.             PatternsNoOpt.Add((int)XmlILOptimization.EliminateAverage);
  56.             PatternsNoOpt.Add((int)XmlILOptimization.EliminateSum);
  57.             PatternsNoOpt.Add((int)XmlILOptimization.EliminateMinimum);
  58.             PatternsNoOpt.Add((int)XmlILOptimization.EliminateMaximum);
  59.             PatternsNoOpt.Add((int)XmlILOptimization.EliminateSort);
  60.             PatternsNoOpt.Add((int)XmlILOptimization.EliminateStrConcatSingle);
  61.            
  62.             PatternsNoOpt.Add((int)XmlILOptimization.NormalizeUnion);
  63.             PatternsNoOpt.Add((int)XmlILOptimization.NormalizeIntersect);
  64.             PatternsNoOpt.Add((int)XmlILOptimization.NormalizeDifference);
  65.            
  66.             PatternsNoOpt.Add((int)XmlILOptimization.AnnotatePositionalIterator);
  67.             PatternsNoOpt.Add((int)XmlILOptimization.AnnotateTrackCallers);
  68.             PatternsNoOpt.Add((int)XmlILOptimization.AnnotateDod);
  69.             PatternsNoOpt.Add((int)XmlILOptimization.AnnotateConstruction);
  70.             PatternsNoOpt.Add((int)XmlILOptimization.AnnotateIndex1);
  71.             PatternsNoOpt.Add((int)XmlILOptimization.AnnotateIndex2);
  72.         }
  73.        
  74.         public XmlILOptimizerVisitor(QilExpression qil, bool optimize) : base(optimize ? PatternsOpt : PatternsNoOpt, qil.Factory)
  75.         {
  76.             this.qil = qil;
  77.             this.elemAnalyzer = new XmlILElementAnalyzer(qil.Factory);
  78.             this.contentAnalyzer = new XmlILStateAnalyzer(qil.Factory);
  79.             this.nmspAnalyzer = new XmlILNamespaceAnalyzer();
  80.         }
  81.        
  82.         /// <summary>
  83.         /// Perform normalization and annotation.
  84.         /// </summary>
  85.         public QilExpression Optimize()
  86.         {
  87.             QilExpression qil = (QilExpression)Visit(this.qil);
  88.            
  89.             // Perform tail-call analysis on all functions within the Qil expression
  90.             if (this[XmlILOptimization.TailCall])
  91.                 TailCallAnalyzer.Analyze(qil);
  92.            
  93.             return qil;
  94.         }
  95.        
  96.         /// <summary>
  97.         /// Override the Visit method in order to scan for redundant namespaces and compute side-effect bit.
  98.         /// </summary>
  99.         protected override QilNode Visit(QilNode nd)
  100.         {
  101.             if (nd != null) {
  102.                 if (this[XmlILOptimization.EliminateNamespaceDecl]) {
  103.                     // Eliminate redundant namespaces in the tree. Don't perform the scan on an ElementCtor which
  104.                     // has already been marked as having a redundant namespace.
  105.                     switch (nd.NodeType) {
  106.                         case QilNodeType.QilExpression:
  107.                             // Perform namespace analysis on root expression (xmlns="" is in-scope for this expression)
  108.                             this.nmspAnalyzer.Analyze(((QilExpression)nd).Root, true);
  109.                             break;
  110.                         case QilNodeType.ElementCtor:
  111.                            
  112.                             if (!XmlILConstructInfo.Read(nd).IsNamespaceInScope)
  113.                                 this.nmspAnalyzer.Analyze(nd, false);
  114.                             break;
  115.                         case QilNodeType.DocumentCtor:
  116.                            
  117.                             this.nmspAnalyzer.Analyze(nd, true);
  118.                             break;
  119.                     }
  120.                 }
  121.             }
  122.            
  123.             // Continue visitation
  124.             return base.Visit(nd);
  125.         }
  126.        
  127.         /// <summary>
  128.         /// Override the VisitReference method in order to possibly substitute.
  129.         /// </summary>
  130.         protected override QilNode VisitReference(QilNode oldNode)
  131.         {
  132.             QilNode newNode = this.subs.FindReplacement(oldNode);
  133.            
  134.             if (newNode == null)
  135.                 newNode = oldNode;
  136.            
  137.             // Fold reference to constant value
  138.             // This is done here because "p" currently cannot match references
  139.             if (this[XmlILOptimization.FoldConstant] && newNode != null) {
  140.                 if (newNode.NodeType == QilNodeType.Let || newNode.NodeType == QilNodeType.For) {
  141.                     QilNode binding = ((QilIterator)oldNode).Binding;
  142.                    
  143.                     if (IsLiteral(binding))
  144.                         return Replace(XmlILOptimization.FoldConstant, newNode, binding.ShallowClone(f));
  145.                 }
  146.             }
  147.            
  148.             return base.VisitReference(newNode);
  149.         }
  150.        
  151.         /// <summary>
  152.         /// Strongly-typed AllowReplace.
  153.         /// </summary>
  154.         protected bool AllowReplace(XmlILOptimization pattern, QilNode original)
  155.         {
  156.             return base.AllowReplace((int)pattern, original);
  157.         }
  158.        
  159.         /// <summary>
  160.         /// Strongly-typed Replace.
  161.         /// </summary>
  162.         protected QilNode Replace(XmlILOptimization pattern, QilNode original, QilNode replacement)
  163.         {
  164.             return base.Replace((int)pattern, original, replacement);
  165.         }
  166.        
  167.         /// <summary>
  168.         /// Called when all replacements have already been made and all annotations are complete.
  169.         /// </summary>
  170.         protected override QilNode NoReplace(QilNode node)
  171.         {
  172.             // Calculate MaybeSideEffects pattern. This is done here rather than using P because every node needs
  173.             // to compute it and P has no good way of matching every node type.
  174.             if (node != null) {
  175.                 switch (node.NodeType) {
  176.                     case QilNodeType.Error:
  177.                     case QilNodeType.Warning:
  178.                     case QilNodeType.XsltInvokeLateBound:
  179.                         // Error, Warning, and XsltInvokeLateBound are always assumed to have side-effects
  180.                         OptimizerPatterns.Write(node).AddPattern(OptimizerPatternName.MaybeSideEffects);
  181.                         break;
  182.                     case QilNodeType.XsltInvokeEarlyBound:
  183.                        
  184.                         // XsltInvokeEarlyBound is assumed to have side-effects if it is not a built-in function
  185.                         if (((QilInvokeEarlyBound)node).Name.NamespaceUri.Length != 0)
  186.                             goto case QilNodeType.XsltInvokeLateBound;
  187.                         goto default;
  188.                         break;
  189.                     case QilNodeType.Invoke:
  190.                        
  191.                         // Invoke is assumed to have side-effects if it invokes a function with its SideEffects flag set
  192.                         if (((QilInvoke)node).Function.MaybeSideEffects)
  193.                             goto case QilNodeType.XsltInvokeLateBound;
  194.                        
  195.                         // Otherwise, check children
  196.                         goto default;
  197.                         break;
  198.                     default:
  199.                        
  200.                         // If any of the visited node's children have side effects, then mark the node as also having side effects
  201.                         for (int i = 0; i < node.Count; i++) {
  202.                             if (node[i] != null) {
  203.                                 if (OptimizerPatterns.Read(node[i]).MatchesPattern(OptimizerPatternName.MaybeSideEffects))
  204.                                     goto case QilNodeType.XsltInvokeLateBound;
  205.                             }
  206.                         }
  207.                         break;
  208.                 }
  209.             }
  210.            
  211.             return node;
  212.         }
  213.        
  214.         /// <summary>
  215.         /// Override the RecalculateType method so that global variable type is not recalculated.
  216.         /// </summary>
  217.         protected override void RecalculateType(QilNode node, XmlQueryType oldType)
  218.         {
  219.             if (node.NodeType != QilNodeType.Let || !this.qil.GlobalVariableList.Contains(node))
  220.                 base.RecalculateType(node, oldType);
  221.         }
  222.        
  223.         // Do not edit this region
  224.         // It is auto-generated
  225.         #region AUTOGENERATED
  226.        
  227.         #region meta
  228.         protected override QilNode VisitQilExpression(QilExpression local0)
  229.         {
  230.             QilNode local1 = local0[0];
  231.             if (this[XmlILOptimization.EliminateUnusedFunctions]) {
  232.                 if (AllowReplace(XmlILOptimization.EliminateUnusedFunctions, local0)) {
  233.                    
  234.                     IList<QilNode> funcList = local0.FunctionList;
  235.                     for (int i = funcList.Count - 1; i >= 0; i--) {
  236.                         if (XmlILConstructInfo.Write(funcList[i]).CallersInfo.Count == 0)
  237.                             funcList.RemoveAt(i);
  238.                     }
  239.                 }
  240.             }
  241.             if (this[XmlILOptimization.AnnotateConstruction]) {
  242.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  243.                    
  244.                     foreach (QilFunction ndFunc in local0.FunctionList) {
  245.                         // Functions that construct Xml trees should stream output to writer; otherwise, results should
  246.                         // be cached and returned.
  247.                         if (IsConstructedExpression(ndFunc.Definition)) {
  248.                             // Perform state analysis on function's content
  249.                             ndFunc.Definition = this.contentAnalyzer.Analyze(ndFunc, ndFunc.Definition);
  250.                         }
  251.                     }
  252.                    
  253.                     // Perform state analysis on the root expression
  254.                     local0.Root = this.contentAnalyzer.Analyze(null, local0.Root);
  255.                    
  256.                     // Make sure that root expression is pushed to writer
  257.                     XmlILConstructInfo.Write(local0.Root).PushToWriterLast = true;
  258.                 }
  259.             }
  260.             return NoReplace(local0);
  261.         }
  262.        
  263.         protected override QilNode VisitOptimizeBarrier(QilUnary local0)
  264.         {
  265.             QilNode local1 = local0[0];
  266.             if (this[XmlILOptimization.AnnotateBarrier]) {
  267.                 if (AllowReplace(XmlILOptimization.AnnotateBarrier, local0)) {
  268.                     OptimizerPatterns.Inherit((QilNode)(local1), (QilNode)(local0), OptimizerPatternName.IsDocOrderDistinct);
  269.                     OptimizerPatterns.Inherit((QilNode)(local1), (QilNode)(local0), OptimizerPatternName.SameDepth);
  270.                 }
  271.             }
  272.             return NoReplace(local0);
  273.         }
  274.        
  275.         #endregion // meta
  276.        
  277.         #region specials
  278.         protected override QilNode VisitDataSource(QilDataSource local0)
  279.         {
  280.             QilNode local1 = local0[0];
  281.             QilNode local2 = local0[1];
  282.             if (this[XmlILOptimization.FoldNone]) {
  283.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  284.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  285.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  286.                     }
  287.                 }
  288.             }
  289.             if (this[XmlILOptimization.FoldNone]) {
  290.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  291.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  292.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  293.                     }
  294.                 }
  295.             }
  296.             return NoReplace(local0);
  297.         }
  298.        
  299.         protected override QilNode VisitNop(QilUnary local0)
  300.         {
  301.             QilNode local1 = local0[0];
  302.             if (this[XmlILOptimization.EliminateNop]) {
  303.                 if (AllowReplace(XmlILOptimization.EliminateNop, local0)) {
  304.                     return Replace(XmlILOptimization.EliminateNop, local0, local1);
  305.                 }
  306.             }
  307.             return NoReplace(local0);
  308.         }
  309.        
  310.         protected override QilNode VisitError(QilUnary local0)
  311.         {
  312.             QilNode local1 = local0[0];
  313.             if (this[XmlILOptimization.FoldNone]) {
  314.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  315.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  316.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  317.                     }
  318.                 }
  319.             }
  320.             return NoReplace(local0);
  321.         }
  322.        
  323.         protected override QilNode VisitWarning(QilUnary local0)
  324.         {
  325.             QilNode local1 = local0[0];
  326.             if (this[XmlILOptimization.FoldNone]) {
  327.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  328.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  329.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  330.                     }
  331.                 }
  332.             }
  333.             return NoReplace(local0);
  334.         }
  335.        
  336.         #endregion // specials
  337.        
  338.         #region variables
  339.         protected override QilNode VisitLet(QilIterator local0)
  340.         {
  341.             QilNode local1 = local0[0];
  342.             if (((((local0).XmlType).IsSingleton) && (!(IsGlobalVariable(local0)))) && (this[XmlILOptimization.NormalizeSingletonLet])) {
  343.                 if (AllowReplace(XmlILOptimization.NormalizeSingletonLet, local0)) {
  344.                    
  345.                     local0.NodeType = QilNodeType.For;
  346.                     VisitFor(local0);
  347.                 }
  348.             }
  349.             if (this[XmlILOptimization.AnnotateLet]) {
  350.                 if (AllowReplace(XmlILOptimization.AnnotateLet, local0)) {
  351.                     OptimizerPatterns.Inherit((QilNode)(local1), (QilNode)(local0), OptimizerPatternName.Step);
  352.                     OptimizerPatterns.Inherit((QilNode)(local1), (QilNode)(local0), OptimizerPatternName.IsDocOrderDistinct);
  353.                     OptimizerPatterns.Inherit((QilNode)(local1), (QilNode)(local0), OptimizerPatternName.SameDepth);
  354.                 }
  355.             }
  356.             return NoReplace(local0);
  357.         }
  358.        
  359.         protected override QilNode VisitPositionOf(QilUnary local0)
  360.         {
  361.             QilNode local1 = local0[0];
  362.             if (this[XmlILOptimization.EliminatePositionOf]) {
  363.                 if (!((local1).NodeType == QilNodeType.For)) {
  364.                     if (AllowReplace(XmlILOptimization.EliminatePositionOf, local0)) {
  365.                         return Replace(XmlILOptimization.EliminatePositionOf, local0, VisitLiteralInt32(f.LiteralInt32(1)));
  366.                     }
  367.                 }
  368.             }
  369.             if (this[XmlILOptimization.EliminatePositionOf]) {
  370.                 if (local1.NodeType == QilNodeType.For) {
  371.                     QilNode local2 = local1[0];
  372.                     if (((local2).XmlType).IsSingleton) {
  373.                         if (AllowReplace(XmlILOptimization.EliminatePositionOf, local0)) {
  374.                             return Replace(XmlILOptimization.EliminatePositionOf, local0, VisitLiteralInt32(f.LiteralInt32(1)));
  375.                         }
  376.                     }
  377.                 }
  378.             }
  379.             if (this[XmlILOptimization.AnnotatePositionalIterator]) {
  380.                 if (AllowReplace(XmlILOptimization.AnnotatePositionalIterator, local0)) {
  381.                     OptimizerPatterns.Write((QilNode)(local1)).AddPattern(OptimizerPatternName.IsPositional);
  382.                 }
  383.             }
  384.             return NoReplace(local0);
  385.         }
  386.        
  387.         #endregion // variables
  388.        
  389.         #region literals
  390.         #endregion // literals
  391.        
  392.         #region boolean operators
  393.         protected override QilNode VisitAnd(QilBinary local0)
  394.         {
  395.             QilNode local1 = local0[0];
  396.             QilNode local2 = local0[1];
  397.             if (this[XmlILOptimization.FoldNone]) {
  398.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  399.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  400.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  401.                     }
  402.                 }
  403.             }
  404.             if (this[XmlILOptimization.FoldNone]) {
  405.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  406.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  407.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  408.                     }
  409.                 }
  410.             }
  411.             if (this[XmlILOptimization.EliminateAnd]) {
  412.                 if (local1.NodeType == QilNodeType.True) {
  413.                     if (AllowReplace(XmlILOptimization.EliminateAnd, local0)) {
  414.                         return Replace(XmlILOptimization.EliminateAnd, local0, local2);
  415.                     }
  416.                 }
  417.             }
  418.             if (this[XmlILOptimization.EliminateAnd]) {
  419.                 if (local1.NodeType == QilNodeType.False) {
  420.                     if (AllowReplace(XmlILOptimization.EliminateAnd, local0)) {
  421.                         return Replace(XmlILOptimization.EliminateAnd, local0, local1);
  422.                     }
  423.                 }
  424.             }
  425.             if (this[XmlILOptimization.EliminateAnd]) {
  426.                 if (local2.NodeType == QilNodeType.True) {
  427.                     if (AllowReplace(XmlILOptimization.EliminateAnd, local0)) {
  428.                         return Replace(XmlILOptimization.EliminateAnd, local0, local1);
  429.                     }
  430.                 }
  431.             }
  432.             if (this[XmlILOptimization.EliminateAnd]) {
  433.                 if (local2.NodeType == QilNodeType.False) {
  434.                     if (AllowReplace(XmlILOptimization.EliminateAnd, local0)) {
  435.                         return Replace(XmlILOptimization.EliminateAnd, local0, local2);
  436.                     }
  437.                 }
  438.             }
  439.             return NoReplace(local0);
  440.         }
  441.        
  442.         protected override QilNode VisitOr(QilBinary local0)
  443.         {
  444.             QilNode local1 = local0[0];
  445.             QilNode local2 = local0[1];
  446.             if (this[XmlILOptimization.FoldNone]) {
  447.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  448.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  449.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  450.                     }
  451.                 }
  452.             }
  453.             if (this[XmlILOptimization.FoldNone]) {
  454.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  455.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  456.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  457.                     }
  458.                 }
  459.             }
  460.             if (this[XmlILOptimization.EliminateOr]) {
  461.                 if (local1.NodeType == QilNodeType.True) {
  462.                     if (AllowReplace(XmlILOptimization.EliminateOr, local0)) {
  463.                         return Replace(XmlILOptimization.EliminateOr, local0, local1);
  464.                     }
  465.                 }
  466.             }
  467.             if (this[XmlILOptimization.EliminateOr]) {
  468.                 if (local1.NodeType == QilNodeType.False) {
  469.                     if (AllowReplace(XmlILOptimization.EliminateOr, local0)) {
  470.                         return Replace(XmlILOptimization.EliminateOr, local0, local2);
  471.                     }
  472.                 }
  473.             }
  474.             if (this[XmlILOptimization.EliminateOr]) {
  475.                 if (local2.NodeType == QilNodeType.True) {
  476.                     if (AllowReplace(XmlILOptimization.EliminateOr, local0)) {
  477.                         return Replace(XmlILOptimization.EliminateOr, local0, local2);
  478.                     }
  479.                 }
  480.             }
  481.             if (this[XmlILOptimization.EliminateOr]) {
  482.                 if (local2.NodeType == QilNodeType.False) {
  483.                     if (AllowReplace(XmlILOptimization.EliminateOr, local0)) {
  484.                         return Replace(XmlILOptimization.EliminateOr, local0, local1);
  485.                     }
  486.                 }
  487.             }
  488.             return NoReplace(local0);
  489.         }
  490.        
  491.         protected override QilNode VisitNot(QilUnary local0)
  492.         {
  493.             QilNode local1 = local0[0];
  494.             if (this[XmlILOptimization.FoldNone]) {
  495.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  496.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  497.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  498.                     }
  499.                 }
  500.             }
  501.             if (this[XmlILOptimization.EliminateNot]) {
  502.                 if (local1.NodeType == QilNodeType.True) {
  503.                     if (AllowReplace(XmlILOptimization.EliminateNot, local0)) {
  504.                         return Replace(XmlILOptimization.EliminateNot, local0, VisitFalse(f.False()));
  505.                     }
  506.                 }
  507.             }
  508.             if (this[XmlILOptimization.EliminateNot]) {
  509.                 if (local1.NodeType == QilNodeType.False) {
  510.                     if (AllowReplace(XmlILOptimization.EliminateNot, local0)) {
  511.                         return Replace(XmlILOptimization.EliminateNot, local0, VisitTrue(f.True()));
  512.                     }
  513.                 }
  514.             }
  515.             return NoReplace(local0);
  516.         }
  517.        
  518.         #endregion // boolean operators
  519.        
  520.         #region choice
  521.         protected override QilNode VisitConditional(QilTernary local0)
  522.         {
  523.             QilNode local1 = local0[0];
  524.             QilNode local2 = local0[1];
  525.             QilNode local3 = local0[2];
  526.             if (this[XmlILOptimization.FoldNone]) {
  527.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  528.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  529.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  530.                     }
  531.                 }
  532.             }
  533.             if (this[XmlILOptimization.EliminateConditional]) {
  534.                 if (local1.NodeType == QilNodeType.True) {
  535.                     if (AllowReplace(XmlILOptimization.EliminateConditional, local0)) {
  536.                         return Replace(XmlILOptimization.EliminateConditional, local0, local2);
  537.                     }
  538.                 }
  539.             }
  540.             if (this[XmlILOptimization.EliminateConditional]) {
  541.                 if (local1.NodeType == QilNodeType.False) {
  542.                     if (AllowReplace(XmlILOptimization.EliminateConditional, local0)) {
  543.                         return Replace(XmlILOptimization.EliminateConditional, local0, local3);
  544.                     }
  545.                 }
  546.             }
  547.             if (this[XmlILOptimization.EliminateConditional]) {
  548.                 if (local2.NodeType == QilNodeType.True) {
  549.                     if (local3.NodeType == QilNodeType.False) {
  550.                         if (AllowReplace(XmlILOptimization.EliminateConditional, local0)) {
  551.                             return Replace(XmlILOptimization.EliminateConditional, local0, local1);
  552.                         }
  553.                     }
  554.                 }
  555.             }
  556.             if (this[XmlILOptimization.EliminateConditional]) {
  557.                 if (local2.NodeType == QilNodeType.False) {
  558.                     if (local3.NodeType == QilNodeType.True) {
  559.                         if (AllowReplace(XmlILOptimization.EliminateConditional, local0)) {
  560.                             return Replace(XmlILOptimization.EliminateConditional, local0, VisitNot(f.Not(local1)));
  561.                         }
  562.                     }
  563.                 }
  564.             }
  565.             if (this[XmlILOptimization.FoldConditionalNot]) {
  566.                 if (local1.NodeType == QilNodeType.Not) {
  567.                     QilNode local4 = local1[0];
  568.                     if (AllowReplace(XmlILOptimization.FoldConditionalNot, local0)) {
  569.                         return Replace(XmlILOptimization.FoldConditionalNot, local0, VisitConditional(f.Conditional(local4, local3, local2)));
  570.                     }
  571.                 }
  572.             }
  573.             if (this[XmlILOptimization.NormalizeConditionalText]) {
  574.                 if (local2.NodeType == QilNodeType.TextCtor) {
  575.                     QilNode local4 = local2[0];
  576.                     if (local3.NodeType == QilNodeType.TextCtor) {
  577.                         QilNode local5 = local3[0];
  578.                         if (AllowReplace(XmlILOptimization.NormalizeConditionalText, local0)) {
  579.                             return Replace(XmlILOptimization.NormalizeConditionalText, local0, VisitTextCtor(f.TextCtor(VisitConditional(f.Conditional(local1, local4, local5)))));
  580.                         }
  581.                     }
  582.                 }
  583.             }
  584.             return NoReplace(local0);
  585.         }
  586.        
  587.         protected override QilNode VisitChoice(QilChoice local0)
  588.         {
  589.             QilNode local1 = local0[0];
  590.             QilNode local2 = local0[1];
  591.             if (this[XmlILOptimization.AnnotateConstruction]) {
  592.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  593.                    
  594.                     this.contentAnalyzer.Analyze(local0, null);
  595.                 }
  596.             }
  597.             return NoReplace(local0);
  598.         }
  599.        
  600.         #endregion // choice
  601.        
  602.         #region collection operators
  603.         protected override QilNode VisitLength(QilUnary local0)
  604.         {
  605.             QilNode local1 = local0[0];
  606.             if (this[XmlILOptimization.FoldNone]) {
  607.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  608.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  609.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  610.                     }
  611.                 }
  612.             }
  613.             if (this[XmlILOptimization.EliminateLength]) {
  614.                 if (local1.NodeType == QilNodeType.Sequence) {
  615.                     if ((local1).Count == (0)) {
  616.                         if (AllowReplace(XmlILOptimization.EliminateLength, local0)) {
  617.                             return Replace(XmlILOptimization.EliminateLength, local0, VisitLiteralInt32(f.LiteralInt32(0)));
  618.                         }
  619.                     }
  620.                 }
  621.             }
  622.             if (this[XmlILOptimization.EliminateLength]) {
  623.                 if ((((local1).XmlType).IsSingleton) && (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects))) {
  624.                     if (AllowReplace(XmlILOptimization.EliminateLength, local0)) {
  625.                         return Replace(XmlILOptimization.EliminateLength, local0, VisitLiteralInt32(f.LiteralInt32(1)));
  626.                     }
  627.                 }
  628.             }
  629.             if (this[XmlILOptimization.IntroducePrecedingDod]) {
  630.                 if ((!(IsDocOrderDistinct(local1))) && ((IsStepPattern(local1, QilNodeType.XPathPreceding)) || (IsStepPattern(local1, QilNodeType.PrecedingSibling)))) {
  631.                     if (AllowReplace(XmlILOptimization.IntroducePrecedingDod, local0)) {
  632.                         return Replace(XmlILOptimization.IntroducePrecedingDod, local0, VisitLength(f.Length(VisitDocOrderDistinct(f.DocOrderDistinct(local1)))));
  633.                     }
  634.                 }
  635.             }
  636.             return NoReplace(local0);
  637.         }
  638.        
  639.         protected override QilNode VisitSequence(QilList local0)
  640.         {
  641.             if (((local0).Count == (1)) && (this[XmlILOptimization.EliminateSequence])) {
  642.                 if (AllowReplace(XmlILOptimization.EliminateSequence, local0)) {
  643.                     return Replace(XmlILOptimization.EliminateSequence, local0, (QilNode)(local0)[0]);
  644.                 }
  645.             }
  646.             if ((HasNestedSequence(local0)) && (this[XmlILOptimization.NormalizeNestedSequences])) {
  647.                 if (AllowReplace(XmlILOptimization.NormalizeNestedSequences, local0)) {
  648.                     QilNode local1 = VisitSequence(f.Sequence());
  649.                    
  650.                     foreach (QilNode nd in local0) {
  651.                         if (nd.NodeType == QilNodeType.Sequence)
  652.                             local1.Add((IList<QilNode>)nd);
  653.                         else
  654.                             local1.Add(nd);
  655.                     }
  656.                    
  657.                     // Match patterns on new sequence
  658.                     local1 = VisitSequence((QilList)local1);
  659.                     return Replace(XmlILOptimization.NormalizeNestedSequences, local0, local1);
  660.                 }
  661.             }
  662.             return NoReplace(local0);
  663.         }
  664.        
  665.         protected override QilNode VisitUnion(QilBinary local0)
  666.         {
  667.             QilNode local1 = local0[0];
  668.             QilNode local2 = local0[1];
  669.             if (this[XmlILOptimization.FoldNone]) {
  670.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  671.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  672.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  673.                     }
  674.                 }
  675.             }
  676.             if (this[XmlILOptimization.FoldNone]) {
  677.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  678.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  679.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  680.                     }
  681.                 }
  682.             }
  683.             if (this[XmlILOptimization.EliminateUnion]) {
  684.                 if (local2 == local1) {
  685.                     if (AllowReplace(XmlILOptimization.EliminateUnion, local0)) {
  686.                         return Replace(XmlILOptimization.EliminateUnion, local0, VisitDocOrderDistinct(f.DocOrderDistinct(local1)));
  687.                     }
  688.                 }
  689.             }
  690.             if (this[XmlILOptimization.EliminateUnion]) {
  691.                 if (local1.NodeType == QilNodeType.Sequence) {
  692.                     if ((local1).Count == (0)) {
  693.                         if (AllowReplace(XmlILOptimization.EliminateUnion, local0)) {
  694.                             return Replace(XmlILOptimization.EliminateUnion, local0, VisitDocOrderDistinct(f.DocOrderDistinct(local2)));
  695.                         }
  696.                     }
  697.                 }
  698.             }
  699.             if (this[XmlILOptimization.EliminateUnion]) {
  700.                 if (local2.NodeType == QilNodeType.Sequence) {
  701.                     if ((local2).Count == (0)) {
  702.                         if (AllowReplace(XmlILOptimization.EliminateUnion, local0)) {
  703.                             return Replace(XmlILOptimization.EliminateUnion, local0, VisitDocOrderDistinct(f.DocOrderDistinct(local1)));
  704.                         }
  705.                     }
  706.                 }
  707.             }
  708.             if (this[XmlILOptimization.EliminateUnion]) {
  709.                 if (local1.NodeType == QilNodeType.XmlContext) {
  710.                     if (local2.NodeType == QilNodeType.XmlContext) {
  711.                         if (AllowReplace(XmlILOptimization.EliminateUnion, local0)) {
  712.                             return Replace(XmlILOptimization.EliminateUnion, local0, local1);
  713.                         }
  714.                     }
  715.                 }
  716.             }
  717.             if (this[XmlILOptimization.NormalizeUnion]) {
  718.                 if ((!(IsDocOrderDistinct(local1))) || (!(IsDocOrderDistinct(local2)))) {
  719.                     if (AllowReplace(XmlILOptimization.NormalizeUnion, local0)) {
  720.                         return Replace(XmlILOptimization.NormalizeUnion, local0, VisitUnion(f.Union(VisitDocOrderDistinct(f.DocOrderDistinct(local1)), VisitDocOrderDistinct(f.DocOrderDistinct(local2)))));
  721.                     }
  722.                 }
  723.             }
  724.             if (this[XmlILOptimization.AnnotateUnion]) {
  725.                 if (AllowReplace(XmlILOptimization.AnnotateUnion, local0)) {
  726.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  727.                 }
  728.             }
  729.             if (this[XmlILOptimization.AnnotateUnionContent]) {
  730.                 if ((IsStepPattern(local1, QilNodeType.Content)) || (IsStepPattern(local1, QilNodeType.Union))) {
  731.                     if (((IsStepPattern(local2, QilNodeType.Content)) || (IsStepPattern(local2, QilNodeType.Union))) && ((OptimizerPatterns.Read((QilNode)(local1)).GetArgument(OptimizerPatternArgument.StepInput)) == (OptimizerPatterns.Read((QilNode)(local2)).GetArgument(OptimizerPatternArgument.StepInput)))) {
  732.                         if (AllowReplace(XmlILOptimization.AnnotateUnionContent, local0)) {
  733.                             AddStepPattern((QilNode)(local0), (QilNode)(OptimizerPatterns.Read((QilNode)(local1)).GetArgument(OptimizerPatternArgument.StepInput)));
  734.                             OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SameDepth);
  735.                         }
  736.                     }
  737.                 }
  738.             }
  739.             return NoReplace(local0);
  740.         }
  741.        
  742.         protected override QilNode VisitIntersection(QilBinary local0)
  743.         {
  744.             QilNode local1 = local0[0];
  745.             QilNode local2 = local0[1];
  746.             if (this[XmlILOptimization.FoldNone]) {
  747.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  748.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  749.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  750.                     }
  751.                 }
  752.             }
  753.             if (this[XmlILOptimization.FoldNone]) {
  754.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  755.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  756.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  757.                     }
  758.                 }
  759.             }
  760.             if (this[XmlILOptimization.EliminateIntersection]) {
  761.                 if (local2 == local1) {
  762.                     if (AllowReplace(XmlILOptimization.EliminateIntersection, local0)) {
  763.                         return Replace(XmlILOptimization.EliminateIntersection, local0, VisitDocOrderDistinct(f.DocOrderDistinct(local1)));
  764.                     }
  765.                 }
  766.             }
  767.             if (this[XmlILOptimization.EliminateIntersection]) {
  768.                 if (local1.NodeType == QilNodeType.Sequence) {
  769.                     if ((local1).Count == (0)) {
  770.                         if (AllowReplace(XmlILOptimization.EliminateIntersection, local0)) {
  771.                             return Replace(XmlILOptimization.EliminateIntersection, local0, local1);
  772.                         }
  773.                     }
  774.                 }
  775.             }
  776.             if (this[XmlILOptimization.EliminateIntersection]) {
  777.                 if (local2.NodeType == QilNodeType.Sequence) {
  778.                     if ((local2).Count == (0)) {
  779.                         if (AllowReplace(XmlILOptimization.EliminateIntersection, local0)) {
  780.                             return Replace(XmlILOptimization.EliminateIntersection, local0, local2);
  781.                         }
  782.                     }
  783.                 }
  784.             }
  785.             if (this[XmlILOptimization.EliminateIntersection]) {
  786.                 if (local1.NodeType == QilNodeType.XmlContext) {
  787.                     if (local2.NodeType == QilNodeType.XmlContext) {
  788.                         if (AllowReplace(XmlILOptimization.EliminateIntersection, local0)) {
  789.                             return Replace(XmlILOptimization.EliminateIntersection, local0, local1);
  790.                         }
  791.                     }
  792.                 }
  793.             }
  794.             if (this[XmlILOptimization.NormalizeIntersect]) {
  795.                 if ((!(IsDocOrderDistinct(local1))) || (!(IsDocOrderDistinct(local2)))) {
  796.                     if (AllowReplace(XmlILOptimization.NormalizeIntersect, local0)) {
  797.                         return Replace(XmlILOptimization.NormalizeIntersect, local0, VisitIntersection(f.Intersection(VisitDocOrderDistinct(f.DocOrderDistinct(local1)), VisitDocOrderDistinct(f.DocOrderDistinct(local2)))));
  798.                     }
  799.                 }
  800.             }
  801.             if (this[XmlILOptimization.AnnotateIntersect]) {
  802.                 if (AllowReplace(XmlILOptimization.AnnotateIntersect, local0)) {
  803.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  804.                 }
  805.             }
  806.             return NoReplace(local0);
  807.         }
  808.        
  809.         protected override QilNode VisitDifference(QilBinary local0)
  810.         {
  811.             QilNode local1 = local0[0];
  812.             QilNode local2 = local0[1];
  813.             if (this[XmlILOptimization.FoldNone]) {
  814.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  815.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  816.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  817.                     }
  818.                 }
  819.             }
  820.             if (this[XmlILOptimization.FoldNone]) {
  821.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  822.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  823.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  824.                     }
  825.                 }
  826.             }
  827.             if (this[XmlILOptimization.EliminateDifference]) {
  828.                 if (local1.NodeType == QilNodeType.Sequence) {
  829.                     if ((local1).Count == (0)) {
  830.                         if (AllowReplace(XmlILOptimization.EliminateDifference, local0)) {
  831.                             return Replace(XmlILOptimization.EliminateDifference, local0, local1);
  832.                         }
  833.                     }
  834.                 }
  835.             }
  836.             if (this[XmlILOptimization.EliminateDifference]) {
  837.                 if (local2.NodeType == QilNodeType.Sequence) {
  838.                     if ((local2).Count == (0)) {
  839.                         if (AllowReplace(XmlILOptimization.EliminateDifference, local0)) {
  840.                             return Replace(XmlILOptimization.EliminateDifference, local0, VisitDocOrderDistinct(f.DocOrderDistinct(local1)));
  841.                         }
  842.                     }
  843.                 }
  844.             }
  845.             if (this[XmlILOptimization.EliminateDifference]) {
  846.                 if (local2 == local1) {
  847.                     if (AllowReplace(XmlILOptimization.EliminateDifference, local0)) {
  848.                         return Replace(XmlILOptimization.EliminateDifference, local0, VisitSequence(f.Sequence()));
  849.                     }
  850.                 }
  851.             }
  852.             if (this[XmlILOptimization.EliminateDifference]) {
  853.                 if (local1.NodeType == QilNodeType.XmlContext) {
  854.                     if (local2.NodeType == QilNodeType.XmlContext) {
  855.                         if (AllowReplace(XmlILOptimization.EliminateDifference, local0)) {
  856.                             return Replace(XmlILOptimization.EliminateDifference, local0, VisitSequence(f.Sequence()));
  857.                         }
  858.                     }
  859.                 }
  860.             }
  861.             if (this[XmlILOptimization.NormalizeDifference]) {
  862.                 if ((!(IsDocOrderDistinct(local1))) || (!(IsDocOrderDistinct(local2)))) {
  863.                     if (AllowReplace(XmlILOptimization.NormalizeDifference, local0)) {
  864.                         return Replace(XmlILOptimization.NormalizeDifference, local0, VisitDifference(f.Difference(VisitDocOrderDistinct(f.DocOrderDistinct(local1)), VisitDocOrderDistinct(f.DocOrderDistinct(local2)))));
  865.                     }
  866.                 }
  867.             }
  868.             if (this[XmlILOptimization.AnnotateDifference]) {
  869.                 if (AllowReplace(XmlILOptimization.AnnotateDifference, local0)) {
  870.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  871.                 }
  872.             }
  873.             return NoReplace(local0);
  874.         }
  875.        
  876.         protected override QilNode VisitAverage(QilUnary local0)
  877.         {
  878.             QilNode local1 = local0[0];
  879.             if (this[XmlILOptimization.FoldNone]) {
  880.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  881.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  882.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  883.                     }
  884.                 }
  885.             }
  886.             if (this[XmlILOptimization.EliminateAverage]) {
  887.                 if (((local1).XmlType).Cardinality == XmlQueryCardinality.Zero) {
  888.                     if (AllowReplace(XmlILOptimization.EliminateAverage, local0)) {
  889.                         return Replace(XmlILOptimization.EliminateAverage, local0, VisitNop(f.Nop(local1)));
  890.                     }
  891.                 }
  892.             }
  893.             return NoReplace(local0);
  894.         }
  895.        
  896.         protected override QilNode VisitSum(QilUnary local0)
  897.         {
  898.             QilNode local1 = local0[0];
  899.             if (this[XmlILOptimization.FoldNone]) {
  900.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  901.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  902.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  903.                     }
  904.                 }
  905.             }
  906.             if (this[XmlILOptimization.EliminateSum]) {
  907.                 if (((local1).XmlType).Cardinality == XmlQueryCardinality.Zero) {
  908.                     if (AllowReplace(XmlILOptimization.EliminateSum, local0)) {
  909.                         return Replace(XmlILOptimization.EliminateSum, local0, VisitNop(f.Nop(local1)));
  910.                     }
  911.                 }
  912.             }
  913.             return NoReplace(local0);
  914.         }
  915.        
  916.         protected override QilNode VisitMinimum(QilUnary local0)
  917.         {
  918.             QilNode local1 = local0[0];
  919.             if (this[XmlILOptimization.FoldNone]) {
  920.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  921.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  922.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  923.                     }
  924.                 }
  925.             }
  926.             if (this[XmlILOptimization.EliminateMinimum]) {
  927.                 if (((local1).XmlType).Cardinality == XmlQueryCardinality.Zero) {
  928.                     if (AllowReplace(XmlILOptimization.EliminateMinimum, local0)) {
  929.                         return Replace(XmlILOptimization.EliminateMinimum, local0, VisitNop(f.Nop(local1)));
  930.                     }
  931.                 }
  932.             }
  933.             return NoReplace(local0);
  934.         }
  935.        
  936.         protected override QilNode VisitMaximum(QilUnary local0)
  937.         {
  938.             QilNode local1 = local0[0];
  939.             if (this[XmlILOptimization.FoldNone]) {
  940.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  941.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  942.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  943.                     }
  944.                 }
  945.             }
  946.             if (this[XmlILOptimization.EliminateMaximum]) {
  947.                 if (((local1).XmlType).Cardinality == XmlQueryCardinality.Zero) {
  948.                     if (AllowReplace(XmlILOptimization.EliminateMaximum, local0)) {
  949.                         return Replace(XmlILOptimization.EliminateMaximum, local0, VisitNop(f.Nop(local1)));
  950.                     }
  951.                 }
  952.             }
  953.             return NoReplace(local0);
  954.         }
  955.        
  956.         #endregion // collection operators
  957.        
  958.         #region arithmetic operators
  959.         protected override QilNode VisitNegate(QilUnary local0)
  960.         {
  961.             QilNode local1 = local0[0];
  962.             if (this[XmlILOptimization.FoldNone]) {
  963.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  964.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  965.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  966.                     }
  967.                 }
  968.             }
  969.             if (this[XmlILOptimization.EliminateNegate]) {
  970.                 if (local1.NodeType == QilNodeType.LiteralDecimal) {
  971.                     decimal local2 = (decimal)((QilLiteral)local1).Value;
  972.                     if (AllowReplace(XmlILOptimization.EliminateNegate, local0)) {
  973.                         return Replace(XmlILOptimization.EliminateNegate, local0, VisitLiteralDecimal(f.LiteralDecimal(-local2)));
  974.                     }
  975.                 }
  976.             }
  977.             if (this[XmlILOptimization.EliminateNegate]) {
  978.                 if (local1.NodeType == QilNodeType.LiteralDouble) {
  979.                     double local2 = (double)((QilLiteral)local1).Value;
  980.                     if (AllowReplace(XmlILOptimization.EliminateNegate, local0)) {
  981.                         return Replace(XmlILOptimization.EliminateNegate, local0, VisitLiteralDouble(f.LiteralDouble(-local2)));
  982.                     }
  983.                 }
  984.             }
  985.             if (this[XmlILOptimization.EliminateNegate]) {
  986.                 if (local1.NodeType == QilNodeType.LiteralInt32) {
  987.                     int local2 = (int)((QilLiteral)local1).Value;
  988.                     if (AllowReplace(XmlILOptimization.EliminateNegate, local0)) {
  989.                         return Replace(XmlILOptimization.EliminateNegate, local0, VisitLiteralInt32(f.LiteralInt32(-local2)));
  990.                     }
  991.                 }
  992.             }
  993.             if (this[XmlILOptimization.EliminateNegate]) {
  994.                 if (local1.NodeType == QilNodeType.LiteralInt64) {
  995.                     long local2 = (long)((QilLiteral)local1).Value;
  996.                     if (AllowReplace(XmlILOptimization.EliminateNegate, local0)) {
  997.                         return Replace(XmlILOptimization.EliminateNegate, local0, VisitLiteralInt64(f.LiteralInt64(-local2)));
  998.                     }
  999.                 }
  1000.             }
  1001.             return NoReplace(local0);
  1002.         }
  1003.        
  1004.         protected override QilNode VisitAdd(QilBinary local0)
  1005.         {
  1006.             QilNode local1 = local0[0];
  1007.             QilNode local2 = local0[1];
  1008.             if (this[XmlILOptimization.FoldNone]) {
  1009.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1010.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1011.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1012.                     }
  1013.                 }
  1014.             }
  1015.             if (this[XmlILOptimization.FoldNone]) {
  1016.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1017.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1018.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1019.                     }
  1020.                 }
  1021.             }
  1022.             if (this[XmlILOptimization.EliminateAdd]) {
  1023.                 if (IsLiteral((local1))) {
  1024.                     if ((IsLiteral((local2))) && (CanFoldArithmetic(QilNodeType.Add, (QilLiteral)local1, (QilLiteral)local2))) {
  1025.                         if (AllowReplace(XmlILOptimization.EliminateAdd, local0)) {
  1026.                             return Replace(XmlILOptimization.EliminateAdd, local0, FoldArithmetic(QilNodeType.Add, (QilLiteral)local1, (QilLiteral)local2));
  1027.                         }
  1028.                     }
  1029.                 }
  1030.             }
  1031.             if (this[XmlILOptimization.NormalizeAddLiteral]) {
  1032.                 if (IsLiteral((local1))) {
  1033.                     if (!(IsLiteral((local2)))) {
  1034.                         if (AllowReplace(XmlILOptimization.NormalizeAddLiteral, local0)) {
  1035.                             return Replace(XmlILOptimization.NormalizeAddLiteral, local0, VisitAdd(f.Add(local2, local1)));
  1036.                         }
  1037.                     }
  1038.                 }
  1039.             }
  1040.             return NoReplace(local0);
  1041.         }
  1042.        
  1043.         protected override QilNode VisitSubtract(QilBinary local0)
  1044.         {
  1045.             QilNode local1 = local0[0];
  1046.             QilNode local2 = local0[1];
  1047.             if (this[XmlILOptimization.FoldNone]) {
  1048.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1049.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1050.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1051.                     }
  1052.                 }
  1053.             }
  1054.             if (this[XmlILOptimization.FoldNone]) {
  1055.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1056.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1057.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1058.                     }
  1059.                 }
  1060.             }
  1061.             if (this[XmlILOptimization.EliminateSubtract]) {
  1062.                 if (IsLiteral((local1))) {
  1063.                     if ((IsLiteral((local2))) && (CanFoldArithmetic(QilNodeType.Subtract, (QilLiteral)local1, (QilLiteral)local2))) {
  1064.                         if (AllowReplace(XmlILOptimization.EliminateSubtract, local0)) {
  1065.                             return Replace(XmlILOptimization.EliminateSubtract, local0, FoldArithmetic(QilNodeType.Subtract, (QilLiteral)local1, (QilLiteral)local2));
  1066.                         }
  1067.                     }
  1068.                 }
  1069.             }
  1070.             return NoReplace(local0);
  1071.         }
  1072.        
  1073.         protected override QilNode VisitMultiply(QilBinary local0)
  1074.         {
  1075.             QilNode local1 = local0[0];
  1076.             QilNode local2 = local0[1];
  1077.             if (this[XmlILOptimization.FoldNone]) {
  1078.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1079.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1080.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1081.                     }
  1082.                 }
  1083.             }
  1084.             if (this[XmlILOptimization.FoldNone]) {
  1085.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1086.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1087.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1088.                     }
  1089.                 }
  1090.             }
  1091.             if (this[XmlILOptimization.EliminateMultiply]) {
  1092.                 if (IsLiteral((local1))) {
  1093.                     if ((IsLiteral((local2))) && (CanFoldArithmetic(QilNodeType.Multiply, (QilLiteral)local1, (QilLiteral)local2))) {
  1094.                         if (AllowReplace(XmlILOptimization.EliminateMultiply, local0)) {
  1095.                             return Replace(XmlILOptimization.EliminateMultiply, local0, FoldArithmetic(QilNodeType.Multiply, (QilLiteral)local1, (QilLiteral)local2));
  1096.                         }
  1097.                     }
  1098.                 }
  1099.             }
  1100.             if (this[XmlILOptimization.NormalizeMultiplyLiteral]) {
  1101.                 if (IsLiteral((local1))) {
  1102.                     if (!(IsLiteral((local2)))) {
  1103.                         if (AllowReplace(XmlILOptimization.NormalizeMultiplyLiteral, local0)) {
  1104.                             return Replace(XmlILOptimization.NormalizeMultiplyLiteral, local0, VisitMultiply(f.Multiply(local2, local1)));
  1105.                         }
  1106.                     }
  1107.                 }
  1108.             }
  1109.             return NoReplace(local0);
  1110.         }
  1111.        
  1112.         protected override QilNode VisitDivide(QilBinary local0)
  1113.         {
  1114.             QilNode local1 = local0[0];
  1115.             QilNode local2 = local0[1];
  1116.             if (this[XmlILOptimization.FoldNone]) {
  1117.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1118.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1119.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1120.                     }
  1121.                 }
  1122.             }
  1123.             if (this[XmlILOptimization.FoldNone]) {
  1124.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1125.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1126.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1127.                     }
  1128.                 }
  1129.             }
  1130.             if (this[XmlILOptimization.EliminateDivide]) {
  1131.                 if (IsLiteral((local1))) {
  1132.                     if ((IsLiteral((local2))) && (CanFoldArithmetic(QilNodeType.Divide, (QilLiteral)local1, (QilLiteral)local2))) {
  1133.                         if (AllowReplace(XmlILOptimization.EliminateDivide, local0)) {
  1134.                             return Replace(XmlILOptimization.EliminateDivide, local0, FoldArithmetic(QilNodeType.Divide, (QilLiteral)local1, (QilLiteral)local2));
  1135.                         }
  1136.                     }
  1137.                 }
  1138.             }
  1139.             return NoReplace(local0);
  1140.         }
  1141.        
  1142.         protected override QilNode VisitModulo(QilBinary local0)
  1143.         {
  1144.             QilNode local1 = local0[0];
  1145.             QilNode local2 = local0[1];
  1146.             if (this[XmlILOptimization.FoldNone]) {
  1147.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1148.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1149.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1150.                     }
  1151.                 }
  1152.             }
  1153.             if (this[XmlILOptimization.FoldNone]) {
  1154.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1155.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1156.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1157.                     }
  1158.                 }
  1159.             }
  1160.             if (this[XmlILOptimization.EliminateModulo]) {
  1161.                 if (IsLiteral((local1))) {
  1162.                     if ((IsLiteral((local2))) && (CanFoldArithmetic(QilNodeType.Modulo, (QilLiteral)local1, (QilLiteral)local2))) {
  1163.                         if (AllowReplace(XmlILOptimization.EliminateModulo, local0)) {
  1164.                             return Replace(XmlILOptimization.EliminateModulo, local0, FoldArithmetic(QilNodeType.Modulo, (QilLiteral)local1, (QilLiteral)local2));
  1165.                         }
  1166.                     }
  1167.                 }
  1168.             }
  1169.             return NoReplace(local0);
  1170.         }
  1171.        
  1172.         #endregion // arithmetic operators
  1173.        
  1174.         #region string operators
  1175.         protected override QilNode VisitStrLength(QilUnary local0)
  1176.         {
  1177.             QilNode local1 = local0[0];
  1178.             if (this[XmlILOptimization.FoldNone]) {
  1179.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1180.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1181.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1182.                     }
  1183.                 }
  1184.             }
  1185.             if (this[XmlILOptimization.EliminateStrLength]) {
  1186.                 if (local1.NodeType == QilNodeType.LiteralString) {
  1187.                     string local2 = (string)((QilLiteral)local1).Value;
  1188.                     if (AllowReplace(XmlILOptimization.EliminateStrLength, local0)) {
  1189.                         return Replace(XmlILOptimization.EliminateStrLength, local0, VisitLiteralInt32(f.LiteralInt32(local2.Length)));
  1190.                     }
  1191.                 }
  1192.             }
  1193.             return NoReplace(local0);
  1194.         }
  1195.        
  1196.         protected override QilNode VisitStrConcat(QilStrConcat local0)
  1197.         {
  1198.             QilNode local1 = local0[0];
  1199.             QilNode local2 = local0[1];
  1200.             if (this[XmlILOptimization.FoldNone]) {
  1201.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1202.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1203.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1204.                     }
  1205.                 }
  1206.             }
  1207.             if (this[XmlILOptimization.FoldNone]) {
  1208.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1209.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1210.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1211.                     }
  1212.                 }
  1213.             }
  1214.             if ((((local2).XmlType).IsSingleton) && (this[XmlILOptimization.EliminateStrConcatSingle])) {
  1215.                 if (AllowReplace(XmlILOptimization.EliminateStrConcatSingle, local0)) {
  1216.                     return Replace(XmlILOptimization.EliminateStrConcatSingle, local0, VisitNop(f.Nop(local2)));
  1217.                 }
  1218.             }
  1219.             if (this[XmlILOptimization.EliminateStrConcat]) {
  1220.                 if (local1.NodeType == QilNodeType.LiteralString) {
  1221.                     string local3 = (string)((QilLiteral)local1).Value;
  1222.                     if (local2.NodeType == QilNodeType.Sequence) {
  1223.                         if (AreLiteralArgs(local2)) {
  1224.                             if (AllowReplace(XmlILOptimization.EliminateStrConcat, local0)) {
  1225.                                
  1226.                                 // Concatenate all constant arguments
  1227.                                 StringConcat concat = new StringConcat();
  1228.                                 concat.Delimiter = local3;
  1229.                                
  1230.                                 foreach (QilLiteral lit in local2)
  1231.                                     concat.Concat((string)lit);
  1232.                                 return Replace(XmlILOptimization.EliminateStrConcat, local0, VisitLiteralString(f.LiteralString(concat.GetResult())));
  1233.                             }
  1234.                         }
  1235.                     }
  1236.                 }
  1237.             }
  1238.             return NoReplace(local0);
  1239.         }
  1240.        
  1241.         protected override QilNode VisitStrParseQName(QilBinary local0)
  1242.         {
  1243.             QilNode local1 = local0[0];
  1244.             QilNode local2 = local0[1];
  1245.             if (this[XmlILOptimization.FoldNone]) {
  1246.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1247.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1248.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1249.                     }
  1250.                 }
  1251.             }
  1252.             if (this[XmlILOptimization.FoldNone]) {
  1253.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1254.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1255.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1256.                     }
  1257.                 }
  1258.             }
  1259.             return NoReplace(local0);
  1260.         }
  1261.        
  1262.         #endregion // string operators
  1263.        
  1264.         #region value comparison operators
  1265.         protected override QilNode VisitNe(QilBinary local0)
  1266.         {
  1267.             QilNode local1 = local0[0];
  1268.             QilNode local2 = local0[1];
  1269.             if (this[XmlILOptimization.FoldNone]) {
  1270.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1271.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1272.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1273.                     }
  1274.                 }
  1275.             }
  1276.             if (this[XmlILOptimization.FoldNone]) {
  1277.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1278.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1279.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1280.                     }
  1281.                 }
  1282.             }
  1283.             if (this[XmlILOptimization.EliminateNe]) {
  1284.                 if (IsLiteral((local1))) {
  1285.                     if (IsLiteral((local2))) {
  1286.                         if (AllowReplace(XmlILOptimization.EliminateNe, local0)) {
  1287.                             return Replace(XmlILOptimization.EliminateNe, local0, FoldComparison(QilNodeType.Ne, local1, local2));
  1288.                         }
  1289.                     }
  1290.                 }
  1291.             }
  1292.             if (this[XmlILOptimization.NormalizeNeLiteral]) {
  1293.                 if (IsLiteral((local1))) {
  1294.                     if (!(IsLiteral((local2)))) {
  1295.                         if (AllowReplace(XmlILOptimization.NormalizeNeLiteral, local0)) {
  1296.                             return Replace(XmlILOptimization.NormalizeNeLiteral, local0, VisitNe(f.Ne(local2, local1)));
  1297.                         }
  1298.                     }
  1299.                 }
  1300.             }
  1301.             if (this[XmlILOptimization.NormalizeXsltConvertNe]) {
  1302.                 if (local1.NodeType == QilNodeType.XsltConvert) {
  1303.                     QilNode local3 = local1[0];
  1304.                     QilNode local4 = local1[1];
  1305.                     if (local4.NodeType == QilNodeType.LiteralType) {
  1306.                         XmlQueryType local5 = (XmlQueryType)((QilLiteral)local4).Value;
  1307.                         if ((IsPrimitiveNumeric((local3).XmlType)) && (IsPrimitiveNumeric(local5))) {
  1308.                             if ((IsLiteral((local2))) && (CanFoldXsltConvertNonLossy(local2, (local3).XmlType))) {
  1309.                                 if (AllowReplace(XmlILOptimization.NormalizeXsltConvertNe, local0)) {
  1310.                                     return Replace(XmlILOptimization.NormalizeXsltConvertNe, local0, VisitNe(f.Ne(local3, FoldXsltConvert(local2, (local3).XmlType))));
  1311.                                 }
  1312.                             }
  1313.                         }
  1314.                     }
  1315.                 }
  1316.             }
  1317.             if (this[XmlILOptimization.NormalizeIdNe]) {
  1318.                 if (local1.NodeType == QilNodeType.XsltGenerateId) {
  1319.                     QilNode local3 = local1[0];
  1320.                     if (((local3).XmlType).IsSingleton) {
  1321.                         if (local2.NodeType == QilNodeType.XsltGenerateId) {
  1322.                             QilNode local4 = local2[0];
  1323.                             if (((local4).XmlType).IsSingleton) {
  1324.                                 if (AllowReplace(XmlILOptimization.NormalizeIdNe, local0)) {
  1325.                                     return Replace(XmlILOptimization.NormalizeIdNe, local0, VisitNot(f.Not(VisitIs(f.Is(local3, local4)))));
  1326.                                 }
  1327.                             }
  1328.                         }
  1329.                     }
  1330.                 }
  1331.             }
  1332.             if (this[XmlILOptimization.NormalizeLengthNe]) {
  1333.                 if (local1.NodeType == QilNodeType.Length) {
  1334.                     QilNode local3 = local1[0];
  1335.                     if (local2.NodeType == QilNodeType.LiteralInt32) {
  1336.                         int local4 = (int)((QilLiteral)local2).Value;
  1337.                         if (local4 == 0) {
  1338.                             if (AllowReplace(XmlILOptimization.NormalizeLengthNe, local0)) {
  1339.                                 return Replace(XmlILOptimization.NormalizeLengthNe, local0, VisitNot(f.Not(VisitIsEmpty(f.IsEmpty(local3)))));
  1340.                             }
  1341.                         }
  1342.                     }
  1343.                 }
  1344.             }
  1345.             if (this[XmlILOptimization.AnnotateMaxLengthNe]) {
  1346.                 if (local1.NodeType == QilNodeType.Length) {
  1347.                     if (local2.NodeType == QilNodeType.LiteralInt32) {
  1348.                         int local4 = (int)((QilLiteral)local2).Value;
  1349.                         if (AllowReplace(XmlILOptimization.AnnotateMaxLengthNe, local0)) {
  1350.                             OptimizerPatterns.Write((QilNode)(local1)).AddPattern(OptimizerPatternName.MaxPosition);
  1351.                             OptimizerPatterns.Write((QilNode)(local1)).AddArgument(OptimizerPatternArgument.MaxPosition, local4);
  1352.                         }
  1353.                     }
  1354.                 }
  1355.             }
  1356.             return NoReplace(local0);
  1357.         }
  1358.        
  1359.         protected override QilNode VisitEq(QilBinary local0)
  1360.         {
  1361.             QilNode local1 = local0[0];
  1362.             QilNode local2 = local0[1];
  1363.             if (this[XmlILOptimization.FoldNone]) {
  1364.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1365.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1366.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1367.                     }
  1368.                 }
  1369.             }
  1370.             if (this[XmlILOptimization.FoldNone]) {
  1371.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1372.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1373.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1374.                     }
  1375.                 }
  1376.             }
  1377.             if (this[XmlILOptimization.EliminateEq]) {
  1378.                 if (IsLiteral((local1))) {
  1379.                     if (IsLiteral((local2))) {
  1380.                         if (AllowReplace(XmlILOptimization.EliminateEq, local0)) {
  1381.                             return Replace(XmlILOptimization.EliminateEq, local0, FoldComparison(QilNodeType.Eq, local1, local2));
  1382.                         }
  1383.                     }
  1384.                 }
  1385.             }
  1386.             if (this[XmlILOptimization.NormalizeEqLiteral]) {
  1387.                 if (IsLiteral((local1))) {
  1388.                     if (!(IsLiteral((local2)))) {
  1389.                         if (AllowReplace(XmlILOptimization.NormalizeEqLiteral, local0)) {
  1390.                             return Replace(XmlILOptimization.NormalizeEqLiteral, local0, VisitEq(f.Eq(local2, local1)));
  1391.                         }
  1392.                     }
  1393.                 }
  1394.             }
  1395.             if (this[XmlILOptimization.NormalizeXsltConvertEq]) {
  1396.                 if (local1.NodeType == QilNodeType.XsltConvert) {
  1397.                     QilNode local3 = local1[0];
  1398.                     QilNode local4 = local1[1];
  1399.                     if (local4.NodeType == QilNodeType.LiteralType) {
  1400.                         XmlQueryType local5 = (XmlQueryType)((QilLiteral)local4).Value;
  1401.                         if ((IsPrimitiveNumeric((local3).XmlType)) && (IsPrimitiveNumeric(local5))) {
  1402.                             if ((IsLiteral((local2))) && (CanFoldXsltConvertNonLossy(local2, (local3).XmlType))) {
  1403.                                 if (AllowReplace(XmlILOptimization.NormalizeXsltConvertEq, local0)) {
  1404.                                     return Replace(XmlILOptimization.NormalizeXsltConvertEq, local0, VisitEq(f.Eq(local3, FoldXsltConvert(local2, (local3).XmlType))));
  1405.                                 }
  1406.                             }
  1407.                         }
  1408.                     }
  1409.                 }
  1410.             }
  1411.             if (this[XmlILOptimization.NormalizeAddEq]) {
  1412.                 if (local1.NodeType == QilNodeType.Add) {
  1413.                     QilNode local3 = local1[0];
  1414.                     QilNode local4 = local1[1];
  1415.                     if (IsLiteral((local4))) {
  1416.                         if ((IsLiteral((local2))) && (CanFoldArithmetic(QilNodeType.Subtract, (QilLiteral)local2, (QilLiteral)local4))) {
  1417.                             if (AllowReplace(XmlILOptimization.NormalizeAddEq, local0)) {
  1418.                                 return Replace(XmlILOptimization.NormalizeAddEq, local0, VisitEq(f.Eq(local3, FoldArithmetic(QilNodeType.Subtract, (QilLiteral)local2, (QilLiteral)local4))));
  1419.                             }
  1420.                         }
  1421.                     }
  1422.                 }
  1423.             }
  1424.             if (this[XmlILOptimization.NormalizeIdEq]) {
  1425.                 if (local1.NodeType == QilNodeType.XsltGenerateId) {
  1426.                     QilNode local3 = local1[0];
  1427.                     if (((local3).XmlType).IsSingleton) {
  1428.                         if (local2.NodeType == QilNodeType.XsltGenerateId) {
  1429.                             QilNode local4 = local2[0];
  1430.                             if (((local4).XmlType).IsSingleton) {
  1431.                                 if (AllowReplace(XmlILOptimization.NormalizeIdEq, local0)) {
  1432.                                     return Replace(XmlILOptimization.NormalizeIdEq, local0, VisitIs(f.Is(local3, local4)));
  1433.                                 }
  1434.                             }
  1435.                         }
  1436.                     }
  1437.                 }
  1438.             }
  1439.             if (this[XmlILOptimization.NormalizeIdEq]) {
  1440.                 if (local1.NodeType == QilNodeType.XsltGenerateId) {
  1441.                     QilNode local3 = local1[0];
  1442.                     if (((local3).XmlType).IsSingleton) {
  1443.                         if (local2.NodeType == QilNodeType.StrConcat) {
  1444.                             QilNode local5 = local2[1];
  1445.                             if (local5.NodeType == QilNodeType.Loop) {
  1446.                                 QilNode local6 = local5[0];
  1447.                                 QilNode local8 = local5[1];
  1448.                                 if (local6.NodeType == QilNodeType.For) {
  1449.                                     QilNode local7 = local6[0];
  1450.                                     if (!((local7).XmlType).MaybeMany) {
  1451.                                         if (local8.NodeType == QilNodeType.XsltGenerateId) {
  1452.                                             QilNode local9 = local8[0];
  1453.                                             if (local9 == local6) {
  1454.                                                 if (AllowReplace(XmlILOptimization.NormalizeIdEq, local0)) {
  1455.                                                     QilNode local10 = VisitFor(f.For(local7));
  1456.                                                     return Replace(XmlILOptimization.NormalizeIdEq, local0, VisitNot(f.Not(VisitIsEmpty(f.IsEmpty(VisitFilter(f.Filter(local10, VisitIs(f.Is(local3, local10)))))))));
  1457.                                                 }
  1458.                                             }
  1459.                                         }
  1460.                                     }
  1461.                                 }
  1462.                             }
  1463.                         }
  1464.                     }
  1465.                 }
  1466.             }
  1467.             if (this[XmlILOptimization.NormalizeIdEq]) {
  1468.                 if (local1.NodeType == QilNodeType.StrConcat) {
  1469.                     QilNode local4 = local1[1];
  1470.                     if (local4.NodeType == QilNodeType.Loop) {
  1471.                         QilNode local5 = local4[0];
  1472.                         QilNode local7 = local4[1];
  1473.                         if (local5.NodeType == QilNodeType.For) {
  1474.                             QilNode local6 = local5[0];
  1475.                             if (!((local6).XmlType).MaybeMany) {
  1476.                                 if (local7.NodeType == QilNodeType.XsltGenerateId) {
  1477.                                     QilNode local8 = local7[0];
  1478.                                     if (local8 == local5) {
  1479.                                         if (local2.NodeType == QilNodeType.XsltGenerateId) {
  1480.                                             QilNode local9 = local2[0];
  1481.                                             if (((local9).XmlType).IsSingleton) {
  1482.                                                 if (AllowReplace(XmlILOptimization.NormalizeIdEq, local0)) {
  1483.                                                     QilNode local10 = VisitFor(f.For(local6));
  1484.                                                     return Replace(XmlILOptimization.NormalizeIdEq, local0, VisitNot(f.Not(VisitIsEmpty(f.IsEmpty(VisitFilter(f.Filter(local10, VisitIs(f.Is(local9, local10)))))))));
  1485.                                                 }
  1486.                                             }
  1487.                                         }
  1488.                                     }
  1489.                                 }
  1490.                             }
  1491.                         }
  1492.                     }
  1493.                 }
  1494.             }
  1495.             if (this[XmlILOptimization.NormalizeMuenchian]) {
  1496.                 if (local1.NodeType == QilNodeType.Length) {
  1497.                     QilNode local3 = local1[0];
  1498.                     if (local3.NodeType == QilNodeType.Union) {
  1499.                         QilNode local4 = local3[0];
  1500.                         QilNode local5 = local3[1];
  1501.                         if ((((local4).XmlType).IsSingleton) && (!((local5).XmlType).MaybeMany)) {
  1502.                             if (local2.NodeType == QilNodeType.LiteralInt32) {
  1503.                                 int local6 = (int)((QilLiteral)local2).Value;
  1504.                                 if (local6 == 1) {
  1505.                                     if (AllowReplace(XmlILOptimization.NormalizeMuenchian, local0)) {
  1506.                                         QilNode local7 = VisitFor(f.For(local5));
  1507.                                         return Replace(XmlILOptimization.NormalizeMuenchian, local0, VisitIsEmpty(f.IsEmpty(VisitFilter(f.Filter(local7, VisitNot(f.Not(VisitIs(f.Is(local4, local7)))))))));
  1508.                                     }
  1509.                                 }
  1510.                             }
  1511.                         }
  1512.                     }
  1513.                 }
  1514.             }
  1515.             if (this[XmlILOptimization.NormalizeMuenchian]) {
  1516.                 if (local1.NodeType == QilNodeType.Length) {
  1517.                     QilNode local3 = local1[0];
  1518.                     if (local3.NodeType == QilNodeType.Union) {
  1519.                         QilNode local4 = local3[0];
  1520.                         QilNode local5 = local3[1];
  1521.                         if ((!((local4).XmlType).MaybeMany) && (((local5).XmlType).IsSingleton)) {
  1522.                             if (local2.NodeType == QilNodeType.LiteralInt32) {
  1523.                                 int local6 = (int)((QilLiteral)local2).Value;
  1524.                                 if (local6 == 1) {
  1525.                                     if (AllowReplace(XmlILOptimization.NormalizeMuenchian, local0)) {
  1526.                                         QilNode local7 = VisitFor(f.For(local4));
  1527.                                         return Replace(XmlILOptimization.NormalizeMuenchian, local0, VisitIsEmpty(f.IsEmpty(VisitFilter(f.Filter(local7, VisitNot(f.Not(VisitIs(f.Is(local7, local5)))))))));
  1528.                                     }
  1529.                                 }
  1530.                             }
  1531.                         }
  1532.                     }
  1533.                 }
  1534.             }
  1535.             if (this[XmlILOptimization.AnnotateMaxLengthEq]) {
  1536.                 if (local1.NodeType == QilNodeType.Length) {
  1537.                     if (local2.NodeType == QilNodeType.LiteralInt32) {
  1538.                         int local4 = (int)((QilLiteral)local2).Value;
  1539.                         if (AllowReplace(XmlILOptimization.AnnotateMaxLengthEq, local0)) {
  1540.                             OptimizerPatterns.Write((QilNode)(local1)).AddPattern(OptimizerPatternName.MaxPosition);
  1541.                             OptimizerPatterns.Write((QilNode)(local1)).AddArgument(OptimizerPatternArgument.MaxPosition, local4);
  1542.                         }
  1543.                     }
  1544.                 }
  1545.             }
  1546.             return NoReplace(local0);
  1547.         }
  1548.        
  1549.         protected override QilNode VisitGt(QilBinary local0)
  1550.         {
  1551.             QilNode local1 = local0[0];
  1552.             QilNode local2 = local0[1];
  1553.             if (this[XmlILOptimization.FoldNone]) {
  1554.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1555.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1556.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1557.                     }
  1558.                 }
  1559.             }
  1560.             if (this[XmlILOptimization.FoldNone]) {
  1561.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1562.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1563.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1564.                     }
  1565.                 }
  1566.             }
  1567.             if (this[XmlILOptimization.EliminateGt]) {
  1568.                 if (IsLiteral((local1))) {
  1569.                     if (IsLiteral((local2))) {
  1570.                         if (AllowReplace(XmlILOptimization.EliminateGt, local0)) {
  1571.                             return Replace(XmlILOptimization.EliminateGt, local0, FoldComparison(QilNodeType.Gt, local1, local2));
  1572.                         }
  1573.                     }
  1574.                 }
  1575.             }
  1576.             if (this[XmlILOptimization.NormalizeGtLiteral]) {
  1577.                 if (IsLiteral((local1))) {
  1578.                     if (!(IsLiteral((local2)))) {
  1579.                         if (AllowReplace(XmlILOptimization.NormalizeGtLiteral, local0)) {
  1580.                             return Replace(XmlILOptimization.NormalizeGtLiteral, local0, VisitLt(f.Lt(local2, local1)));
  1581.                         }
  1582.                     }
  1583.                 }
  1584.             }
  1585.             if (this[XmlILOptimization.NormalizeXsltConvertGt]) {
  1586.                 if (local1.NodeType == QilNodeType.XsltConvert) {
  1587.                     QilNode local3 = local1[0];
  1588.                     QilNode local4 = local1[1];
  1589.                     if (local4.NodeType == QilNodeType.LiteralType) {
  1590.                         XmlQueryType local5 = (XmlQueryType)((QilLiteral)local4).Value;
  1591.                         if ((IsPrimitiveNumeric((local3).XmlType)) && (IsPrimitiveNumeric(local5))) {
  1592.                             if ((IsLiteral((local2))) && (CanFoldXsltConvertNonLossy(local2, (local3).XmlType))) {
  1593.                                 if (AllowReplace(XmlILOptimization.NormalizeXsltConvertGt, local0)) {
  1594.                                     return Replace(XmlILOptimization.NormalizeXsltConvertGt, local0, VisitGt(f.Gt(local3, FoldXsltConvert(local2, (local3).XmlType))));
  1595.                                 }
  1596.                             }
  1597.                         }
  1598.                     }
  1599.                 }
  1600.             }
  1601.             if (this[XmlILOptimization.NormalizeLengthGt]) {
  1602.                 if (local1.NodeType == QilNodeType.Length) {
  1603.                     QilNode local3 = local1[0];
  1604.                     if (local2.NodeType == QilNodeType.LiteralInt32) {
  1605.                         int local4 = (int)((QilLiteral)local2).Value;
  1606.                         if (local4 == 0) {
  1607.                             if (AllowReplace(XmlILOptimization.NormalizeLengthGt, local0)) {
  1608.                                 return Replace(XmlILOptimization.NormalizeLengthGt, local0, VisitNot(f.Not(VisitIsEmpty(f.IsEmpty(local3)))));
  1609.                             }
  1610.                         }
  1611.                     }
  1612.                 }
  1613.             }
  1614.             if (this[XmlILOptimization.AnnotateMaxLengthGt]) {
  1615.                 if (local1.NodeType == QilNodeType.Length) {
  1616.                     if (local2.NodeType == QilNodeType.LiteralInt32) {
  1617.                         int local4 = (int)((QilLiteral)local2).Value;
  1618.                         if (AllowReplace(XmlILOptimization.AnnotateMaxLengthGt, local0)) {
  1619.                             OptimizerPatterns.Write((QilNode)(local1)).AddPattern(OptimizerPatternName.MaxPosition);
  1620.                             OptimizerPatterns.Write((QilNode)(local1)).AddArgument(OptimizerPatternArgument.MaxPosition, local4);
  1621.                         }
  1622.                     }
  1623.                 }
  1624.             }
  1625.             return NoReplace(local0);
  1626.         }
  1627.        
  1628.         protected override QilNode VisitGe(QilBinary local0)
  1629.         {
  1630.             QilNode local1 = local0[0];
  1631.             QilNode local2 = local0[1];
  1632.             if (this[XmlILOptimization.FoldNone]) {
  1633.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1634.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1635.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1636.                     }
  1637.                 }
  1638.             }
  1639.             if (this[XmlILOptimization.FoldNone]) {
  1640.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1641.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1642.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1643.                     }
  1644.                 }
  1645.             }
  1646.             if (this[XmlILOptimization.EliminateGe]) {
  1647.                 if (IsLiteral((local1))) {
  1648.                     if (IsLiteral((local2))) {
  1649.                         if (AllowReplace(XmlILOptimization.EliminateGe, local0)) {
  1650.                             return Replace(XmlILOptimization.EliminateGe, local0, FoldComparison(QilNodeType.Ge, local1, local2));
  1651.                         }
  1652.                     }
  1653.                 }
  1654.             }
  1655.             if (this[XmlILOptimization.NormalizeGeLiteral]) {
  1656.                 if (IsLiteral((local1))) {
  1657.                     if (!(IsLiteral((local2)))) {
  1658.                         if (AllowReplace(XmlILOptimization.NormalizeGeLiteral, local0)) {
  1659.                             return Replace(XmlILOptimization.NormalizeGeLiteral, local0, VisitLe(f.Le(local2, local1)));
  1660.                         }
  1661.                     }
  1662.                 }
  1663.             }
  1664.             if (this[XmlILOptimization.NormalizeXsltConvertGe]) {
  1665.                 if (local1.NodeType == QilNodeType.XsltConvert) {
  1666.                     QilNode local3 = local1[0];
  1667.                     QilNode local4 = local1[1];
  1668.                     if (local4.NodeType == QilNodeType.LiteralType) {
  1669.                         XmlQueryType local5 = (XmlQueryType)((QilLiteral)local4).Value;
  1670.                         if ((IsPrimitiveNumeric((local3).XmlType)) && (IsPrimitiveNumeric(local5))) {
  1671.                             if ((IsLiteral((local2))) && (CanFoldXsltConvertNonLossy(local2, (local3).XmlType))) {
  1672.                                 if (AllowReplace(XmlILOptimization.NormalizeXsltConvertGe, local0)) {
  1673.                                     return Replace(XmlILOptimization.NormalizeXsltConvertGe, local0, VisitGe(f.Ge(local3, FoldXsltConvert(local2, (local3).XmlType))));
  1674.                                 }
  1675.                             }
  1676.                         }
  1677.                     }
  1678.                 }
  1679.             }
  1680.             if (this[XmlILOptimization.AnnotateMaxLengthGe]) {
  1681.                 if (local1.NodeType == QilNodeType.Length) {
  1682.                     if (local2.NodeType == QilNodeType.LiteralInt32) {
  1683.                         int local4 = (int)((QilLiteral)local2).Value;
  1684.                         if (AllowReplace(XmlILOptimization.AnnotateMaxLengthGe, local0)) {
  1685.                             OptimizerPatterns.Write((QilNode)(local1)).AddPattern(OptimizerPatternName.MaxPosition);
  1686.                             OptimizerPatterns.Write((QilNode)(local1)).AddArgument(OptimizerPatternArgument.MaxPosition, local4);
  1687.                         }
  1688.                     }
  1689.                 }
  1690.             }
  1691.             return NoReplace(local0);
  1692.         }
  1693.        
  1694.         protected override QilNode VisitLt(QilBinary local0)
  1695.         {
  1696.             QilNode local1 = local0[0];
  1697.             QilNode local2 = local0[1];
  1698.             if (this[XmlILOptimization.FoldNone]) {
  1699.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1700.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1701.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1702.                     }
  1703.                 }
  1704.             }
  1705.             if (this[XmlILOptimization.FoldNone]) {
  1706.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1707.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1708.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1709.                     }
  1710.                 }
  1711.             }
  1712.             if (this[XmlILOptimization.EliminateLt]) {
  1713.                 if (IsLiteral((local1))) {
  1714.                     if (IsLiteral((local2))) {
  1715.                         if (AllowReplace(XmlILOptimization.EliminateLt, local0)) {
  1716.                             return Replace(XmlILOptimization.EliminateLt, local0, FoldComparison(QilNodeType.Lt, local1, local2));
  1717.                         }
  1718.                     }
  1719.                 }
  1720.             }
  1721.             if (this[XmlILOptimization.NormalizeLtLiteral]) {
  1722.                 if (IsLiteral((local1))) {
  1723.                     if (!(IsLiteral((local2)))) {
  1724.                         if (AllowReplace(XmlILOptimization.NormalizeLtLiteral, local0)) {
  1725.                             return Replace(XmlILOptimization.NormalizeLtLiteral, local0, VisitGt(f.Gt(local2, local1)));
  1726.                         }
  1727.                     }
  1728.                 }
  1729.             }
  1730.             if (this[XmlILOptimization.NormalizeXsltConvertLt]) {
  1731.                 if (local1.NodeType == QilNodeType.XsltConvert) {
  1732.                     QilNode local3 = local1[0];
  1733.                     QilNode local4 = local1[1];
  1734.                     if (local4.NodeType == QilNodeType.LiteralType) {
  1735.                         XmlQueryType local5 = (XmlQueryType)((QilLiteral)local4).Value;
  1736.                         if ((IsPrimitiveNumeric((local3).XmlType)) && (IsPrimitiveNumeric(local5))) {
  1737.                             if ((IsLiteral((local2))) && (CanFoldXsltConvertNonLossy(local2, (local3).XmlType))) {
  1738.                                 if (AllowReplace(XmlILOptimization.NormalizeXsltConvertLt, local0)) {
  1739.                                     return Replace(XmlILOptimization.NormalizeXsltConvertLt, local0, VisitLt(f.Lt(local3, FoldXsltConvert(local2, (local3).XmlType))));
  1740.                                 }
  1741.                             }
  1742.                         }
  1743.                     }
  1744.                 }
  1745.             }
  1746.             if (this[XmlILOptimization.AnnotateMaxLengthLt]) {
  1747.                 if (local1.NodeType == QilNodeType.Length) {
  1748.                     if (local2.NodeType == QilNodeType.LiteralInt32) {
  1749.                         int local4 = (int)((QilLiteral)local2).Value;
  1750.                         if (AllowReplace(XmlILOptimization.AnnotateMaxLengthLt, local0)) {
  1751.                             OptimizerPatterns.Write((QilNode)(local1)).AddPattern(OptimizerPatternName.MaxPosition);
  1752.                             OptimizerPatterns.Write((QilNode)(local1)).AddArgument(OptimizerPatternArgument.MaxPosition, local4);
  1753.                         }
  1754.                     }
  1755.                 }
  1756.             }
  1757.             return NoReplace(local0);
  1758.         }
  1759.        
  1760.         protected override QilNode VisitLe(QilBinary local0)
  1761.         {
  1762.             QilNode local1 = local0[0];
  1763.             QilNode local2 = local0[1];
  1764.             if (this[XmlILOptimization.FoldNone]) {
  1765.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1766.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1767.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1768.                     }
  1769.                 }
  1770.             }
  1771.             if (this[XmlILOptimization.FoldNone]) {
  1772.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1773.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1774.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1775.                     }
  1776.                 }
  1777.             }
  1778.             if (this[XmlILOptimization.EliminateLe]) {
  1779.                 if (IsLiteral((local1))) {
  1780.                     if (IsLiteral((local2))) {
  1781.                         if (AllowReplace(XmlILOptimization.EliminateLe, local0)) {
  1782.                             return Replace(XmlILOptimization.EliminateLe, local0, FoldComparison(QilNodeType.Le, local1, local2));
  1783.                         }
  1784.                     }
  1785.                 }
  1786.             }
  1787.             if (this[XmlILOptimization.NormalizeLeLiteral]) {
  1788.                 if (IsLiteral((local1))) {
  1789.                     if (!(IsLiteral((local2)))) {
  1790.                         if (AllowReplace(XmlILOptimization.NormalizeLeLiteral, local0)) {
  1791.                             return Replace(XmlILOptimization.NormalizeLeLiteral, local0, VisitGe(f.Ge(local2, local1)));
  1792.                         }
  1793.                     }
  1794.                 }
  1795.             }
  1796.             if (this[XmlILOptimization.NormalizeXsltConvertLe]) {
  1797.                 if (local1.NodeType == QilNodeType.XsltConvert) {
  1798.                     QilNode local3 = local1[0];
  1799.                     QilNode local4 = local1[1];
  1800.                     if (local4.NodeType == QilNodeType.LiteralType) {
  1801.                         XmlQueryType local5 = (XmlQueryType)((QilLiteral)local4).Value;
  1802.                         if ((IsPrimitiveNumeric((local3).XmlType)) && (IsPrimitiveNumeric(local5))) {
  1803.                             if ((IsLiteral((local2))) && (CanFoldXsltConvertNonLossy(local2, (local3).XmlType))) {
  1804.                                 if (AllowReplace(XmlILOptimization.NormalizeXsltConvertLe, local0)) {
  1805.                                     return Replace(XmlILOptimization.NormalizeXsltConvertLe, local0, VisitLe(f.Le(local3, FoldXsltConvert(local2, (local3).XmlType))));
  1806.                                 }
  1807.                             }
  1808.                         }
  1809.                     }
  1810.                 }
  1811.             }
  1812.             if (this[XmlILOptimization.AnnotateMaxLengthLe]) {
  1813.                 if (local1.NodeType == QilNodeType.Length) {
  1814.                     if (local2.NodeType == QilNodeType.LiteralInt32) {
  1815.                         int local4 = (int)((QilLiteral)local2).Value;
  1816.                         if (AllowReplace(XmlILOptimization.AnnotateMaxLengthLe, local0)) {
  1817.                             OptimizerPatterns.Write((QilNode)(local1)).AddPattern(OptimizerPatternName.MaxPosition);
  1818.                             OptimizerPatterns.Write((QilNode)(local1)).AddArgument(OptimizerPatternArgument.MaxPosition, local4);
  1819.                         }
  1820.                     }
  1821.                 }
  1822.             }
  1823.             return NoReplace(local0);
  1824.         }
  1825.        
  1826.         #endregion // value comparison operators
  1827.        
  1828.         #region node comparison operators
  1829.         protected override QilNode VisitIs(QilBinary local0)
  1830.         {
  1831.             QilNode local1 = local0[0];
  1832.             QilNode local2 = local0[1];
  1833.             if (this[XmlILOptimization.FoldNone]) {
  1834.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1835.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1836.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1837.                     }
  1838.                 }
  1839.             }
  1840.             if (this[XmlILOptimization.FoldNone]) {
  1841.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1842.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1843.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1844.                     }
  1845.                 }
  1846.             }
  1847.             if (this[XmlILOptimization.EliminateIs]) {
  1848.                 if (local2 == local1) {
  1849.                     if (AllowReplace(XmlILOptimization.EliminateIs, local0)) {
  1850.                         return Replace(XmlILOptimization.EliminateIs, local0, VisitTrue(f.True()));
  1851.                     }
  1852.                 }
  1853.             }
  1854.             return NoReplace(local0);
  1855.         }
  1856.        
  1857.         protected override QilNode VisitAfter(QilBinary local0)
  1858.         {
  1859.             QilNode local1 = local0[0];
  1860.             QilNode local2 = local0[1];
  1861.             if (this[XmlILOptimization.FoldNone]) {
  1862.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1863.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1864.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1865.                     }
  1866.                 }
  1867.             }
  1868.             if (this[XmlILOptimization.FoldNone]) {
  1869.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1870.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1871.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1872.                     }
  1873.                 }
  1874.             }
  1875.             if (this[XmlILOptimization.EliminateAfter]) {
  1876.                 if (local2 == local1) {
  1877.                     if (AllowReplace(XmlILOptimization.EliminateAfter, local0)) {
  1878.                         return Replace(XmlILOptimization.EliminateAfter, local0, VisitFalse(f.False()));
  1879.                     }
  1880.                 }
  1881.             }
  1882.             return NoReplace(local0);
  1883.         }
  1884.        
  1885.         protected override QilNode VisitBefore(QilBinary local0)
  1886.         {
  1887.             QilNode local1 = local0[0];
  1888.             QilNode local2 = local0[1];
  1889.             if (this[XmlILOptimization.FoldNone]) {
  1890.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1891.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1892.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  1893.                     }
  1894.                 }
  1895.             }
  1896.             if (this[XmlILOptimization.FoldNone]) {
  1897.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  1898.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1899.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  1900.                     }
  1901.                 }
  1902.             }
  1903.             if (this[XmlILOptimization.EliminateBefore]) {
  1904.                 if (local2 == local1) {
  1905.                     if (AllowReplace(XmlILOptimization.EliminateBefore, local0)) {
  1906.                         return Replace(XmlILOptimization.EliminateBefore, local0, VisitFalse(f.False()));
  1907.                     }
  1908.                 }
  1909.             }
  1910.             return NoReplace(local0);
  1911.         }
  1912.        
  1913.         #endregion // node comparison operators
  1914.        
  1915.         #region loops
  1916.         protected override QilNode VisitLoop(QilLoop local0)
  1917.         {
  1918.             QilNode local1 = local0[0];
  1919.             QilNode local2 = local0[1];
  1920.             if (this[XmlILOptimization.FoldNone]) {
  1921.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  1922.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  1923.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop((QilNode)(local1)[0])));
  1924.                     }
  1925.                 }
  1926.             }
  1927.             if (this[XmlILOptimization.EliminateIterator]) {
  1928.                 if (local1.NodeType == QilNodeType.For) {
  1929.                     QilNode local3 = local1[0];
  1930.                     if (local3.NodeType == QilNodeType.For) {
  1931.                         if (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.IsPositional)) {
  1932.                             if (AllowReplace(XmlILOptimization.EliminateIterator, local0)) {
  1933.                                 return Replace(XmlILOptimization.EliminateIterator, local0, Subs(local2, local1, local3));
  1934.                             }
  1935.                         }
  1936.                     }
  1937.                 }
  1938.             }
  1939.             if (this[XmlILOptimization.EliminateLoop]) {
  1940.                 if (local1.NodeType == QilNodeType.For) {
  1941.                     QilNode local3 = local1[0];
  1942.                     if (local3.NodeType == QilNodeType.Sequence) {
  1943.                         if ((local3).Count == (0)) {
  1944.                             if (AllowReplace(XmlILOptimization.EliminateLoop, local0)) {
  1945.                                 return Replace(XmlILOptimization.EliminateLoop, local0, VisitSequence(f.Sequence()));
  1946.                             }
  1947.                         }
  1948.                     }
  1949.                 }
  1950.             }
  1951.             if (this[XmlILOptimization.EliminateLoop]) {
  1952.                 if (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects)) {
  1953.                     if (local2.NodeType == QilNodeType.Sequence) {
  1954.                         if ((local2).Count == (0)) {
  1955.                             if (AllowReplace(XmlILOptimization.EliminateLoop, local0)) {
  1956.                                 return Replace(XmlILOptimization.EliminateLoop, local0, VisitSequence(f.Sequence()));
  1957.                             }
  1958.                         }
  1959.                     }
  1960.                 }
  1961.             }
  1962.             if (this[XmlILOptimization.EliminateLoop]) {
  1963.                 if (local2 == local1) {
  1964.                     if (AllowReplace(XmlILOptimization.EliminateLoop, local0)) {
  1965.                         return Replace(XmlILOptimization.EliminateLoop, local0, (QilNode)(local1)[0]);
  1966.                     }
  1967.                 }
  1968.             }
  1969.             if (this[XmlILOptimization.NormalizeLoopText]) {
  1970.                 if (local1.NodeType == QilNodeType.For) {
  1971.                     QilNode local3 = local1[0];
  1972.                     if (((local3).XmlType).IsSingleton) {
  1973.                         if (local2.NodeType == QilNodeType.TextCtor) {
  1974.                             QilNode local4 = local2[0];
  1975.                             if (AllowReplace(XmlILOptimization.NormalizeLoopText, local0)) {
  1976.                                 return Replace(XmlILOptimization.NormalizeLoopText, local0, VisitTextCtor(f.TextCtor(VisitLoop(f.Loop(local1, local4)))));
  1977.                             }
  1978.                         }
  1979.                     }
  1980.                 }
  1981.             }
  1982.             if (this[XmlILOptimization.EliminateIteratorUsedAtMostOnce]) {
  1983.                 if ((((local1).NodeType == QilNodeType.Let) || ((((QilNode)(local1)[0]).XmlType).IsSingleton)) && (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects))) {
  1984.                     if ((nodeCounter.Count(local2, local1) <= 1) && (!OptimizerPatterns.Read(local2).MatchesPattern(OptimizerPatternName.MaybeSideEffects))) {
  1985.                         if (AllowReplace(XmlILOptimization.EliminateIteratorUsedAtMostOnce, local0)) {
  1986.                             return Replace(XmlILOptimization.EliminateIteratorUsedAtMostOnce, local0, Subs(local2, local1, (QilNode)(local1)[0]));
  1987.                         }
  1988.                     }
  1989.                 }
  1990.             }
  1991.             if (this[XmlILOptimization.NormalizeLoopConditional]) {
  1992.                 if (local2.NodeType == QilNodeType.Conditional) {
  1993.                     QilNode local3 = local2[0];
  1994.                     QilNode local4 = local2[1];
  1995.                     QilNode local5 = local2[2];
  1996.                     if (local4.NodeType == QilNodeType.Sequence) {
  1997.                         if ((local4).Count == (0)) {
  1998.                             if (local5 == local1) {
  1999.                                 if (AllowReplace(XmlILOptimization.NormalizeLoopConditional, local0)) {
  2000.                                     return Replace(XmlILOptimization.NormalizeLoopConditional, local0, VisitFilter(f.Filter(local1, VisitNot(f.Not(local3)))));
  2001.                                 }
  2002.                             }
  2003.                         }
  2004.                     }
  2005.                 }
  2006.             }
  2007.             if (this[XmlILOptimization.NormalizeLoopConditional]) {
  2008.                 if (local2.NodeType == QilNodeType.Conditional) {
  2009.                     QilNode local3 = local2[0];
  2010.                     QilNode local4 = local2[1];
  2011.                     QilNode local5 = local2[2];
  2012.                     if (local4 == local1) {
  2013.                         if (local5.NodeType == QilNodeType.Sequence) {
  2014.                             if ((local5).Count == (0)) {
  2015.                                 if (AllowReplace(XmlILOptimization.NormalizeLoopConditional, local0)) {
  2016.                                     return Replace(XmlILOptimization.NormalizeLoopConditional, local0, VisitFilter(f.Filter(local1, local3)));
  2017.                                 }
  2018.                             }
  2019.                         }
  2020.                     }
  2021.                 }
  2022.             }
  2023.             if (this[XmlILOptimization.NormalizeLoopConditional]) {
  2024.                 if (local1.NodeType == QilNodeType.For) {
  2025.                     if (local2.NodeType == QilNodeType.Conditional) {
  2026.                         QilNode local4 = local2[0];
  2027.                         QilNode local5 = local2[1];
  2028.                         QilNode local6 = local2[2];
  2029.                         if (local5.NodeType == QilNodeType.Sequence) {
  2030.                             if ((local5).Count == (0)) {
  2031.                                 if (NonPositional(local6, local1)) {
  2032.                                     if (AllowReplace(XmlILOptimization.NormalizeLoopConditional, local0)) {
  2033.                                         QilNode local7 = VisitFor(f.For(VisitFilter(f.Filter(local1, VisitNot(f.Not(local4))))));
  2034.                                         return Replace(XmlILOptimization.NormalizeLoopConditional, local0, VisitLoop(f.Loop(local7, Subs(local6, local1, local7))));
  2035.                                     }
  2036.                                 }
  2037.                             }
  2038.                         }
  2039.                     }
  2040.                 }
  2041.             }
  2042.             if (this[XmlILOptimization.NormalizeLoopConditional]) {
  2043.                 if (local1.NodeType == QilNodeType.For) {
  2044.                     if (local2.NodeType == QilNodeType.Conditional) {
  2045.                         QilNode local4 = local2[0];
  2046.                         QilNode local5 = local2[1];
  2047.                         QilNode local6 = local2[2];
  2048.                         if (NonPositional(local5, local1)) {
  2049.                             if (local6.NodeType == QilNodeType.Sequence) {
  2050.                                 if ((local6).Count == (0)) {
  2051.                                     if (AllowReplace(XmlILOptimization.NormalizeLoopConditional, local0)) {
  2052.                                         QilNode local7 = VisitFor(f.For(VisitFilter(f.Filter(local1, local4))));
  2053.                                         return Replace(XmlILOptimization.NormalizeLoopConditional, local0, VisitLoop(f.Loop(local7, Subs(local5, local1, local7))));
  2054.                                     }
  2055.                                 }
  2056.                             }
  2057.                         }
  2058.                     }
  2059.                 }
  2060.             }
  2061.             if (this[XmlILOptimization.NormalizeLoopLoop]) {
  2062.                 if (local2.NodeType == QilNodeType.Loop) {
  2063.                     QilNode local3 = local2[0];
  2064.                     QilNode local5 = local2[1];
  2065.                     if (local3.NodeType == QilNodeType.For) {
  2066.                         QilNode local4 = local3[0];
  2067.                         if ((!(DependsOn(local5, local1))) && (NonPositional(local5, local3))) {
  2068.                             if (AllowReplace(XmlILOptimization.NormalizeLoopLoop, local0)) {
  2069.                                 QilNode local6 = VisitFor(f.For(VisitLoop(f.Loop(local1, local4))));
  2070.                                 return Replace(XmlILOptimization.NormalizeLoopLoop, local0, VisitLoop(f.Loop(local6, Subs(local5, local3, local6))));
  2071.                             }
  2072.                         }
  2073.                     }
  2074.                 }
  2075.             }
  2076.             if (this[XmlILOptimization.AnnotateSingletonLoop]) {
  2077.                 if (local1.NodeType == QilNodeType.For) {
  2078.                     QilNode local3 = local1[0];
  2079.                     if (!((local3).XmlType).MaybeMany) {
  2080.                         if (AllowReplace(XmlILOptimization.AnnotateSingletonLoop, local0)) {
  2081.                             OptimizerPatterns.Inherit((QilNode)(local2), (QilNode)(local0), OptimizerPatternName.IsDocOrderDistinct);
  2082.                             OptimizerPatterns.Inherit((QilNode)(local2), (QilNode)(local0), OptimizerPatternName.SameDepth);
  2083.                         }
  2084.                     }
  2085.                 }
  2086.             }
  2087.             if (this[XmlILOptimization.AnnotateRootLoop]) {
  2088.                 if (IsStepPattern(local2, QilNodeType.Root)) {
  2089.                     if (AllowReplace(XmlILOptimization.AnnotateRootLoop, local0)) {
  2090.                         OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SameDepth);
  2091.                     }
  2092.                 }
  2093.             }
  2094.             if (this[XmlILOptimization.AnnotateContentLoop]) {
  2095.                 if (local1.NodeType == QilNodeType.For) {
  2096.                     QilNode local3 = local1[0];
  2097.                     if (OptimizerPatterns.Read((QilNode)(local3)).MatchesPattern(OptimizerPatternName.SameDepth)) {
  2098.                         if (((IsStepPattern(local2, QilNodeType.Content)) || (IsStepPattern(local2, QilNodeType.Union))) && ((local1) == (OptimizerPatterns.Read((QilNode)(local2)).GetArgument(OptimizerPatternArgument.StepInput)))) {
  2099.                             if (AllowReplace(XmlILOptimization.AnnotateContentLoop, local0)) {
  2100.                                 OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SameDepth);
  2101.                                 OptimizerPatterns.Inherit((QilNode)(local3), (QilNode)(local0), OptimizerPatternName.IsDocOrderDistinct);
  2102.                             }
  2103.                         }
  2104.                     }
  2105.                 }
  2106.             }
  2107.             if (this[XmlILOptimization.AnnotateAttrNmspLoop]) {
  2108.                 if (local1.NodeType == QilNodeType.For) {
  2109.                     QilNode local3 = local1[0];
  2110.                     if ((((IsStepPattern(local2, QilNodeType.Attribute)) || (IsStepPattern(local2, QilNodeType.XPathNamespace))) || (OptimizerPatterns.Read((QilNode)(local2)).MatchesPattern(OptimizerPatternName.FilterAttributeKind))) && ((local1) == (OptimizerPatterns.Read((QilNode)(local2)).GetArgument(OptimizerPatternArgument.StepInput)))) {
  2111.                         if (AllowReplace(XmlILOptimization.AnnotateAttrNmspLoop, local0)) {
  2112.                             OptimizerPatterns.Inherit((QilNode)(local3), (QilNode)(local0), OptimizerPatternName.SameDepth);
  2113.                             OptimizerPatterns.Inherit((QilNode)(local3), (QilNode)(local0), OptimizerPatternName.IsDocOrderDistinct);
  2114.                         }
  2115.                     }
  2116.                 }
  2117.             }
  2118.             if (this[XmlILOptimization.AnnotateDescendantLoop]) {
  2119.                 if (local1.NodeType == QilNodeType.For) {
  2120.                     QilNode local3 = local1[0];
  2121.                     if (OptimizerPatterns.Read((QilNode)(local3)).MatchesPattern(OptimizerPatternName.SameDepth)) {
  2122.                         if (((IsStepPattern(local2, QilNodeType.Descendant)) || (IsStepPattern(local2, QilNodeType.DescendantOrSelf))) && ((local1) == (OptimizerPatterns.Read((QilNode)(local2)).GetArgument(OptimizerPatternArgument.StepInput)))) {
  2123.                             if (AllowReplace(XmlILOptimization.AnnotateDescendantLoop, local0)) {
  2124.                                 OptimizerPatterns.Inherit((QilNode)(local3), (QilNode)(local0), OptimizerPatternName.IsDocOrderDistinct);
  2125.                             }
  2126.                         }
  2127.                     }
  2128.                 }
  2129.             }
  2130.             return NoReplace(local0);
  2131.         }
  2132.        
  2133.         protected override QilNode VisitFilter(QilLoop local0)
  2134.         {
  2135.             QilNode local1 = local0[0];
  2136.             QilNode local2 = local0[1];
  2137.             if (this[XmlILOptimization.FoldNone]) {
  2138.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  2139.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2140.                         return Replace(XmlILOptimization.FoldNone, local0, VisitLoop(f.Loop(local1, local2)));
  2141.                     }
  2142.                 }
  2143.             }
  2144.             if (this[XmlILOptimization.EliminateFilter]) {
  2145.                 if (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects)) {
  2146.                     if (local2.NodeType == QilNodeType.False) {
  2147.                         if (AllowReplace(XmlILOptimization.EliminateFilter, local0)) {
  2148.                             return Replace(XmlILOptimization.EliminateFilter, local0, VisitSequence(f.Sequence()));
  2149.                         }
  2150.                     }
  2151.                 }
  2152.             }
  2153.             if (this[XmlILOptimization.EliminateFilter]) {
  2154.                 if (local2.NodeType == QilNodeType.True) {
  2155.                     if (AllowReplace(XmlILOptimization.EliminateFilter, local0)) {
  2156.                         return Replace(XmlILOptimization.EliminateFilter, local0, (QilNode)(local1)[0]);
  2157.                     }
  2158.                 }
  2159.             }
  2160.             if (this[XmlILOptimization.NormalizeAttribute]) {
  2161.                 if (local1.NodeType == QilNodeType.For) {
  2162.                     QilNode local3 = local1[0];
  2163.                     if (local3.NodeType == QilNodeType.Content) {
  2164.                         QilNode local4 = local3[0];
  2165.                         if (local2.NodeType == QilNodeType.And) {
  2166.                             QilNode local5 = local2[0];
  2167.                             QilNode local9 = local2[1];
  2168.                             if (local5.NodeType == QilNodeType.IsType) {
  2169.                                 QilNode local6 = local5[0];
  2170.                                 QilNode local7 = local5[1];
  2171.                                 if (local6 == local1) {
  2172.                                     if (local7.NodeType == QilNodeType.LiteralType) {
  2173.                                         XmlQueryType local8 = (XmlQueryType)((QilLiteral)local7).Value;
  2174.                                         if ((local8) == (XmlQueryTypeFactory.Attribute)) {
  2175.                                             if (local9.NodeType == QilNodeType.Eq) {
  2176.                                                 QilNode local10 = local9[0];
  2177.                                                 QilNode local12 = local9[1];
  2178.                                                 if (local10.NodeType == QilNodeType.NameOf) {
  2179.                                                     QilNode local11 = local10[0];
  2180.                                                     if (local11 == local1) {
  2181.                                                         if (local12.NodeType == QilNodeType.LiteralQName) {
  2182.                                                             if (AllowReplace(XmlILOptimization.NormalizeAttribute, local0)) {
  2183.                                                                 return Replace(XmlILOptimization.NormalizeAttribute, local0, VisitAttribute(f.Attribute(local4, local12)));
  2184.                                                             }
  2185.                                                         }
  2186.                                                     }
  2187.                                                 }
  2188.                                             }
  2189.                                         }
  2190.                                     }
  2191.                                 }
  2192.                             }
  2193.                         }
  2194.                     }
  2195.                 }
  2196.             }
  2197.             if (this[XmlILOptimization.CommuteFilterLoop]) {
  2198.                 if (local1.NodeType == QilNodeType.For) {
  2199.                     QilNode local3 = local1[0];
  2200.                     if (local3.NodeType == QilNodeType.Loop) {
  2201.                         QilNode local4 = local3[0];
  2202.                         QilNode local5 = local3[1];
  2203.                         if (NonPositional(local2, local1)) {
  2204.                             if (AllowReplace(XmlILOptimization.CommuteFilterLoop, local0)) {
  2205.                                 QilNode local6 = VisitFor(f.For(local5));
  2206.                                 return Replace(XmlILOptimization.CommuteFilterLoop, local0, VisitLoop(f.Loop(local4, VisitFilter(f.Filter(local6, Subs(local2, local1, local6))))));
  2207.                             }
  2208.                         }
  2209.                     }
  2210.                 }
  2211.             }
  2212.             if (this[XmlILOptimization.NormalizeLoopInvariant]) {
  2213.                 if (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects)) {
  2214.                     if ((!(DependsOn(local2, local1))) && (!OptimizerPatterns.Read(local2).MatchesPattern(OptimizerPatternName.MaybeSideEffects))) {
  2215.                         if (AllowReplace(XmlILOptimization.NormalizeLoopInvariant, local0)) {
  2216.                             return Replace(XmlILOptimization.NormalizeLoopInvariant, local0, VisitConditional(f.Conditional(local2, (QilNode)(local1)[0], VisitSequence(f.Sequence()))));
  2217.                         }
  2218.                     }
  2219.                 }
  2220.             }
  2221.             if (this[XmlILOptimization.AnnotateMaxPositionEq]) {
  2222.                 if (local2.NodeType == QilNodeType.Eq) {
  2223.                     QilNode local3 = local2[0];
  2224.                     QilNode local5 = local2[1];
  2225.                     if (local3.NodeType == QilNodeType.PositionOf) {
  2226.                         QilNode local4 = local3[0];
  2227.                         if (local4 == local1) {
  2228.                             if (local5.NodeType == QilNodeType.LiteralInt32) {
  2229.                                 int local6 = (int)((QilLiteral)local5).Value;
  2230.                                 if (AllowReplace(XmlILOptimization.AnnotateMaxPositionEq, local0)) {
  2231.                                     OptimizerPatterns.Write((QilNode)(local1)).AddPattern(OptimizerPatternName.MaxPosition);
  2232.                                     OptimizerPatterns.Write((QilNode)(local1)).AddArgument(OptimizerPatternArgument.MaxPosition, local6);
  2233.                                 }
  2234.                             }
  2235.                         }
  2236.                     }
  2237.                 }
  2238.             }
  2239.             if (this[XmlILOptimization.AnnotateMaxPositionLe]) {
  2240.                 if (local2.NodeType == QilNodeType.Le) {
  2241.                     QilNode local3 = local2[0];
  2242.                     QilNode local5 = local2[1];
  2243.                     if (local3.NodeType == QilNodeType.PositionOf) {
  2244.                         QilNode local4 = local3[0];
  2245.                         if (local4 == local1) {
  2246.                             if (local5.NodeType == QilNodeType.LiteralInt32) {
  2247.                                 int local6 = (int)((QilLiteral)local5).Value;
  2248.                                 if (AllowReplace(XmlILOptimization.AnnotateMaxPositionLe, local0)) {
  2249.                                     OptimizerPatterns.Write((QilNode)(local1)).AddPattern(OptimizerPatternName.MaxPosition);
  2250.                                     OptimizerPatterns.Write((QilNode)(local1)).AddArgument(OptimizerPatternArgument.MaxPosition, local6);
  2251.                                 }
  2252.                             }
  2253.                         }
  2254.                     }
  2255.                 }
  2256.             }
  2257.             if (this[XmlILOptimization.AnnotateMaxPositionLt]) {
  2258.                 if (local2.NodeType == QilNodeType.Lt) {
  2259.                     QilNode local3 = local2[0];
  2260.                     QilNode local5 = local2[1];
  2261.                     if (local3.NodeType == QilNodeType.PositionOf) {
  2262.                         QilNode local4 = local3[0];
  2263.                         if (local4 == local1) {
  2264.                             if (local5.NodeType == QilNodeType.LiteralInt32) {
  2265.                                 int local6 = (int)((QilLiteral)local5).Value;
  2266.                                 if (AllowReplace(XmlILOptimization.AnnotateMaxPositionLt, local0)) {
  2267.                                     OptimizerPatterns.Write((QilNode)(local1)).AddPattern(OptimizerPatternName.MaxPosition);
  2268.                                     OptimizerPatterns.Write((QilNode)(local1)).AddArgument(OptimizerPatternArgument.MaxPosition, local6 - 1);
  2269.                                 }
  2270.                             }
  2271.                         }
  2272.                     }
  2273.                 }
  2274.             }
  2275.             if (this[XmlILOptimization.AnnotateFilter]) {
  2276.                 if (local1.NodeType == QilNodeType.For) {
  2277.                     QilNode local3 = local1[0];
  2278.                     if (AllowReplace(XmlILOptimization.AnnotateFilter, local0)) {
  2279.                         OptimizerPatterns.Inherit((QilNode)(local3), (QilNode)(local0), OptimizerPatternName.Step);
  2280.                         OptimizerPatterns.Inherit((QilNode)(local3), (QilNode)(local0), OptimizerPatternName.IsDocOrderDistinct);
  2281.                         OptimizerPatterns.Inherit((QilNode)(local3), (QilNode)(local0), OptimizerPatternName.SameDepth);
  2282.                     }
  2283.                 }
  2284.             }
  2285.             if (this[XmlILOptimization.AnnotateFilterElements]) {
  2286.                 if (local1.NodeType == QilNodeType.For) {
  2287.                     QilNode local3 = local1[0];
  2288.                     if (OptimizerPatterns.Read((QilNode)(local3)).MatchesPattern(OptimizerPatternName.Axis)) {
  2289.                         if (local2.NodeType == QilNodeType.And) {
  2290.                             QilNode local4 = local2[0];
  2291.                             QilNode local8 = local2[1];
  2292.                             if (local4.NodeType == QilNodeType.IsType) {
  2293.                                 QilNode local5 = local4[0];
  2294.                                 QilNode local6 = local4[1];
  2295.                                 if (local5 == local1) {
  2296.                                     if (local6.NodeType == QilNodeType.LiteralType) {
  2297.                                         XmlQueryType local7 = (XmlQueryType)((QilLiteral)local6).Value;
  2298.                                         if ((local7) == (XmlQueryTypeFactory.Element)) {
  2299.                                             if (local8.NodeType == QilNodeType.Eq) {
  2300.                                                 QilNode local9 = local8[0];
  2301.                                                 QilNode local11 = local8[1];
  2302.                                                 if (local9.NodeType == QilNodeType.NameOf) {
  2303.                                                     QilNode local10 = local9[0];
  2304.                                                     if (local10 == local1) {
  2305.                                                         if (local11.NodeType == QilNodeType.LiteralQName) {
  2306.                                                             if (AllowReplace(XmlILOptimization.AnnotateFilterElements, local0)) {
  2307.                                                                 OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.FilterElements);
  2308.                                                                 OptimizerPatterns.Write((QilNode)(local0)).AddArgument(OptimizerPatternArgument.ElementQName, local11);
  2309.                                                             }
  2310.                                                         }
  2311.                                                     }
  2312.                                                 }
  2313.                                             }
  2314.                                         }
  2315.                                     }
  2316.                                 }
  2317.                             }
  2318.                         }
  2319.                     }
  2320.                 }
  2321.             }
  2322.             if (this[XmlILOptimization.AnnotateFilterContentKind]) {
  2323.                 if (local1.NodeType == QilNodeType.For) {
  2324.                     QilNode local3 = local1[0];
  2325.                     if (OptimizerPatterns.Read((QilNode)(local3)).MatchesPattern(OptimizerPatternName.Axis)) {
  2326.                         if (local2.NodeType == QilNodeType.IsType) {
  2327.                             QilNode local4 = local2[0];
  2328.                             QilNode local5 = local2[1];
  2329.                             if (local4 == local1) {
  2330.                                 if (local5.NodeType == QilNodeType.LiteralType) {
  2331.                                     XmlQueryType local6 = (XmlQueryType)((QilLiteral)local5).Value;
  2332.                                     if (MatchesContentTest(local6)) {
  2333.                                         if (AllowReplace(XmlILOptimization.AnnotateFilterContentKind, local0)) {
  2334.                                             OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.FilterContentKind);
  2335.                                             OptimizerPatterns.Write((QilNode)(local0)).AddArgument(OptimizerPatternArgument.KindTestType, local6);
  2336.                                         }
  2337.                                     }
  2338.                                 }
  2339.                             }
  2340.                         }
  2341.                     }
  2342.                 }
  2343.             }
  2344.             if (this[XmlILOptimization.AnnotateFilterAttributeKind]) {
  2345.                 if (local1.NodeType == QilNodeType.For) {
  2346.                     QilNode local3 = local1[0];
  2347.                     if (local3.NodeType == QilNodeType.Content) {
  2348.                         if (local2.NodeType == QilNodeType.IsType) {
  2349.                             QilNode local5 = local2[0];
  2350.                             QilNode local6 = local2[1];
  2351.                             if (local5 == local1) {
  2352.                                 if (local6.NodeType == QilNodeType.LiteralType) {
  2353.                                     XmlQueryType local7 = (XmlQueryType)((QilLiteral)local6).Value;
  2354.                                     if ((local7) == (XmlQueryTypeFactory.Attribute)) {
  2355.                                         if (AllowReplace(XmlILOptimization.AnnotateFilterAttributeKind, local0)) {
  2356.                                             OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.FilterAttributeKind);
  2357.                                         }
  2358.                                     }
  2359.                                 }
  2360.                             }
  2361.                         }
  2362.                     }
  2363.                 }
  2364.             }
  2365.             return NoReplace(local0);
  2366.         }
  2367.        
  2368.         #endregion // loops
  2369.        
  2370.         #region sorting
  2371.         protected override QilNode VisitSort(QilLoop local0)
  2372.         {
  2373.             QilNode local1 = local0[0];
  2374.             QilNode local2 = local0[1];
  2375.             if (this[XmlILOptimization.FoldNone]) {
  2376.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2377.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2378.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop((QilNode)(local1)[0])));
  2379.                     }
  2380.                 }
  2381.             }
  2382.             if (this[XmlILOptimization.EliminateSort]) {
  2383.                 if (local1.NodeType == QilNodeType.For) {
  2384.                     QilNode local3 = local1[0];
  2385.                     if (((local3).XmlType).IsSingleton) {
  2386.                         if (AllowReplace(XmlILOptimization.EliminateSort, local0)) {
  2387.                             return Replace(XmlILOptimization.EliminateSort, local0, VisitNop(f.Nop(local3)));
  2388.                         }
  2389.                     }
  2390.                 }
  2391.             }
  2392.             return NoReplace(local0);
  2393.         }
  2394.        
  2395.         protected override QilNode VisitSortKey(QilSortKey local0)
  2396.         {
  2397.             QilNode local1 = local0[0];
  2398.             QilNode local2 = local0[1];
  2399.             if (this[XmlILOptimization.NormalizeSortXsltConvert]) {
  2400.                 if (local1.NodeType == QilNodeType.XsltConvert) {
  2401.                     QilNode local3 = local1[0];
  2402.                     QilNode local4 = local1[1];
  2403.                     if (local4.NodeType == QilNodeType.LiteralType) {
  2404.                         XmlQueryType local5 = (XmlQueryType)((QilLiteral)local4).Value;
  2405.                         if ((((local3).XmlType) == (XmlQueryTypeFactory.IntX)) && ((local5) == (XmlQueryTypeFactory.DoubleX))) {
  2406.                             if (AllowReplace(XmlILOptimization.NormalizeSortXsltConvert, local0)) {
  2407.                                 return Replace(XmlILOptimization.NormalizeSortXsltConvert, local0, VisitSortKey(f.SortKey(local3, local2)));
  2408.                             }
  2409.                         }
  2410.                     }
  2411.                 }
  2412.             }
  2413.             return NoReplace(local0);
  2414.         }
  2415.        
  2416.         protected override QilNode VisitDocOrderDistinct(QilUnary local0)
  2417.         {
  2418.             QilNode local1 = local0[0];
  2419.             if (this[XmlILOptimization.FoldNone]) {
  2420.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2421.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2422.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2423.                     }
  2424.                 }
  2425.             }
  2426.             if (this[XmlILOptimization.EliminateDod]) {
  2427.                 if (IsDocOrderDistinct(local1)) {
  2428.                     if (AllowReplace(XmlILOptimization.EliminateDod, local0)) {
  2429.                         return Replace(XmlILOptimization.EliminateDod, local0, local1);
  2430.                     }
  2431.                 }
  2432.             }
  2433.             if (this[XmlILOptimization.FoldNamedDescendants]) {
  2434.                 if (local1.NodeType == QilNodeType.Loop) {
  2435.                     QilNode local2 = local1[0];
  2436.                     QilNode local7 = local1[1];
  2437.                     if (local2.NodeType == QilNodeType.For) {
  2438.                         QilNode local3 = local2[0];
  2439.                         if (local3.NodeType == QilNodeType.Loop) {
  2440.                             QilNode local4 = local3[0];
  2441.                             QilNode local5 = local3[1];
  2442.                             if (local5.NodeType == QilNodeType.DescendantOrSelf) {
  2443.                                 QilNode local6 = local5[0];
  2444.                                 if (local7.NodeType == QilNodeType.Filter) {
  2445.                                     QilNode local8 = local7[0];
  2446.                                     QilNode local9 = local7[1];
  2447.                                     if (((OptimizerPatterns.Read((QilNode)(local7)).MatchesPattern(OptimizerPatternName.FilterElements)) || (OptimizerPatterns.Read((QilNode)(local7)).MatchesPattern(OptimizerPatternName.FilterContentKind))) && (IsStepPattern(local7, QilNodeType.Content))) {
  2448.                                         if (AllowReplace(XmlILOptimization.FoldNamedDescendants, local0)) {
  2449.                                             QilNode local10 = VisitFor(f.For(VisitDescendant(f.Descendant(local6))));
  2450.                                             return Replace(XmlILOptimization.FoldNamedDescendants, local0, VisitDocOrderDistinct(f.DocOrderDistinct(VisitLoop(f.Loop(local4, VisitFilter(f.Filter(local10, Subs(local9, local8, local10))))))));
  2451.                                         }
  2452.                                     }
  2453.                                 }
  2454.                             }
  2455.                         }
  2456.                     }
  2457.                 }
  2458.             }
  2459.             if (this[XmlILOptimization.FoldNamedDescendants]) {
  2460.                 if (local1.NodeType == QilNodeType.Loop) {
  2461.                     QilNode local2 = local1[0];
  2462.                     QilNode local5 = local1[1];
  2463.                     if (local2.NodeType == QilNodeType.For) {
  2464.                         QilNode local3 = local2[0];
  2465.                         if (local3.NodeType == QilNodeType.DescendantOrSelf) {
  2466.                             QilNode local4 = local3[0];
  2467.                             if (local5.NodeType == QilNodeType.Filter) {
  2468.                                 QilNode local6 = local5[0];
  2469.                                 QilNode local7 = local5[1];
  2470.                                 if (((OptimizerPatterns.Read((QilNode)(local5)).MatchesPattern(OptimizerPatternName.FilterElements)) || (OptimizerPatterns.Read((QilNode)(local5)).MatchesPattern(OptimizerPatternName.FilterContentKind))) && (IsStepPattern(local5, QilNodeType.Content))) {
  2471.                                     if (AllowReplace(XmlILOptimization.FoldNamedDescendants, local0)) {
  2472.                                         QilNode local8 = VisitFor(f.For(VisitDescendant(f.Descendant(local4))));
  2473.                                         return Replace(XmlILOptimization.FoldNamedDescendants, local0, VisitFilter(f.Filter(local8, Subs(local7, local6, local8))));
  2474.                                     }
  2475.                                 }
  2476.                             }
  2477.                         }
  2478.                     }
  2479.                 }
  2480.             }
  2481.             if (this[XmlILOptimization.CommuteDodFilter]) {
  2482.                 if (local1.NodeType == QilNodeType.Filter) {
  2483.                     QilNode local2 = local1[0];
  2484.                     QilNode local4 = local1[1];
  2485.                     if (local2.NodeType == QilNodeType.For) {
  2486.                         QilNode local3 = local2[0];
  2487.                         if (!OptimizerPatterns.Read(local2).MatchesPattern(OptimizerPatternName.IsPositional)) {
  2488.                             if (((!(OptimizerPatterns.Read((QilNode)(local1)).MatchesPattern(OptimizerPatternName.FilterElements))) && (!(OptimizerPatterns.Read((QilNode)(local1)).MatchesPattern(OptimizerPatternName.FilterContentKind)))) && (!(OptimizerPatterns.Read((QilNode)(local1)).MatchesPattern(OptimizerPatternName.FilterAttributeKind)))) {
  2489.                                 if (AllowReplace(XmlILOptimization.CommuteDodFilter, local0)) {
  2490.                                     QilNode local5 = VisitFor(f.For(VisitDocOrderDistinct(f.DocOrderDistinct(local3))));
  2491.                                     return Replace(XmlILOptimization.CommuteDodFilter, local0, VisitFilter(f.Filter(local5, Subs(local4, local2, local5))));
  2492.                                 }
  2493.                             }
  2494.                         }
  2495.                     }
  2496.                 }
  2497.             }
  2498.             if (this[XmlILOptimization.CommuteDodFilter]) {
  2499.                 if (local1.NodeType == QilNodeType.Loop) {
  2500.                     QilNode local2 = local1[0];
  2501.                     QilNode local3 = local1[1];
  2502.                     if (local3.NodeType == QilNodeType.Filter) {
  2503.                         QilNode local4 = local3[0];
  2504.                         QilNode local6 = local3[1];
  2505.                         if (local4.NodeType == QilNodeType.For) {
  2506.                             QilNode local5 = local4[0];
  2507.                             if (!OptimizerPatterns.Read(local4).MatchesPattern(OptimizerPatternName.IsPositional)) {
  2508.                                 if (!(DependsOn(local6, local2))) {
  2509.                                     if (((!(OptimizerPatterns.Read((QilNode)(local3)).MatchesPattern(OptimizerPatternName.FilterElements))) && (!(OptimizerPatterns.Read((QilNode)(local3)).MatchesPattern(OptimizerPatternName.FilterContentKind)))) && (!(OptimizerPatterns.Read((QilNode)(local3)).MatchesPattern(OptimizerPatternName.FilterAttributeKind)))) {
  2510.                                         if (AllowReplace(XmlILOptimization.CommuteDodFilter, local0)) {
  2511.                                             QilNode local7 = VisitFor(f.For(VisitDocOrderDistinct(f.DocOrderDistinct(VisitLoop(f.Loop(local2, local5))))));
  2512.                                             return Replace(XmlILOptimization.CommuteDodFilter, local0, VisitFilter(f.Filter(local7, Subs(local6, local4, local7))));
  2513.                                         }
  2514.                                     }
  2515.                                 }
  2516.                             }
  2517.                         }
  2518.                     }
  2519.                 }
  2520.             }
  2521.             if (this[XmlILOptimization.IntroduceDod]) {
  2522.                 if (local1.NodeType == QilNodeType.Loop) {
  2523.                     QilNode local2 = local1[0];
  2524.                     QilNode local4 = local1[1];
  2525.                     if (local2.NodeType == QilNodeType.For) {
  2526.                         QilNode local3 = local2[0];
  2527.                         if (!(IsDocOrderDistinct(local3))) {
  2528.                             if ((!OptimizerPatterns.Read(local2).MatchesPattern(OptimizerPatternName.IsPositional)) && ((local3).XmlType.IsSubtypeOf(XmlQueryTypeFactory.NodeNotRtfS))) {
  2529.                                 if (((!(OptimizerPatterns.Read((QilNode)(local1)).MatchesPattern(OptimizerPatternName.FilterElements))) && (!(OptimizerPatterns.Read((QilNode)(local1)).MatchesPattern(OptimizerPatternName.FilterContentKind)))) && (!(OptimizerPatterns.Read((QilNode)(local1)).MatchesPattern(OptimizerPatternName.FilterAttributeKind)))) {
  2530.                                     if (AllowReplace(XmlILOptimization.IntroduceDod, local0)) {
  2531.                                         QilNode local5 = VisitFor(f.For(VisitDocOrderDistinct(f.DocOrderDistinct(local3))));
  2532.                                         return Replace(XmlILOptimization.IntroduceDod, local0, VisitDocOrderDistinct(f.DocOrderDistinct(VisitLoop(f.Loop(local5, Subs(local4, local2, local5))))));
  2533.                                     }
  2534.                                 }
  2535.                             }
  2536.                         }
  2537.                     }
  2538.                 }
  2539.             }
  2540.             if (this[XmlILOptimization.IntroducePrecedingDod]) {
  2541.                 if (local1.NodeType == QilNodeType.Loop) {
  2542.                     QilNode local2 = local1[0];
  2543.                     QilNode local3 = local1[1];
  2544.                     if ((!(IsDocOrderDistinct(local3))) && (IsStepPattern(local3, QilNodeType.PrecedingSibling))) {
  2545.                         if (AllowReplace(XmlILOptimization.IntroducePrecedingDod, local0)) {
  2546.                             return Replace(XmlILOptimization.IntroducePrecedingDod, local0, VisitDocOrderDistinct(f.DocOrderDistinct(VisitLoop(f.Loop(local2, VisitDocOrderDistinct(f.DocOrderDistinct(local3)))))));
  2547.                         }
  2548.                     }
  2549.                 }
  2550.             }
  2551.             if (this[XmlILOptimization.EliminateReturnDod]) {
  2552.                 if (local1.NodeType == QilNodeType.Loop) {
  2553.                     QilNode local2 = local1[0];
  2554.                     QilNode local3 = local1[1];
  2555.                     if (local3.NodeType == QilNodeType.DocOrderDistinct) {
  2556.                         QilNode local4 = local3[0];
  2557.                         if (!(IsStepPattern(local4, QilNodeType.PrecedingSibling))) {
  2558.                             if (AllowReplace(XmlILOptimization.EliminateReturnDod, local0)) {
  2559.                                 return Replace(XmlILOptimization.EliminateReturnDod, local0, VisitDocOrderDistinct(f.DocOrderDistinct(VisitLoop(f.Loop(local2, local4)))));
  2560.                             }
  2561.                         }
  2562.                     }
  2563.                 }
  2564.             }
  2565.             if (this[XmlILOptimization.AnnotateDod]) {
  2566.                 if (AllowReplace(XmlILOptimization.AnnotateDod, local0)) {
  2567.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  2568.                     OptimizerPatterns.Inherit((QilNode)(local1), (QilNode)(local0), OptimizerPatternName.SameDepth);
  2569.                 }
  2570.             }
  2571.             if (this[XmlILOptimization.AnnotateDodReverse]) {
  2572.                 if (AllowDodReverse(local1)) {
  2573.                     if (AllowReplace(XmlILOptimization.AnnotateDodReverse, local0)) {
  2574.                         OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.DodReverse);
  2575.                         OptimizerPatterns.Write((QilNode)(local0)).AddArgument(OptimizerPatternArgument.DodStep, local1);
  2576.                     }
  2577.                 }
  2578.             }
  2579.             if (this[XmlILOptimization.AnnotateJoinAndDod]) {
  2580.                 if (local1.NodeType == QilNodeType.Loop) {
  2581.                     QilNode local2 = local1[0];
  2582.                     QilNode local4 = local1[1];
  2583.                     if (local2.NodeType == QilNodeType.For) {
  2584.                         QilNode local3 = local2[0];
  2585.                         if (IsDocOrderDistinct(local3)) {
  2586.                             if ((AllowJoinAndDod(local4)) && ((local2) == (OptimizerPatterns.Read((QilNode)(local4)).GetArgument(OptimizerPatternArgument.StepInput)))) {
  2587.                                 if (AllowReplace(XmlILOptimization.AnnotateJoinAndDod, local0)) {
  2588.                                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.JoinAndDod);
  2589.                                     OptimizerPatterns.Write((QilNode)(local0)).AddArgument(OptimizerPatternArgument.DodStep, local4);
  2590.                                 }
  2591.                             }
  2592.                         }
  2593.                     }
  2594.                 }
  2595.             }
  2596.             if (this[XmlILOptimization.AnnotateDodMerge]) {
  2597.                 if (local1.NodeType == QilNodeType.Loop) {
  2598.                     QilNode local3 = local1[1];
  2599.                     if (local3.NodeType == QilNodeType.Invoke) {
  2600.                         if (IsDocOrderDistinct(local3)) {
  2601.                             if (AllowReplace(XmlILOptimization.AnnotateDodMerge, local0)) {
  2602.                                 OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.DodMerge);
  2603.                             }
  2604.                         }
  2605.                     }
  2606.                 }
  2607.             }
  2608.             return NoReplace(local0);
  2609.         }
  2610.        
  2611.         #endregion // sorting
  2612.        
  2613.         #region function definition and invocation
  2614.         protected override QilNode VisitFunction(QilFunction local0)
  2615.         {
  2616.             QilNode local1 = local0[0];
  2617.             QilNode local2 = local0[1];
  2618.             QilNode local3 = local0[2];
  2619.             XmlQueryType local4 = (XmlQueryType)((QilFunction)local0).XmlType;
  2620.             if (((local0).XmlType.IsSubtypeOf(XmlQueryTypeFactory.NodeS)) && (this[XmlILOptimization.AnnotateIndex1])) {
  2621.                 if (((local1.Count == 2) && (((QilNode)(local1)[0]).XmlType.IsSubtypeOf(XmlQueryTypeFactory.Node))) && ((((QilNode)(local1)[1]).XmlType) == (XmlQueryTypeFactory.StringX))) {
  2622.                     if (local2.NodeType == QilNodeType.Filter) {
  2623.                         QilNode local5 = local2[0];
  2624.                         QilNode local7 = local2[1];
  2625.                         if (local5.NodeType == QilNodeType.For) {
  2626.                             QilNode local6 = local5[0];
  2627.                             if (local7.NodeType == QilNodeType.Not) {
  2628.                                 QilNode local8 = local7[0];
  2629.                                 if (local8.NodeType == QilNodeType.IsEmpty) {
  2630.                                     QilNode local9 = local8[0];
  2631.                                     if (local9.NodeType == QilNodeType.Filter) {
  2632.                                         QilNode local10 = local9[0];
  2633.                                         QilNode local12 = local9[1];
  2634.                                         if (local10.NodeType == QilNodeType.For) {
  2635.                                             QilNode local11 = local10[0];
  2636.                                             if (local12.NodeType == QilNodeType.Eq) {
  2637.                                                 QilNode local13 = local12[0];
  2638.                                                 QilNode local14 = local12[1];
  2639.                                                 if (local13 == local10) {
  2640.                                                     if (local14.NodeType == QilNodeType.Parameter) {
  2641.                                                         if ((local14) == ((QilNode)(local1)[1])) {
  2642.                                                             if (AllowReplace(XmlILOptimization.AnnotateIndex1, local0)) {
  2643.                                                                
  2644.                                                                 // The following conditions must be true for this pattern to match:
  2645.                                                                 // 1. The function must have exactly two arguments
  2646.                                                                 // 2. The type of the first argument must be a subtype of Node
  2647.                                                                 // 3. The type of the second argument must be String
  2648.                                                                 // 4. The return type must be a subtype of Node*
  2649.                                                                 // 5. Every reference to $args[0] (context document) must be wrapped in an (Root *) function
  2650.                                                                 // 6. $keyParam cannot be used with the $bindingNodes and $bindingKeys expressions
  2651.                                                                
  2652.                                                                 EqualityIndexVisitor visitor = new EqualityIndexVisitor();
  2653.                                                                 if (visitor.Scan(local6, local1[0], local14) && visitor.Scan(local11, local1[0], local14)) {
  2654.                                                                     // All conditions were true, so annotate Filter with the EqualityIndex pattern
  2655.                                                                     OptimizerPatterns patt = OptimizerPatterns.Write(local2);
  2656.                                                                     patt.AddPattern(OptimizerPatternName.EqualityIndex);
  2657.                                                                     patt.AddArgument(OptimizerPatternArgument.IndexedNodes, local5);
  2658.                                                                     patt.AddArgument(OptimizerPatternArgument.KeyExpression, local11);
  2659.                                                                 }
  2660.                                                             }
  2661.                                                         }
  2662.                                                     }
  2663.                                                 }
  2664.                                             }
  2665.                                         }
  2666.                                     }
  2667.                                 }
  2668.                             }
  2669.                         }
  2670.                     }
  2671.                 }
  2672.             }
  2673.             if (this[XmlILOptimization.AnnotateIndex2]) {
  2674.                 if (((local1.Count == 2) && ((((QilNode)(local1)[0]).XmlType) == (XmlQueryTypeFactory.Node))) && ((((QilNode)(local1)[1]).XmlType) == (XmlQueryTypeFactory.StringX))) {
  2675.                     if (local2.NodeType == QilNodeType.Filter) {
  2676.                         QilNode local5 = local2[0];
  2677.                         QilNode local7 = local2[1];
  2678.                         if (local5.NodeType == QilNodeType.For) {
  2679.                             QilNode local6 = local5[0];
  2680.                             if (local7.NodeType == QilNodeType.Eq) {
  2681.                                 QilNode local8 = local7[0];
  2682.                                 QilNode local9 = local7[1];
  2683.                                 if (local9.NodeType == QilNodeType.Parameter) {
  2684.                                     if ((local9) == ((QilNode)(local1)[1])) {
  2685.                                         if (AllowReplace(XmlILOptimization.AnnotateIndex2, local0)) {
  2686.                                            
  2687.                                             // Same as EqualityIndex1, except that each nodes has at most one key value
  2688.                                            
  2689.                                             EqualityIndexVisitor visitor = new EqualityIndexVisitor();
  2690.                                             if (visitor.Scan(local6, local1[0], local9) && visitor.Scan(local8, local1[0], local9)) {
  2691.                                                 // All conditions were true, so annotate Filter with the EqualityIndex pattern
  2692.                                                 OptimizerPatterns patt = OptimizerPatterns.Write(local2);
  2693.                                                 patt.AddPattern(OptimizerPatternName.EqualityIndex);
  2694.                                                 patt.AddArgument(OptimizerPatternArgument.IndexedNodes, local5);
  2695.                                                 patt.AddArgument(OptimizerPatternArgument.KeyExpression, local8);
  2696.                                             }
  2697.                                         }
  2698.                                     }
  2699.                                 }
  2700.                             }
  2701.                         }
  2702.                     }
  2703.                 }
  2704.             }
  2705.             return NoReplace(local0);
  2706.         }
  2707.        
  2708.         protected override QilNode VisitInvoke(QilInvoke local0)
  2709.         {
  2710.             QilNode local1 = local0[0];
  2711.             QilNode local2 = local0[1];
  2712.             if (this[XmlILOptimization.NormalizeInvokeEmpty]) {
  2713.                 if (local1.NodeType == QilNodeType.Function) {
  2714.                     QilNode local4 = local1[1];
  2715.                     if (local4.NodeType == QilNodeType.Sequence) {
  2716.                         if ((local4).Count == (0)) {
  2717.                             if (AllowReplace(XmlILOptimization.NormalizeInvokeEmpty, local0)) {
  2718.                                 return Replace(XmlILOptimization.NormalizeInvokeEmpty, local0, VisitSequence(f.Sequence()));
  2719.                             }
  2720.                         }
  2721.                     }
  2722.                 }
  2723.             }
  2724.             if (this[XmlILOptimization.AnnotateTrackCallers]) {
  2725.                 if (AllowReplace(XmlILOptimization.AnnotateTrackCallers, local0)) {
  2726.                     XmlILConstructInfo.Write(local1).CallersInfo.Add(XmlILConstructInfo.Write(local0));
  2727.                 }
  2728.             }
  2729.             if (this[XmlILOptimization.AnnotateInvoke]) {
  2730.                 if (local1.NodeType == QilNodeType.Function) {
  2731.                     QilNode local4 = local1[1];
  2732.                     if (AllowReplace(XmlILOptimization.AnnotateInvoke, local0)) {
  2733.                         OptimizerPatterns.Inherit((QilNode)(local4), (QilNode)(local0), OptimizerPatternName.IsDocOrderDistinct);
  2734.                         OptimizerPatterns.Inherit((QilNode)(local4), (QilNode)(local0), OptimizerPatternName.SameDepth);
  2735.                     }
  2736.                 }
  2737.             }
  2738.             return NoReplace(local0);
  2739.         }
  2740.        
  2741.         #endregion // function definition and invocation
  2742.        
  2743.         #region XML navigation
  2744.         protected override QilNode VisitContent(QilUnary local0)
  2745.         {
  2746.             QilNode local1 = local0[0];
  2747.             if (this[XmlILOptimization.FoldNone]) {
  2748.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2749.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2750.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2751.                     }
  2752.                 }
  2753.             }
  2754.             if (this[XmlILOptimization.AnnotateContent]) {
  2755.                 if (AllowReplace(XmlILOptimization.AnnotateContent, local0)) {
  2756.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2757.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2758.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  2759.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SameDepth);
  2760.                 }
  2761.             }
  2762.             return NoReplace(local0);
  2763.         }
  2764.        
  2765.         protected override QilNode VisitAttribute(QilBinary local0)
  2766.         {
  2767.             QilNode local1 = local0[0];
  2768.             QilNode local2 = local0[1];
  2769.             if (this[XmlILOptimization.FoldNone]) {
  2770.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2771.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2772.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2773.                     }
  2774.                 }
  2775.             }
  2776.             if (this[XmlILOptimization.FoldNone]) {
  2777.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  2778.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2779.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  2780.                     }
  2781.                 }
  2782.             }
  2783.             if (this[XmlILOptimization.AnnotateAttribute]) {
  2784.                 if (AllowReplace(XmlILOptimization.AnnotateAttribute, local0)) {
  2785.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2786.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2787.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  2788.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SameDepth);
  2789.                 }
  2790.             }
  2791.             return NoReplace(local0);
  2792.         }
  2793.        
  2794.         protected override QilNode VisitParent(QilUnary local0)
  2795.         {
  2796.             QilNode local1 = local0[0];
  2797.             if (this[XmlILOptimization.FoldNone]) {
  2798.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2799.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2800.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2801.                     }
  2802.                 }
  2803.             }
  2804.             if (this[XmlILOptimization.AnnotateParent]) {
  2805.                 if (AllowReplace(XmlILOptimization.AnnotateParent, local0)) {
  2806.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2807.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2808.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  2809.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SameDepth);
  2810.                 }
  2811.             }
  2812.             return NoReplace(local0);
  2813.         }
  2814.        
  2815.         protected override QilNode VisitRoot(QilUnary local0)
  2816.         {
  2817.             QilNode local1 = local0[0];
  2818.             if (this[XmlILOptimization.FoldNone]) {
  2819.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2820.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2821.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2822.                     }
  2823.                 }
  2824.             }
  2825.             if (this[XmlILOptimization.AnnotateRoot]) {
  2826.                 if (AllowReplace(XmlILOptimization.AnnotateRoot, local0)) {
  2827.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2828.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2829.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  2830.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SameDepth);
  2831.                 }
  2832.             }
  2833.             return NoReplace(local0);
  2834.         }
  2835.        
  2836.         protected override QilNode VisitDescendant(QilUnary local0)
  2837.         {
  2838.             QilNode local1 = local0[0];
  2839.             if (this[XmlILOptimization.FoldNone]) {
  2840.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2841.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2842.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2843.                     }
  2844.                 }
  2845.             }
  2846.             if (this[XmlILOptimization.AnnotateDescendant]) {
  2847.                 if (AllowReplace(XmlILOptimization.AnnotateDescendant, local0)) {
  2848.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2849.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2850.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  2851.                 }
  2852.             }
  2853.             return NoReplace(local0);
  2854.         }
  2855.        
  2856.         protected override QilNode VisitDescendantOrSelf(QilUnary local0)
  2857.         {
  2858.             QilNode local1 = local0[0];
  2859.             if (this[XmlILOptimization.FoldNone]) {
  2860.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2861.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2862.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2863.                     }
  2864.                 }
  2865.             }
  2866.             if (this[XmlILOptimization.AnnotateDescendantSelf]) {
  2867.                 if (AllowReplace(XmlILOptimization.AnnotateDescendantSelf, local0)) {
  2868.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2869.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2870.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  2871.                 }
  2872.             }
  2873.             return NoReplace(local0);
  2874.         }
  2875.        
  2876.         protected override QilNode VisitAncestor(QilUnary local0)
  2877.         {
  2878.             QilNode local1 = local0[0];
  2879.             if (this[XmlILOptimization.FoldNone]) {
  2880.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2881.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2882.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2883.                     }
  2884.                 }
  2885.             }
  2886.             if (this[XmlILOptimization.AnnotateAncestor]) {
  2887.                 if (AllowReplace(XmlILOptimization.AnnotateAncestor, local0)) {
  2888.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2889.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2890.                 }
  2891.             }
  2892.             return NoReplace(local0);
  2893.         }
  2894.        
  2895.         protected override QilNode VisitAncestorOrSelf(QilUnary local0)
  2896.         {
  2897.             QilNode local1 = local0[0];
  2898.             if (this[XmlILOptimization.FoldNone]) {
  2899.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2900.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2901.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2902.                     }
  2903.                 }
  2904.             }
  2905.             if (this[XmlILOptimization.AnnotateAncestorSelf]) {
  2906.                 if (AllowReplace(XmlILOptimization.AnnotateAncestorSelf, local0)) {
  2907.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2908.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2909.                 }
  2910.             }
  2911.             return NoReplace(local0);
  2912.         }
  2913.        
  2914.         protected override QilNode VisitPreceding(QilUnary local0)
  2915.         {
  2916.             QilNode local1 = local0[0];
  2917.             if (this[XmlILOptimization.FoldNone]) {
  2918.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2919.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2920.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2921.                     }
  2922.                 }
  2923.             }
  2924.             if (this[XmlILOptimization.AnnotatePreceding]) {
  2925.                 if (AllowReplace(XmlILOptimization.AnnotatePreceding, local0)) {
  2926.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2927.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2928.                 }
  2929.             }
  2930.             return NoReplace(local0);
  2931.         }
  2932.        
  2933.         protected override QilNode VisitFollowingSibling(QilUnary local0)
  2934.         {
  2935.             QilNode local1 = local0[0];
  2936.             if (this[XmlILOptimization.FoldNone]) {
  2937.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2938.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2939.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2940.                     }
  2941.                 }
  2942.             }
  2943.             if (this[XmlILOptimization.AnnotateFollowingSibling]) {
  2944.                 if (AllowReplace(XmlILOptimization.AnnotateFollowingSibling, local0)) {
  2945.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2946.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2947.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  2948.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SameDepth);
  2949.                 }
  2950.             }
  2951.             return NoReplace(local0);
  2952.         }
  2953.        
  2954.         protected override QilNode VisitPrecedingSibling(QilUnary local0)
  2955.         {
  2956.             QilNode local1 = local0[0];
  2957.             if (this[XmlILOptimization.FoldNone]) {
  2958.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2959.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2960.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2961.                     }
  2962.                 }
  2963.             }
  2964.             if (this[XmlILOptimization.AnnotatePrecedingSibling]) {
  2965.                 if (AllowReplace(XmlILOptimization.AnnotatePrecedingSibling, local0)) {
  2966.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2967.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2968.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SameDepth);
  2969.                 }
  2970.             }
  2971.             return NoReplace(local0);
  2972.         }
  2973.        
  2974.         protected override QilNode VisitNodeRange(QilBinary local0)
  2975.         {
  2976.             QilNode local1 = local0[0];
  2977.             QilNode local2 = local0[1];
  2978.             if (this[XmlILOptimization.FoldNone]) {
  2979.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  2980.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2981.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  2982.                     }
  2983.                 }
  2984.             }
  2985.             if (this[XmlILOptimization.FoldNone]) {
  2986.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  2987.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  2988.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  2989.                     }
  2990.                 }
  2991.             }
  2992.             if (this[XmlILOptimization.AnnotateNodeRange]) {
  2993.                 if (AllowReplace(XmlILOptimization.AnnotateNodeRange, local0)) {
  2994.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  2995.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  2996.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  2997.                 }
  2998.             }
  2999.             return NoReplace(local0);
  3000.         }
  3001.        
  3002.         protected override QilNode VisitDeref(QilBinary local0)
  3003.         {
  3004.             QilNode local1 = local0[0];
  3005.             QilNode local2 = local0[1];
  3006.             if (this[XmlILOptimization.FoldNone]) {
  3007.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3008.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3009.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3010.                     }
  3011.                 }
  3012.             }
  3013.             if (this[XmlILOptimization.FoldNone]) {
  3014.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  3015.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3016.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  3017.                     }
  3018.                 }
  3019.             }
  3020.             return NoReplace(local0);
  3021.         }
  3022.        
  3023.         #endregion // XML navigation
  3024.        
  3025.         #region XML construction
  3026.         protected override QilNode VisitElementCtor(QilBinary local0)
  3027.         {
  3028.             QilNode local1 = local0[0];
  3029.             QilNode local2 = local0[1];
  3030.             if (this[XmlILOptimization.FoldNone]) {
  3031.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3032.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3033.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3034.                     }
  3035.                 }
  3036.             }
  3037.             if (this[XmlILOptimization.FoldNone]) {
  3038.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  3039.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3040.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  3041.                     }
  3042.                 }
  3043.             }
  3044.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3045.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3046.                    
  3047.                     // The analysis occasionally makes small changes to the content of constructors, which is
  3048.                     // why the result of Analyze is assigned to $ctor.Right.
  3049.                     local0.Right = this.elemAnalyzer.Analyze(local0, local2);
  3050.                 }
  3051.             }
  3052.             return NoReplace(local0);
  3053.         }
  3054.        
  3055.         protected override QilNode VisitAttributeCtor(QilBinary local0)
  3056.         {
  3057.             QilNode local1 = local0[0];
  3058.             QilNode local2 = local0[1];
  3059.             if (this[XmlILOptimization.FoldNone]) {
  3060.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3061.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3062.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3063.                     }
  3064.                 }
  3065.             }
  3066.             if (this[XmlILOptimization.FoldNone]) {
  3067.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  3068.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3069.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  3070.                     }
  3071.                 }
  3072.             }
  3073.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3074.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3075.                    
  3076.                     local0.Right = this.contentAnalyzer.Analyze(local0, local2);
  3077.                 }
  3078.             }
  3079.             return NoReplace(local0);
  3080.         }
  3081.        
  3082.         protected override QilNode VisitCommentCtor(QilUnary local0)
  3083.         {
  3084.             QilNode local1 = local0[0];
  3085.             if (this[XmlILOptimization.FoldNone]) {
  3086.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3087.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3088.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3089.                     }
  3090.                 }
  3091.             }
  3092.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3093.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3094.                    
  3095.                     local0.Child = this.contentAnalyzer.Analyze(local0, local1);
  3096.                 }
  3097.             }
  3098.             return NoReplace(local0);
  3099.         }
  3100.        
  3101.         protected override QilNode VisitPICtor(QilBinary local0)
  3102.         {
  3103.             QilNode local1 = local0[0];
  3104.             QilNode local2 = local0[1];
  3105.             if (this[XmlILOptimization.FoldNone]) {
  3106.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3107.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3108.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3109.                     }
  3110.                 }
  3111.             }
  3112.             if (this[XmlILOptimization.FoldNone]) {
  3113.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  3114.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3115.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  3116.                     }
  3117.                 }
  3118.             }
  3119.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3120.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3121.                    
  3122.                     local0.Right = this.contentAnalyzer.Analyze(local0, local2);
  3123.                 }
  3124.             }
  3125.             return NoReplace(local0);
  3126.         }
  3127.        
  3128.         protected override QilNode VisitTextCtor(QilUnary local0)
  3129.         {
  3130.             QilNode local1 = local0[0];
  3131.             if (this[XmlILOptimization.FoldNone]) {
  3132.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3133.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3134.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3135.                     }
  3136.                 }
  3137.             }
  3138.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3139.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3140.                    
  3141.                     this.contentAnalyzer.Analyze(local0, null);
  3142.                 }
  3143.             }
  3144.             return NoReplace(local0);
  3145.         }
  3146.        
  3147.         protected override QilNode VisitRawTextCtor(QilUnary local0)
  3148.         {
  3149.             QilNode local1 = local0[0];
  3150.             if (this[XmlILOptimization.FoldNone]) {
  3151.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3152.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3153.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3154.                     }
  3155.                 }
  3156.             }
  3157.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3158.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3159.                    
  3160.                     this.contentAnalyzer.Analyze(local0, null);
  3161.                 }
  3162.             }
  3163.             return NoReplace(local0);
  3164.         }
  3165.        
  3166.         protected override QilNode VisitDocumentCtor(QilUnary local0)
  3167.         {
  3168.             QilNode local1 = local0[0];
  3169.             if (this[XmlILOptimization.FoldNone]) {
  3170.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3171.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3172.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3173.                     }
  3174.                 }
  3175.             }
  3176.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3177.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3178.                    
  3179.                     local0.Child = this.contentAnalyzer.Analyze(local0, local1);
  3180.                 }
  3181.             }
  3182.             return NoReplace(local0);
  3183.         }
  3184.        
  3185.         protected override QilNode VisitNamespaceDecl(QilBinary local0)
  3186.         {
  3187.             QilNode local1 = local0[0];
  3188.             QilNode local2 = local0[1];
  3189.             if (this[XmlILOptimization.FoldNone]) {
  3190.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3191.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3192.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3193.                     }
  3194.                 }
  3195.             }
  3196.             if (this[XmlILOptimization.FoldNone]) {
  3197.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  3198.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3199.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  3200.                     }
  3201.                 }
  3202.             }
  3203.             if ((XmlILConstructInfo.Read(local0).IsNamespaceInScope) && (this[XmlILOptimization.EliminateNamespaceDecl])) {
  3204.                 if (AllowReplace(XmlILOptimization.EliminateNamespaceDecl, local0)) {
  3205.                     return Replace(XmlILOptimization.EliminateNamespaceDecl, local0, VisitSequence(f.Sequence()));
  3206.                 }
  3207.             }
  3208.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3209.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3210.                    
  3211.                     this.contentAnalyzer.Analyze(local0, null);
  3212.                 }
  3213.             }
  3214.             return NoReplace(local0);
  3215.         }
  3216.        
  3217.         protected override QilNode VisitRtfCtor(QilBinary local0)
  3218.         {
  3219.             QilNode local1 = local0[0];
  3220.             QilNode local2 = local0[1];
  3221.             if (this[XmlILOptimization.FoldNone]) {
  3222.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3223.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3224.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3225.                     }
  3226.                 }
  3227.             }
  3228.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3229.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3230.                    
  3231.                     local0.Left = this.contentAnalyzer.Analyze(local0, local1);
  3232.                 }
  3233.             }
  3234.             if (this[XmlILOptimization.AnnotateSingleTextRtf]) {
  3235.                 if (local1.NodeType == QilNodeType.TextCtor) {
  3236.                     QilNode local3 = local1[0];
  3237.                     if (AllowReplace(XmlILOptimization.AnnotateSingleTextRtf, local0)) {
  3238.                         OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SingleTextRtf);
  3239.                         OptimizerPatterns.Write((QilNode)(local0)).AddArgument(OptimizerPatternArgument.RtfText, local3);
  3240.                         // In this case, Rtf will be pushed onto the stack rather than pushed to the writer
  3241.                         XmlILConstructInfo.Write(local0).PullFromIteratorFirst = true;
  3242.                     }
  3243.                 }
  3244.             }
  3245.             return NoReplace(local0);
  3246.         }
  3247.        
  3248.         #endregion // XML construction
  3249.        
  3250.         #region Node properties
  3251.         protected override QilNode VisitNameOf(QilUnary local0)
  3252.         {
  3253.             QilNode local1 = local0[0];
  3254.             if (this[XmlILOptimization.FoldNone]) {
  3255.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3256.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3257.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3258.                     }
  3259.                 }
  3260.             }
  3261.             return NoReplace(local0);
  3262.         }
  3263.        
  3264.         protected override QilNode VisitLocalNameOf(QilUnary local0)
  3265.         {
  3266.             QilNode local1 = local0[0];
  3267.             if (this[XmlILOptimization.FoldNone]) {
  3268.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3269.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3270.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3271.                     }
  3272.                 }
  3273.             }
  3274.             return NoReplace(local0);
  3275.         }
  3276.        
  3277.         protected override QilNode VisitNamespaceUriOf(QilUnary local0)
  3278.         {
  3279.             QilNode local1 = local0[0];
  3280.             if (this[XmlILOptimization.FoldNone]) {
  3281.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3282.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3283.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3284.                     }
  3285.                 }
  3286.             }
  3287.             return NoReplace(local0);
  3288.         }
  3289.        
  3290.         protected override QilNode VisitPrefixOf(QilUnary local0)
  3291.         {
  3292.             QilNode local1 = local0[0];
  3293.             if (this[XmlILOptimization.FoldNone]) {
  3294.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3295.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3296.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3297.                     }
  3298.                 }
  3299.             }
  3300.             return NoReplace(local0);
  3301.         }
  3302.        
  3303.         #endregion // Node properties
  3304.        
  3305.         #region Type operators
  3306.         protected override QilNode VisitTypeAssert(QilTargetType local0)
  3307.         {
  3308.             QilNode local1 = local0[0];
  3309.             QilNode local2 = local0[1];
  3310.             if (this[XmlILOptimization.FoldNone]) {
  3311.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3312.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3313.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3314.                     }
  3315.                 }
  3316.             }
  3317.             if (this[XmlILOptimization.EliminateTypeAssert]) {
  3318.                 if (local2.NodeType == QilNodeType.LiteralType) {
  3319.                     XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value;
  3320.                     if ((local1).XmlType.NeverSubtypeOf(local3)) {
  3321.                         if (AllowReplace(XmlILOptimization.EliminateTypeAssert, local0)) {
  3322.                             return Replace(XmlILOptimization.EliminateTypeAssert, local0, VisitError(f.Error(VisitLiteralString(f.LiteralString("")))));
  3323.                         }
  3324.                     }
  3325.                 }
  3326.             }
  3327.             if (this[XmlILOptimization.EliminateTypeAssert]) {
  3328.                 if (local2.NodeType == QilNodeType.LiteralType) {
  3329.                     XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value;
  3330.                     if ((local1).XmlType.Prime.NeverSubtypeOf(local3.Prime)) {
  3331.                         if (AllowReplace(XmlILOptimization.EliminateTypeAssert, local0)) {
  3332.                             return Replace(XmlILOptimization.EliminateTypeAssert, local0, VisitConditional(f.Conditional(VisitIsEmpty(f.IsEmpty(local1)), VisitSequence(f.Sequence()), VisitError(f.Error(VisitLiteralString(f.LiteralString("")))))));
  3333.                         }
  3334.                     }
  3335.                 }
  3336.             }
  3337.             if (this[XmlILOptimization.EliminateTypeAssertOptional]) {
  3338.                 if (local2.NodeType == QilNodeType.LiteralType) {
  3339.                     XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value;
  3340.                     if ((local1).XmlType.IsSubtypeOf(local3)) {
  3341.                         if (AllowReplace(XmlILOptimization.EliminateTypeAssertOptional, local0)) {
  3342.                             return Replace(XmlILOptimization.EliminateTypeAssertOptional, local0, local1);
  3343.                         }
  3344.                     }
  3345.                 }
  3346.             }
  3347.             return NoReplace(local0);
  3348.         }
  3349.        
  3350.         protected override QilNode VisitIsType(QilTargetType local0)
  3351.         {
  3352.             QilNode local1 = local0[0];
  3353.             QilNode local2 = local0[1];
  3354.             if (this[XmlILOptimization.FoldNone]) {
  3355.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3356.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3357.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3358.                     }
  3359.                 }
  3360.             }
  3361.             if (this[XmlILOptimization.EliminateIsType]) {
  3362.                 if (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects)) {
  3363.                     if (local2.NodeType == QilNodeType.LiteralType) {
  3364.                         XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value;
  3365.                         if ((local1).XmlType.IsSubtypeOf(local3)) {
  3366.                             if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) {
  3367.                                 return Replace(XmlILOptimization.EliminateIsType, local0, VisitTrue(f.True()));
  3368.                             }
  3369.                         }
  3370.                     }
  3371.                 }
  3372.             }
  3373.             if (this[XmlILOptimization.EliminateIsType]) {
  3374.                 if (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects)) {
  3375.                     if (local2.NodeType == QilNodeType.LiteralType) {
  3376.                         XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value;
  3377.                         if ((local1).XmlType.NeverSubtypeOf(local3)) {
  3378.                             if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) {
  3379.                                 return Replace(XmlILOptimization.EliminateIsType, local0, VisitFalse(f.False()));
  3380.                             }
  3381.                         }
  3382.                     }
  3383.                 }
  3384.             }
  3385.             if (this[XmlILOptimization.EliminateIsType]) {
  3386.                 if (local2.NodeType == QilNodeType.LiteralType) {
  3387.                     XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value;
  3388.                     if ((local1).XmlType.Prime.NeverSubtypeOf(local3.Prime)) {
  3389.                         if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) {
  3390.                             return Replace(XmlILOptimization.EliminateIsType, local0, VisitIsEmpty(f.IsEmpty(local1)));
  3391.                         }
  3392.                     }
  3393.                 }
  3394.             }
  3395.             if (this[XmlILOptimization.EliminateIsType]) {
  3396.                 if (!(!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects))) {
  3397.                     if (local2.NodeType == QilNodeType.LiteralType) {
  3398.                         XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value;
  3399.                         if ((local1).XmlType.IsSubtypeOf(local3)) {
  3400.                             if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) {
  3401.                                 return Replace(XmlILOptimization.EliminateIsType, local0, VisitLoop(f.Loop(VisitLet(f.Let(local1)), VisitTrue(f.True()))));
  3402.                             }
  3403.                         }
  3404.                     }
  3405.                 }
  3406.             }
  3407.             if (this[XmlILOptimization.EliminateIsType]) {
  3408.                 if (!(!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects))) {
  3409.                     if (local2.NodeType == QilNodeType.LiteralType) {
  3410.                         XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value;
  3411.                         if ((local1).XmlType.NeverSubtypeOf(local3)) {
  3412.                             if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) {
  3413.                                 return Replace(XmlILOptimization.EliminateIsType, local0, VisitLoop(f.Loop(VisitLet(f.Let(local1)), VisitFalse(f.False()))));
  3414.                             }
  3415.                         }
  3416.                     }
  3417.                 }
  3418.             }
  3419.             return NoReplace(local0);
  3420.         }
  3421.        
  3422.         protected override QilNode VisitIsEmpty(QilUnary local0)
  3423.         {
  3424.             QilNode local1 = local0[0];
  3425.             if (this[XmlILOptimization.FoldNone]) {
  3426.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3427.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3428.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3429.                     }
  3430.                 }
  3431.             }
  3432.             if (this[XmlILOptimization.EliminateIsEmpty]) {
  3433.                 if (local1.NodeType == QilNodeType.Sequence) {
  3434.                     if ((local1).Count == (0)) {
  3435.                         if (AllowReplace(XmlILOptimization.EliminateIsEmpty, local0)) {
  3436.                             return Replace(XmlILOptimization.EliminateIsEmpty, local0, VisitTrue(f.True()));
  3437.                         }
  3438.                     }
  3439.                 }
  3440.             }
  3441.             if (this[XmlILOptimization.EliminateIsEmpty]) {
  3442.                 if ((!((local1).XmlType).MaybeEmpty) && (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects))) {
  3443.                     if (AllowReplace(XmlILOptimization.EliminateIsEmpty, local0)) {
  3444.                         return Replace(XmlILOptimization.EliminateIsEmpty, local0, VisitFalse(f.False()));
  3445.                     }
  3446.                 }
  3447.             }
  3448.             if (this[XmlILOptimization.EliminateIsEmpty]) {
  3449.                 if (!((local1).XmlType).MaybeEmpty) {
  3450.                     if (AllowReplace(XmlILOptimization.EliminateIsEmpty, local0)) {
  3451.                         return Replace(XmlILOptimization.EliminateIsEmpty, local0, VisitLoop(f.Loop(VisitLet(f.Let(local1)), VisitFalse(f.False()))));
  3452.                     }
  3453.                 }
  3454.             }
  3455.             return NoReplace(local0);
  3456.         }
  3457.        
  3458.         #endregion // Type operators
  3459.        
  3460.         #region XPath operators
  3461.         protected override QilNode VisitXPathNodeValue(QilUnary local0)
  3462.         {
  3463.             QilNode local1 = local0[0];
  3464.             if (this[XmlILOptimization.FoldNone]) {
  3465.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3466.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3467.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3468.                     }
  3469.                 }
  3470.             }
  3471.             return NoReplace(local0);
  3472.         }
  3473.        
  3474.         protected override QilNode VisitXPathFollowing(QilUnary local0)
  3475.         {
  3476.             QilNode local1 = local0[0];
  3477.             if (this[XmlILOptimization.FoldNone]) {
  3478.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3479.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3480.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3481.                     }
  3482.                 }
  3483.             }
  3484.             if (this[XmlILOptimization.AnnotateXPathFollowing]) {
  3485.                 if (AllowReplace(XmlILOptimization.AnnotateXPathFollowing, local0)) {
  3486.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  3487.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  3488.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  3489.                 }
  3490.             }
  3491.             return NoReplace(local0);
  3492.         }
  3493.        
  3494.         protected override QilNode VisitXPathPreceding(QilUnary local0)
  3495.         {
  3496.             QilNode local1 = local0[0];
  3497.             if (this[XmlILOptimization.FoldNone]) {
  3498.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3499.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3500.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3501.                     }
  3502.                 }
  3503.             }
  3504.             if (this[XmlILOptimization.AnnotateXPathPreceding]) {
  3505.                 if (AllowReplace(XmlILOptimization.AnnotateXPathPreceding, local0)) {
  3506.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  3507.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  3508.                 }
  3509.             }
  3510.             return NoReplace(local0);
  3511.         }
  3512.        
  3513.         protected override QilNode VisitXPathNamespace(QilUnary local0)
  3514.         {
  3515.             QilNode local1 = local0[0];
  3516.             if (this[XmlILOptimization.FoldNone]) {
  3517.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3518.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3519.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3520.                     }
  3521.                 }
  3522.             }
  3523.             if (this[XmlILOptimization.AnnotateNamespace]) {
  3524.                 if (AllowReplace(XmlILOptimization.AnnotateNamespace, local0)) {
  3525.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.Axis);
  3526.                     AddStepPattern((QilNode)(local0), (QilNode)(local1));
  3527.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.IsDocOrderDistinct);
  3528.                     OptimizerPatterns.Write((QilNode)(local0)).AddPattern(OptimizerPatternName.SameDepth);
  3529.                 }
  3530.             }
  3531.             return NoReplace(local0);
  3532.         }
  3533.        
  3534.         #endregion // XPath operators
  3535.        
  3536.         #region XSLT
  3537.         protected override QilNode VisitXsltGenerateId(QilUnary local0)
  3538.         {
  3539.             QilNode local1 = local0[0];
  3540.             if (this[XmlILOptimization.FoldNone]) {
  3541.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3542.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3543.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3544.                     }
  3545.                 }
  3546.             }
  3547.             return NoReplace(local0);
  3548.         }
  3549.        
  3550.         protected override QilNode VisitXsltCopy(QilBinary local0)
  3551.         {
  3552.             QilNode local1 = local0[0];
  3553.             QilNode local2 = local0[1];
  3554.             if (this[XmlILOptimization.FoldNone]) {
  3555.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3556.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3557.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3558.                     }
  3559.                 }
  3560.             }
  3561.             if (this[XmlILOptimization.FoldNone]) {
  3562.                 if ((object)((local2).XmlType) == (object)XmlQueryTypeFactory.None) {
  3563.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3564.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local2)));
  3565.                     }
  3566.                 }
  3567.             }
  3568.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3569.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3570.                    
  3571.                     local0.Right = this.contentAnalyzer.Analyze(local0, local2);
  3572.                 }
  3573.             }
  3574.             return NoReplace(local0);
  3575.         }
  3576.        
  3577.         protected override QilNode VisitXsltCopyOf(QilUnary local0)
  3578.         {
  3579.             QilNode local1 = local0[0];
  3580.             if (this[XmlILOptimization.FoldNone]) {
  3581.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3582.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3583.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3584.                     }
  3585.                 }
  3586.             }
  3587.             if (this[XmlILOptimization.AnnotateConstruction]) {
  3588.                 if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
  3589.                    
  3590.                     this.contentAnalyzer.Analyze(local0, null);
  3591.                 }
  3592.             }
  3593.             return NoReplace(local0);
  3594.         }
  3595.        
  3596.         protected override QilNode VisitXsltConvert(QilTargetType local0)
  3597.         {
  3598.             QilNode local1 = local0[0];
  3599.             QilNode local2 = local0[1];
  3600.             if (this[XmlILOptimization.FoldNone]) {
  3601.                 if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) {
  3602.                     if (AllowReplace(XmlILOptimization.FoldNone, local0)) {
  3603.                         return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1)));
  3604.                     }
  3605.                 }
  3606.             }
  3607.             if (this[XmlILOptimization.FoldXsltConvertLiteral]) {
  3608.                 if (IsLiteral((local1))) {
  3609.                     if (local2.NodeType == QilNodeType.LiteralType) {
  3610.                         XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value;
  3611.                         if (CanFoldXsltConvert(local1, local3)) {
  3612.                             if (AllowReplace(XmlILOptimization.FoldXsltConvertLiteral, local0)) {
  3613.                                 return Replace(XmlILOptimization.FoldXsltConvertLiteral, local0, FoldXsltConvert(local1, local3));
  3614.                             }
  3615.                         }
  3616.                     }
  3617.                 }
  3618.             }
  3619.             if (this[XmlILOptimization.EliminateXsltConvert]) {
  3620.                 if (local2.NodeType == QilNodeType.LiteralType) {
  3621.                     XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value;
  3622.                     if (((local1).XmlType) == (local3)) {
  3623.                         if (AllowReplace(XmlILOptimization.EliminateXsltConvert, local0)) {
  3624.                             return Replace(XmlILOptimization.EliminateXsltConvert, local0, local1);
  3625.                         }
  3626.                     }
  3627.                 }
  3628.             }
  3629.             return NoReplace(local0);
  3630.         }
  3631.        
  3632.         #endregion // XSLT
  3633.        
  3634.         #endregion // AUTOGENERATED
  3635.        
  3636.         /// <summary>
  3637.         /// Selectively enable/disable optimizations
  3638.         /// </summary>
  3639.         private bool this[XmlILOptimization ann]
  3640.         {
  3641.             get { return Patterns.IsSet((int)ann); }
  3642.         }
  3643.        
  3644.         private class NodeCounter : QilVisitor
  3645.         {
  3646.             protected QilNode target;
  3647.             protected int cnt;
  3648.            
  3649.             /// <summary>
  3650.             /// Returns number of occurrences of "target" node within the subtree of "expr".
  3651.             /// </summary>
  3652.             public int Count(QilNode expr, QilNode target)
  3653.             {
  3654.                 this.cnt = 0;
  3655.                 this.target = target;
  3656.                 Visit(expr);
  3657.                 return this.cnt;
  3658.             }
  3659.            
  3660.             protected override QilNode Visit(QilNode n)
  3661.             {
  3662.                 if (n == null)
  3663.                     return null;
  3664.                
  3665.                 if (n == this.target)
  3666.                     this.cnt++;
  3667.                
  3668.                 return VisitChildren(n);
  3669.             }
  3670.            
  3671.             protected override QilNode VisitReference(QilNode n)
  3672.             {
  3673.                 if (n == this.target)
  3674.                     this.cnt++;
  3675.                
  3676.                 return n;
  3677.             }
  3678.         }
  3679.        
  3680.         private class NodeFinder : QilVisitor
  3681.         {
  3682.             protected bool result;
  3683.             protected QilNode target, parent;
  3684.            
  3685.             /// <summary>
  3686.             /// Returns true if "target" node exists within the subtree of "expr".
  3687.             /// </summary>
  3688.             public bool Find(QilNode expr, QilNode target)
  3689.             {
  3690.                 this.result = false;
  3691.                 this.target = target;
  3692.                 this.parent = null;
  3693.                 VisitAssumeReference(expr);
  3694.                 return this.result;
  3695.             }
  3696.            
  3697.             /// <summary>
  3698.             /// Recursively visit, searching for target. If/when found, call OnFound() method.
  3699.             /// </summary>
  3700.             protected override QilNode Visit(QilNode expr)
  3701.             {
  3702.                 if (!this.result) {
  3703.                     if (expr == this.target)
  3704.                         this.result = OnFound(expr);
  3705.                    
  3706.                     if (!this.result) {
  3707.                         QilNode parentOld = this.parent;
  3708.                         this.parent = expr;
  3709.                         VisitChildren(expr);
  3710.                         this.parent = parentOld;
  3711.                     }
  3712.                 }
  3713.                
  3714.                 return expr;
  3715.             }
  3716.            
  3717.             /// <summary>
  3718.             /// Determine whether target is a reference.
  3719.             /// </summary>
  3720.             protected override QilNode VisitReference(QilNode expr)
  3721.             {
  3722.                 if (expr == this.target)
  3723.                     this.result = OnFound(expr);
  3724.                
  3725.                 return expr;
  3726.             }
  3727.            
  3728.             /// <summary>
  3729.             /// By default, just return true.
  3730.             /// </summary>
  3731.             protected virtual bool OnFound(QilNode expr)
  3732.             {
  3733.                 return true;
  3734.             }
  3735.         }
  3736.        
  3737.         private class PositionOfFinder : NodeFinder
  3738.         {
  3739.             /// <summary>
  3740.             /// Return true only if parent node type is PositionOf.
  3741.             /// </summary>
  3742.             protected override bool OnFound(QilNode expr)
  3743.             {
  3744.                 return this.parent != null && this.parent.NodeType == QilNodeType.PositionOf;
  3745.             }
  3746.         }
  3747.        
  3748.         private class EqualityIndexVisitor : QilVisitor
  3749.         {
  3750.             protected bool result;
  3751.             protected QilNode ctxt, key;
  3752.            
  3753.             /// <summary>
  3754.             /// Returns true if the subtree of "expr" meets the following requirements:
  3755.             /// 1. Does not contain a reference to "key"
  3756.             /// 2. Every reference to "ctxt" is wrapped by a QilNodeType.Root node
  3757.             /// </summary>
  3758.             public bool Scan(QilNode expr, QilNode ctxt, QilNode key)
  3759.             {
  3760.                 this.result = true;
  3761.                 this.ctxt = ctxt;
  3762.                 this.key = key;
  3763.                 Visit(expr);
  3764.                 return this.result;
  3765.             }
  3766.            
  3767.             /// <summary>
  3768.             /// Recursively visit, looking for references to "key" and "ctxt".
  3769.             /// </summary>
  3770.             protected override QilNode VisitReference(QilNode expr)
  3771.             {
  3772.                 if (this.result) {
  3773.                     if (expr == this.key || expr == this.ctxt) {
  3774.                         this.result = false;
  3775.                         return expr;
  3776.                     }
  3777.                 }
  3778.                 return expr;
  3779.             }
  3780.            
  3781.             /// <summary>
  3782.             /// If Root wraps a reference to "ctxt", then don't visit "ctxt" and continue scan.
  3783.             /// </summary>
  3784.             protected override QilNode VisitRoot(QilUnary root)
  3785.             {
  3786.                 if (root.Child == this.ctxt)
  3787.                     return root;
  3788.                
  3789.                 return VisitChildren(root);
  3790.             }
  3791.         }
  3792.        
  3793.         /// <summary>
  3794.         /// Returns true if any operator within the "expr" subtree references "target".
  3795.         /// </summary>
  3796.         private bool DependsOn(QilNode expr, QilNode target)
  3797.         {
  3798.             return new NodeFinder().Find(expr, target);
  3799.         }
  3800.        
  3801.         /// <summary>
  3802.         /// Returns true if there is no PositionOf operator within the "expr" subtree that references iterator "iter".
  3803.         /// </summary>
  3804.         protected bool NonPositional(QilNode expr, QilNode iter)
  3805.         {
  3806.             return !(new PositionOfFinder().Find(expr, iter));
  3807.         }
  3808.        
  3809.         /// <summary>
  3810.         /// Scans "expr" subtree, looking for "refOld" references and replacing them with "refNew" references.
  3811.         /// </summary>
  3812.         private QilNode Subs(QilNode expr, QilNode refOld, QilNode refNew)
  3813.         {
  3814.             QilNode result;
  3815.            
  3816.             this.subs.AddSubstitutionPair(refOld, refNew);
  3817.             if (expr is QilReference)
  3818.                 result = VisitReference(expr);
  3819.             else
  3820.                 result = Visit(expr);
  3821.             this.subs.RemoveLastSubstitutionPair();
  3822.            
  3823.             return result;
  3824.         }
  3825.        
  3826.         /// <summary>
  3827.         /// True if the specified iterator is a global variable Let iterator.
  3828.         /// </summary>
  3829.         private bool IsGlobalVariable(QilIterator iter)
  3830.         {
  3831.             return this.qil.GlobalVariableList.Contains(iter);
  3832.         }
  3833.        
  3834.         /// <summary>
  3835.         /// Return true if "typ" is xs:decimal=, xs:integer=, xs:int=, xs:double=, or xs:float=.
  3836.         /// </summary>
  3837.         private bool IsPrimitiveNumeric(XmlQueryType typ)
  3838.         {
  3839.             if (typ == XmlQueryTypeFactory.IntX)
  3840.                 return true;
  3841.             if (typ == XmlQueryTypeFactory.IntegerX)
  3842.                 return true;
  3843.             if (typ == XmlQueryTypeFactory.DecimalX)
  3844.                 return true;
  3845.             if (typ == XmlQueryTypeFactory.FloatX)
  3846.                 return true;
  3847.             if (typ == XmlQueryTypeFactory.DoubleX)
  3848.                 return true;
  3849.            
  3850.             return false;
  3851.         }
  3852.        
  3853.         /// <summary>
  3854.         /// Returns true if "typ" matches one of the XPath content node tests: *, text(), comment(), pi(), or node().
  3855.         /// </summary>
  3856.         private bool MatchesContentTest(XmlQueryType typ)
  3857.         {
  3858.             if (typ == XmlQueryTypeFactory.Element)
  3859.                 return true;
  3860.             if (typ == XmlQueryTypeFactory.Text)
  3861.                 return true;
  3862.             if (typ == XmlQueryTypeFactory.Comment)
  3863.                 return true;
  3864.             if (typ == XmlQueryTypeFactory.PI)
  3865.                 return true;
  3866.             if (typ == XmlQueryTypeFactory.Content)
  3867.                 return true;
  3868.            
  3869.             return false;
  3870.         }
  3871.        
  3872.         /// <summary>
  3873.         /// True if the specified expression constructs one or more nodes using QilExpression constructor operators.
  3874.         /// This information is used to determine whether the results of a function should be streamed to a writer
  3875.         /// rather than cached.
  3876.         /// </summary>
  3877.         private bool IsConstructedExpression(QilNode nd)
  3878.         {
  3879.             QilTernary ndCond;
  3880.            
  3881.             // In debug mode, all functions should return void (streamed to writer), so that call stack
  3882.             // consistently shows caller's line number
  3883.             if (this.qil.IsDebug)
  3884.                 return true;
  3885.            
  3886.             if (nd.XmlType.IsNode) {
  3887.                 switch (nd.NodeType) {
  3888.                     case QilNodeType.ElementCtor:
  3889.                     case QilNodeType.AttributeCtor:
  3890.                     case QilNodeType.CommentCtor:
  3891.                     case QilNodeType.PICtor:
  3892.                     case QilNodeType.TextCtor:
  3893.                     case QilNodeType.RawTextCtor:
  3894.                     case QilNodeType.DocumentCtor:
  3895.                     case QilNodeType.NamespaceDecl:
  3896.                     case QilNodeType.XsltCopy:
  3897.                     case QilNodeType.XsltCopyOf:
  3898.                     case QilNodeType.Choice:
  3899.                         return true;
  3900.                     case QilNodeType.Loop:
  3901.                        
  3902.                         // Return true if the return expression is constructed
  3903.                         return IsConstructedExpression(((QilLoop)nd).Body);
  3904.                     case QilNodeType.Sequence:
  3905.                        
  3906.                         // Return true if the list is empty or at least one expression in the list is constructed
  3907.                         if (nd.Count == 0)
  3908.                             return true;
  3909.                        
  3910.                         foreach (QilNode ndItem in nd) {
  3911.                             if (IsConstructedExpression(ndItem))
  3912.                                 return true;
  3913.                         }
  3914.                         break;
  3915.                     case QilNodeType.Conditional:
  3916.                        
  3917.                         // Return true if either left and right branches of the conditional are constructed
  3918.                         ndCond = (QilTernary)nd;
  3919.                         return IsConstructedExpression(ndCond.Center) || IsConstructedExpression(ndCond.Right);
  3920.                     case QilNodeType.Invoke:
  3921.                        
  3922.                         // Return true if the function might return nodes
  3923.                         return !((QilInvoke)nd).Function.XmlType.IsAtomicValue;
  3924.                 }
  3925.             }
  3926.            
  3927.             return false;
  3928.         }
  3929.        
  3930.         /// <summary>
  3931.         /// True if the specified expression is a literal value.
  3932.         /// </summary>
  3933.         private bool IsLiteral(QilNode nd)
  3934.         {
  3935.             switch (nd.NodeType) {
  3936.                 case QilNodeType.True:
  3937.                 case QilNodeType.False:
  3938.                 case QilNodeType.LiteralString:
  3939.                 case QilNodeType.LiteralInt32:
  3940.                 case QilNodeType.LiteralInt64:
  3941.                 case QilNodeType.LiteralDouble:
  3942.                 case QilNodeType.LiteralDecimal:
  3943.                 case QilNodeType.LiteralQName:
  3944.                     return true;
  3945.             }
  3946.             return false;
  3947.         }
  3948.        
  3949.         /// <summary>
  3950.         /// Return true if all children of "nd" are constant.
  3951.         /// </summary>
  3952.         private bool AreLiteralArgs(QilNode nd)
  3953.         {
  3954.             foreach (QilNode child in nd)
  3955.                 if (!IsLiteral(child))
  3956.                     return false;
  3957.            
  3958.             return true;
  3959.         }
  3960.        
  3961.         /// <summary>
  3962.         /// Extract the value of a literal.
  3963.         /// </summary>
  3964.         private object ExtractLiteralValue(QilNode nd)
  3965.         {
  3966.             if (nd.NodeType == QilNodeType.True)
  3967.                 return true;
  3968.             else if (nd.NodeType == QilNodeType.False)
  3969.                 return false;
  3970.             else if (nd.NodeType == QilNodeType.LiteralQName)
  3971.                 return nd;
  3972.            
  3973.             Debug.Assert(nd is QilLiteral, "All literals except True, False, and QName must use QilLiteral");
  3974.             return ((QilLiteral)nd).Value;
  3975.         }
  3976.        
  3977.         /// <summary>
  3978.         /// Return true if "nd" has a child of type Sequence.
  3979.         /// </summary>
  3980.         private bool HasNestedSequence(QilNode nd)
  3981.         {
  3982.             foreach (QilNode child in nd) {
  3983.                 if (child.NodeType == QilNodeType.Sequence)
  3984.                     return true;
  3985.             }
  3986.             return false;
  3987.         }
  3988.        
  3989.         /// <summary>
  3990.         /// True if the JoinAndDod pattern is allowed to match the specified node.
  3991.         /// </summary>
  3992.         private bool AllowJoinAndDod(QilNode nd)
  3993.         {
  3994.             OptimizerPatterns patt = OptimizerPatterns.Read(nd);
  3995.            
  3996.             // AllowJoinAndDod if this pattern is the descendant, descendant-or-self, content, preceding, following, or
  3997.             // following-sibling axis, filtered by either an element name or a node kind test.
  3998.             if (patt.MatchesPattern(OptimizerPatternName.FilterElements) || patt.MatchesPattern(OptimizerPatternName.FilterContentKind)) {
  3999.                 if (IsStepPattern(patt, QilNodeType.DescendantOrSelf) || IsStepPattern(patt, QilNodeType.Descendant) || IsStepPattern(patt, QilNodeType.Content) || IsStepPattern(patt, QilNodeType.XPathPreceding) || IsStepPattern(patt, QilNodeType.XPathFollowing) || IsStepPattern(patt, QilNodeType.FollowingSibling)) {
  4000.                     return true;
  4001.                 }
  4002.             }
  4003.             return false;
  4004.         }
  4005.        
  4006.         /// <summary>
  4007.         /// True if the DodReverse pattern is allowed to match the specified node.
  4008.         /// </summary>
  4009.         private bool AllowDodReverse(QilNode nd)
  4010.         {
  4011.             OptimizerPatterns patt = OptimizerPatterns.Read(nd);
  4012.            
  4013.             // AllowDodReverse if this pattern is the ancestor, ancestor-or-self, preceding, or preceding-sibling axis,
  4014.             // filtered by either an element name or a node kind test.
  4015.             if (patt.MatchesPattern(OptimizerPatternName.Axis) || patt.MatchesPattern(OptimizerPatternName.FilterElements) || patt.MatchesPattern(OptimizerPatternName.FilterContentKind)) {
  4016.                 if (IsStepPattern(patt, QilNodeType.Ancestor) || IsStepPattern(patt, QilNodeType.AncestorOrSelf) || IsStepPattern(patt, QilNodeType.XPathPreceding) || IsStepPattern(patt, QilNodeType.PrecedingSibling)) {
  4017.                     return true;
  4018.                 }
  4019.             }
  4020.             return false;
  4021.         }
  4022.        
  4023.         /// <summary>
  4024.         /// Return true if XsltConvert applied to a Literal can be folded (i.e. the XsltConvert eliminated).
  4025.         /// </summary>
  4026.         private bool CanFoldXsltConvert(QilNode ndLiteral, XmlQueryType typTarget)
  4027.         {
  4028.             // Attempt to fold--on failure, an unfolded XsltConvert node will be returned
  4029.             return FoldXsltConvert(ndLiteral, typTarget).NodeType != QilNodeType.XsltConvert;
  4030.         }
  4031.        
  4032.         /// <summary>
  4033.         /// Return true if XsltConvert applied to a Literal can be folded (i.e. the XsltConvert eliminated), without
  4034.         /// any loss of information.
  4035.         /// </summary>
  4036.         private bool CanFoldXsltConvertNonLossy(QilNode ndLiteral, XmlQueryType typTarget)
  4037.         {
  4038.             QilNode ndDest;
  4039.            
  4040.             // Fold conversion to target type; if conversion cannot be folded, a XsltConvert node is returned
  4041.             ndDest = FoldXsltConvert(ndLiteral, typTarget);
  4042.             if (ndDest.NodeType == QilNodeType.XsltConvert)
  4043.                 return false;
  4044.            
  4045.             // Convert back to source type; if conversion cannot be folded, a XsltConvert node is returned
  4046.             ndDest = FoldXsltConvert(ndDest, ndLiteral.XmlType);
  4047.             if (ndDest.NodeType == QilNodeType.XsltConvert)
  4048.                 return false;
  4049.            
  4050.             // If original value is the same as the round-tripped value, then conversion is non-lossy
  4051.             return ExtractLiteralValue(ndLiteral).Equals(ExtractLiteralValue(ndDest));
  4052.         }
  4053.        
  4054.         /// <summary>
  4055.         /// Fold a XsltConvert applied to a Literal into another Literal. If the fold results in some kind of
  4056.         /// conversion error, or if the QilExpression cannot represent the result as a Literal, return an unfolded
  4057.         /// XsltConvert expression.
  4058.         /// </summary>
  4059.         private QilNode FoldXsltConvert(QilNode ndLiteral, XmlQueryType typTarget)
  4060.         {
  4061.             try {
  4062.                 if (typTarget.IsAtomicValue) {
  4063.                     // Convert the literal to an XmlAtomicValue
  4064.                     XmlAtomicValue value = new XmlAtomicValue(ndLiteral.XmlType.SchemaType, ExtractLiteralValue(ndLiteral));
  4065.                     value = XsltConvert.ConvertToType(value, typTarget);
  4066.                    
  4067.                     if (typTarget == TypeFactory.StringX)
  4068.                         return this.f.LiteralString(value.Value);
  4069.                     else if (typTarget == TypeFactory.IntX)
  4070.                         return this.f.LiteralInt32(value.ValueAsInt);
  4071.                     else if (typTarget == TypeFactory.IntegerX)
  4072.                         return this.f.LiteralInt64(value.ValueAsLong);
  4073.                     else if (typTarget == TypeFactory.DecimalX)
  4074.                         return this.f.LiteralDecimal((decimal)value.ValueAs(XsltConvert.DecimalType));
  4075.                     else if (typTarget == TypeFactory.DoubleX)
  4076.                         return this.f.LiteralDouble(value.ValueAsDouble);
  4077.                     else if (typTarget == TypeFactory.BooleanX)
  4078.                         return value.ValueAsBoolean ? this.f.True() : this.f.False();
  4079.                 }
  4080.             }
  4081.             catch (OverflowException) {
  4082.             }
  4083.             catch (FormatException) {
  4084.             }
  4085.            
  4086.             // Conversion error or QilExpression cannot represent resulting literal
  4087.             return this.f.XsltConvert(ndLiteral, typTarget);
  4088.         }
  4089.        
  4090.         /// <summary>
  4091.         /// Compute the arithmetic operation "opType" over two literal operands and return the result as a QilLiteral.
  4092.         /// In the case of an overflow or divide by zero exception, return the unfolded result.
  4093.         /// </summary>
  4094.         private QilNode FoldComparison(QilNodeType opType, QilNode left, QilNode right)
  4095.         {
  4096.             object litLeft;
  4097.             object litRight;
  4098.             int cmp;
  4099.             Debug.Assert(left.XmlType == right.XmlType, "Comparison is not defined between " + left.XmlType + " and " + right.XmlType);
  4100.            
  4101.             // Extract objects that represent each literal value
  4102.             litLeft = ExtractLiteralValue(left);
  4103.             litRight = ExtractLiteralValue(right);
  4104.            
  4105.             if (left.NodeType == QilNodeType.LiteralDouble) {
  4106.                 // Equals and CompareTo do not handle NaN correctly
  4107.                 if (Double.IsNaN((double)litLeft) || Double.IsNaN((double)litRight))
  4108.                     return (opType == QilNodeType.Ne) ? f.True() : f.False();
  4109.             }
  4110.            
  4111.             if (opType == QilNodeType.Eq)
  4112.                 return litLeft.Equals(litRight) ? f.True() : f.False();
  4113.            
  4114.             if (opType == QilNodeType.Ne)
  4115.                 return litLeft.Equals(litRight) ? f.False() : f.True();
  4116.            
  4117.             if (left.NodeType == QilNodeType.LiteralString) {
  4118.                 // CompareTo does not use Ordinal comparison
  4119.                 cmp = string.CompareOrdinal((string)litLeft, (string)litRight);
  4120.             }
  4121.             else {
  4122.                 cmp = ((IComparable)litLeft).CompareTo(litRight);
  4123.             }
  4124.            
  4125.             switch (opType) {
  4126.                 case QilNodeType.Gt:
  4127.                     return cmp > 0 ? f.True() : f.False();
  4128.                 case QilNodeType.Ge:
  4129.                     return cmp >= 0 ? f.True() : f.False();
  4130.                 case QilNodeType.Lt:
  4131.                     return cmp < 0 ? f.True() : f.False();
  4132.                 case QilNodeType.Le:
  4133.                     return cmp <= 0 ? f.True() : f.False();
  4134.             }
  4135.            
  4136.             Debug.Assert(false, "Cannot fold this comparison operation: " + opType);
  4137.             return null;
  4138.         }
  4139.        
  4140.         /// <summary>
  4141.         /// Return true if arithmetic operation "opType" can be computed over two literal operands without causing
  4142.         /// an overflow or divide by zero exception.
  4143.         /// </summary>
  4144.         private bool CanFoldArithmetic(QilNodeType opType, QilLiteral left, QilLiteral right)
  4145.         {
  4146.             return (FoldArithmetic(opType, left, right) is QilLiteral);
  4147.         }
  4148.        
  4149.         /// <summary>
  4150.         /// Compute the arithmetic operation "opType" over two literal operands and return the result as a QilLiteral.
  4151.         /// Arithmetic operations are always checked; in the case of an overflow or divide by zero exception, return
  4152.         /// the unfolded result.
  4153.         /// </summary>
  4154.         private QilNode FoldArithmetic(QilNodeType opType, QilLiteral left, QilLiteral right)
  4155.         {
  4156.             Debug.Assert(left.NodeType == right.NodeType);
  4157.            
  4158.             // Catch any overflow or divide by zero exceptions
  4159.             try {
  4160.                 checked {
  4161.                     switch (left.NodeType) {
  4162.                         case QilNodeType.LiteralInt32:
  4163.                            
  4164.                             {
  4165.                                 int intLeft = left;
  4166.                                 int intRight = right;
  4167.                                
  4168.                                 switch (opType) {
  4169.                                     case QilNodeType.Add:
  4170.                                         return f.LiteralInt32(intLeft + intRight);
  4171.                                     case QilNodeType.Subtract:
  4172.                                         return f.LiteralInt32(intLeft - intRight);
  4173.                                     case QilNodeType.Multiply:
  4174.                                         return f.LiteralInt32(intLeft * intRight);
  4175.                                     case QilNodeType.Divide:
  4176.                                         return f.LiteralInt32(intLeft / intRight);
  4177.                                     case QilNodeType.Modulo:
  4178.                                         return f.LiteralInt32(intLeft % intRight);
  4179.                                 }
  4180.                                 break;
  4181.                             }
  4182.                             break;
  4183.                         case QilNodeType.LiteralInt64:
  4184.                            
  4185.                            
  4186.                             {
  4187.                                 long lngLeft = left;
  4188.                                 long lngRight = right;
  4189.                                
  4190.                                 switch (opType) {
  4191.                                     case QilNodeType.Add:
  4192.                                         return f.LiteralInt64(lngLeft + lngRight);
  4193.                                     case QilNodeType.Subtract:
  4194.                                         return f.LiteralInt64(lngLeft - lngRight);
  4195.                                     case QilNodeType.Multiply:
  4196.                                         return f.LiteralInt64(lngLeft * lngRight);
  4197.                                     case QilNodeType.Divide:
  4198.                                         return f.LiteralInt64(lngLeft / lngRight);
  4199.                                     case QilNodeType.Modulo:
  4200.                                         return f.LiteralInt64(lngLeft % lngRight);
  4201.                                 }
  4202.                                 break;
  4203.                             }
  4204.                             break;
  4205.                         case QilNodeType.LiteralDecimal:
  4206.                            
  4207.                            
  4208.                             {
  4209.                                 decimal lngLeft = left;
  4210.                                 decimal lngRight = right;
  4211.                                
  4212.                                 switch (opType) {
  4213.                                     case QilNodeType.Add:
  4214.                                         return f.LiteralDecimal(lngLeft + lngRight);
  4215.                                     case QilNodeType.Subtract:
  4216.                                         return f.LiteralDecimal(lngLeft - lngRight);
  4217.                                     case QilNodeType.Multiply:
  4218.                                         return f.LiteralDecimal(lngLeft * lngRight);
  4219.                                     case QilNodeType.Divide:
  4220.                                         return f.LiteralDecimal(lngLeft / lngRight);
  4221.                                     case QilNodeType.Modulo:
  4222.                                         return f.LiteralDecimal(lngLeft % lngRight);
  4223.                                 }
  4224.                                 break;
  4225.                             }
  4226.                             break;
  4227.                         case QilNodeType.LiteralDouble:
  4228.                            
  4229.                            
  4230.                             {
  4231.                                 double lngLeft = left;
  4232.                                 double lngRight = right;
  4233.                                
  4234.                                 switch (opType) {
  4235.                                     case QilNodeType.Add:
  4236.                                         return f.LiteralDouble(lngLeft + lngRight);
  4237.                                     case QilNodeType.Subtract:
  4238.                                         return f.LiteralDouble(lngLeft - lngRight);
  4239.                                     case QilNodeType.Multiply:
  4240.                                         return f.LiteralDouble(lngLeft * lngRight);
  4241.                                     case QilNodeType.Divide:
  4242.                                         return f.LiteralDouble(lngLeft / lngRight);
  4243.                                     case QilNodeType.Modulo:
  4244.                                         return f.LiteralDouble(lngLeft % lngRight);
  4245.                                 }
  4246.                                 break;
  4247.                             }
  4248.                             break;
  4249.                     }
  4250.                 }
  4251.             }
  4252.             catch (OverflowException) {
  4253.             }
  4254.             catch (DivideByZeroException) {
  4255.             }
  4256.            
  4257.             // An error occurred, so don't fold operationo
  4258.             switch (opType) {
  4259.                 case QilNodeType.Add:
  4260.                     return f.Add(left, right);
  4261.                 case QilNodeType.Subtract:
  4262.                     return f.Subtract(left, right);
  4263.                 case QilNodeType.Multiply:
  4264.                     return f.Multiply(left, right);
  4265.                 case QilNodeType.Divide:
  4266.                     return f.Divide(left, right);
  4267.                 case QilNodeType.Modulo:
  4268.                     return f.Modulo(left, right);
  4269.             }
  4270.            
  4271.             Debug.Assert(false, "Cannot fold this arithmetic operation: " + opType);
  4272.             return null;
  4273.         }
  4274.        
  4275.         /// <summary>
  4276.         /// Mark the specified node as matching the Step pattern and set the step node and step input arguments.
  4277.         /// </summary>
  4278.         private void AddStepPattern(QilNode nd, QilNode input)
  4279.         {
  4280.             OptimizerPatterns patt = OptimizerPatterns.Write(nd);
  4281.             patt.AddPattern(OptimizerPatternName.Step);
  4282.             patt.AddArgument(OptimizerPatternArgument.StepNode, nd);
  4283.             patt.AddArgument(OptimizerPatternArgument.StepInput, input);
  4284.         }
  4285.        
  4286.         /// <summary>
  4287.         /// Return true if "nd" matches the Step pattern and the StepType argument is equal to "stepType".
  4288.         /// </summary>
  4289.         private bool IsDocOrderDistinct(QilNode nd)
  4290.         {
  4291.             return OptimizerPatterns.Read(nd).MatchesPattern(OptimizerPatternName.IsDocOrderDistinct);
  4292.         }
  4293.        
  4294.         /// <summary>
  4295.         /// Return true if "nd" matches the Step pattern and the StepType argument is equal to "stepType".
  4296.         /// </summary>
  4297.         private bool IsStepPattern(QilNode nd, QilNodeType stepType)
  4298.         {
  4299.             return IsStepPattern(OptimizerPatterns.Read(nd), stepType);
  4300.         }
  4301.        
  4302.         /// <summary>
  4303.         /// Return true if "patt" matches the Step pattern and the StepType argument is equal to "stepType".
  4304.         /// </summary>
  4305.         private bool IsStepPattern(OptimizerPatterns patt, QilNodeType stepType)
  4306.         {
  4307.             return patt.MatchesPattern(OptimizerPatternName.Step) && ((QilNode)patt.GetArgument(OptimizerPatternArgument.StepNode)).NodeType == stepType;
  4308.         }
  4309.     }
  4310. }

Developer Fusion