public QilTargetType XsltConvert(QilNode source, QilNode targetType) { QilTargetType n = new QilTargetType(QilNodeType.XsltConvert, source, targetType); n.XmlType = _typeCheck.CheckXsltConvert(n); TraceNode(n); return(n); }
//----------------------------------------------- // Type operators //----------------------------------------------- public QilTargetType TypeAssert(QilNode source, QilNode targetType) { QilTargetType n = new QilTargetType(QilNodeType.TypeAssert, source, targetType); n.XmlType = this.typeCheck.CheckTypeAssert(n); TraceNode(n); return(n); }
public QilTargetType IsType(QilNode source, QilNode targetType) { QilTargetType n = new QilTargetType(QilNodeType.IsType, source, targetType); n.XmlType = _typeCheck.CheckIsType(n); TraceNode(n); return(n); }
protected override QilNode VisitXsltConvert(QilTargetType n) { return(NoReplace(n)); }
protected override QilNode VisitIsType(QilTargetType n) { return(NoReplace(n)); }
protected override QilNode VisitTypeAssert(QilTargetType local0) { QilNode local1 = local0[0]; QilNode local2 = local0[1]; if (this[XmlILOptimization.FoldNone]) { if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) { // PATTERN: [FoldNone] (TypeAssert $x:* ^ (None? (TypeOf $x)) *) => (Nop $x) if (AllowReplace(XmlILOptimization.FoldNone, local0)) { return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1))); } } } if (this[XmlILOptimization.EliminateTypeAssert]) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ((local1).XmlType.NeverSubtypeOf(local3)) { // PATTERN: [EliminateTypeAssert] (TypeAssert $opnd:* (LiteralType $typ:*) ^ (NeverSubtypeOf? (TypeOf $opnd) $typ)) => (Error (LiteralString "")) if (AllowReplace(XmlILOptimization.EliminateTypeAssert, local0)) { return Replace(XmlILOptimization.EliminateTypeAssert, local0, VisitError(f.Error(VisitLiteralString(f.LiteralString(string.Empty))))); } } } } if (this[XmlILOptimization.EliminateTypeAssert]) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ((local1).XmlType.Prime.NeverSubtypeOf(local3.Prime)) { // PATTERN: [EliminateTypeAssert] (TypeAssert $opnd:* (LiteralType $typ:*) ^ (NeverSubtypeOf? (Prime (TypeOf $opnd)) (Prime $typ))) => (Conditional (IsEmpty $opnd) (Sequence) (Error (LiteralString ""))) if (AllowReplace(XmlILOptimization.EliminateTypeAssert, local0)) { return Replace(XmlILOptimization.EliminateTypeAssert, local0, VisitConditional(f.Conditional(VisitIsEmpty(f.IsEmpty(local1)), VisitSequence(f.Sequence()), VisitError(f.Error(VisitLiteralString(f.LiteralString(string.Empty))))))); } } } } if (this[XmlILOptimization.EliminateTypeAssertOptional]) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ((local1).XmlType.IsSubtypeOf(local3)) { // PATTERN: [EliminateTypeAssertOptional] (TypeAssert $opnd:* (LiteralType $base:*) ^ (SubtypeOf? (TypeOf $opnd) $base)) => $opnd if (AllowReplace(XmlILOptimization.EliminateTypeAssertOptional, local0)) { return Replace(XmlILOptimization.EliminateTypeAssertOptional, local0, local1); } } } } return NoReplace(local0); }
protected virtual QilNode VisitIsType(QilTargetType n) { return(VisitChildren(n)); }
public XmlQueryType CheckIsType(QilTargetType node) { CheckClassAndNodeType(node[1], typeof(QilLiteral), QilNodeType.LiteralType); return(XmlQueryTypeFactory.BooleanX); }
public XmlQueryType CheckIsType(QilTargetType node) { CheckClassAndNodeType(node[1], typeof(QilLiteral), QilNodeType.LiteralType); return XmlQueryTypeFactory.BooleanX; }
protected override QilNode VisitXsltConvert(QilTargetType local0) { QilNode local1 = local0[0]; QilNode local2 = local0[1]; if (this[XmlILOptimization.FoldNone]) { if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) { // PATTERN: [FoldNone] (XsltConvert $x:* ^ (None? (TypeOf $x)) *) => (Nop $x) if (AllowReplace(XmlILOptimization.FoldNone, local0)) { return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1))); } } } if (this[XmlILOptimization.FoldXsltConvertLiteral]) { if (IsLiteral((local1))) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if (CanFoldXsltConvert(local1, local3)) { // PATTERN: [FoldXsltConvertLiteral] (XsltConvert $lit:* ^ (Literal? $lit) (LiteralType $typ:*) ^ (CanFoldXsltConvert? $lit $typ)) => (FoldXsltConvert $lit $typ) if (AllowReplace(XmlILOptimization.FoldXsltConvertLiteral, local0)) { return Replace(XmlILOptimization.FoldXsltConvertLiteral, local0, FoldXsltConvert(local1, local3)); } } } } } if (this[XmlILOptimization.EliminateXsltConvert]) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if (((local1).XmlType) == (local3)) { // PATTERN: [EliminateXsltConvert] (XsltConvert $expr:* (LiteralType $typ:*) ^ (Equal? (TypeOf $expr) $typ)) => $expr if (AllowReplace(XmlILOptimization.EliminateXsltConvert, local0)) { return Replace(XmlILOptimization.EliminateXsltConvert, local0, local1); } } } } return NoReplace(local0); }
protected override QilNode VisitIsType(QilTargetType n) { return NoReplace(n); }
/// <summary> /// Generate code for QilNodeType.XsltConvert. /// </summary> protected override QilNode VisitXsltConvert(QilTargetType ndConv) { XmlQueryType typSrc, typDst; MethodInfo meth; typSrc = ndConv.Source.XmlType; typDst = ndConv.TargetType; if (GetXsltConvertMethod(typSrc, typDst, out meth)) { NestedVisitEnsureStack(ndConv.Source); } else { // If a conversion could not be found, then convert the source expression to item or item* and try again NestedVisitEnsureStack(ndConv.Source, typeof(XPathItem), !typSrc.IsSingleton); if (!GetXsltConvertMethod(typSrc.IsSingleton ? TypeFactory.Item : TypeFactory.ItemS, typDst, out meth)) Debug.Fail("Conversion from " + ndConv.Source.XmlType + " to " + ndConv.TargetType + " is not supported."); } // XsltConvert.XXXToYYY(value); if (meth != null) _helper.Call(meth); _iterCurr.Storage = StorageDescriptor.Stack(GetItemStorageType(typDst), !typDst.IsSingleton); return ndConv; }
/// <summary> /// Faster code can be generated if type test is just a node kind test. If this special case is detected, then generate code and return true. /// Otherwise, return false, and a call to MatchesXmlType will be generated instead. /// </summary> private bool MatchesNodeKinds(QilTargetType ndIsType, XmlQueryType typDerived, XmlQueryType typBase) { XmlNodeKindFlags kinds; bool allowKinds = true; XPathNodeType kindsRuntime; int kindsUnion; // If not checking whether typDerived is some kind of singleton node, then fallback to MatchesXmlType if (!typBase.IsNode || !typBase.IsSingleton) return false; // If typDerived is not statically guaranteed to be a singleton node (and not an rtf), then fallback to MatchesXmlType if (!typDerived.IsNode || !typDerived.IsSingleton || !typDerived.IsNotRtf) return false; // Now we are guaranteed that typDerived is a node, and typBase is a node, so check node kinds // Ensure that typBase is only composed of kind-test prime types (no name-test, no schema-test, etc.) kinds = XmlNodeKindFlags.None; foreach (XmlQueryType typItem in typBase) { if ((object)typItem == (object)TypeFactory.Element) kinds |= XmlNodeKindFlags.Element; else if ((object)typItem == (object)TypeFactory.Attribute) kinds |= XmlNodeKindFlags.Attribute; else if ((object)typItem == (object)TypeFactory.Text) kinds |= XmlNodeKindFlags.Text; else if ((object)typItem == (object)TypeFactory.Document) kinds |= XmlNodeKindFlags.Document; else if ((object)typItem == (object)TypeFactory.Comment) kinds |= XmlNodeKindFlags.Comment; else if ((object)typItem == (object)TypeFactory.PI) kinds |= XmlNodeKindFlags.PI; else if ((object)typItem == (object)TypeFactory.Namespace) kinds |= XmlNodeKindFlags.Namespace; else return false; } Debug.Assert((typDerived.NodeKinds & kinds) != XmlNodeKindFlags.None, "Normalizer should have taken care of case where node kinds are disjoint."); kinds = typDerived.NodeKinds & kinds; // Attempt to allow or disallow exactly one kind if (!Bits.ExactlyOne((uint)kinds)) { // Not possible to allow one kind, so try to disallow one kind kinds = ~kinds & XmlNodeKindFlags.Any; allowKinds = !allowKinds; } switch (kinds) { case XmlNodeKindFlags.Element: kindsRuntime = XPathNodeType.Element; break; case XmlNodeKindFlags.Attribute: kindsRuntime = XPathNodeType.Attribute; break; case XmlNodeKindFlags.Namespace: kindsRuntime = XPathNodeType.Namespace; break; case XmlNodeKindFlags.PI: kindsRuntime = XPathNodeType.ProcessingInstruction; break; case XmlNodeKindFlags.Comment: kindsRuntime = XPathNodeType.Comment; break; case XmlNodeKindFlags.Document: kindsRuntime = XPathNodeType.Root; break; default: // Union of several types (when testing for Text, we need to test for Whitespace as well) // if (((1 << navigator.NodeType) & nodesDisallow) op 0) goto LabelBranch; _helper.Emit(OpCodes.Ldc_I4_1); kindsRuntime = XPathNodeType.All; break; } // Push navigator.NodeType onto the stack NestedVisitEnsureStack(ndIsType.Source); _helper.Call(XmlILMethods.NavType); if (kindsRuntime == XPathNodeType.All) { // if (((1 << navigator.NodeType) & kindsUnion) op 0) goto LabelBranch; _helper.Emit(OpCodes.Shl); kindsUnion = 0; if ((kinds & XmlNodeKindFlags.Document) != 0) kindsUnion |= (1 << (int)XPathNodeType.Root); if ((kinds & XmlNodeKindFlags.Element) != 0) kindsUnion |= (1 << (int)XPathNodeType.Element); if ((kinds & XmlNodeKindFlags.Attribute) != 0) kindsUnion |= (1 << (int)XPathNodeType.Attribute); if ((kinds & XmlNodeKindFlags.Text) != 0) kindsUnion |= (1 << (int)(int)XPathNodeType.Text) | (1 << (int)(int)XPathNodeType.SignificantWhitespace) | (1 << (int)(int)XPathNodeType.Whitespace); if ((kinds & XmlNodeKindFlags.Comment) != 0) kindsUnion |= (1 << (int)XPathNodeType.Comment); if ((kinds & XmlNodeKindFlags.PI) != 0) kindsUnion |= (1 << (int)XPathNodeType.ProcessingInstruction); if ((kinds & XmlNodeKindFlags.Namespace) != 0) kindsUnion |= (1 << (int)XPathNodeType.Namespace); _helper.LoadInteger(kindsUnion); _helper.Emit(OpCodes.And); ZeroCompare(allowKinds ? QilNodeType.Ne : QilNodeType.Eq, false); } else { // if (navigator.NodeType op runtimeItem) goto LabelBranch; _helper.LoadInteger((int)kindsRuntime); ClrCompare(allowKinds ? QilNodeType.Eq : QilNodeType.Ne, XmlTypeCode.Int); } return true; }
/// <summary> /// Generate code for QilNodeType.IsType. /// </summary> protected override QilNode VisitIsType(QilTargetType ndIsType) { XmlQueryType typDerived, typBase; XmlTypeCode codeBase; typDerived = ndIsType.Source.XmlType; typBase = ndIsType.TargetType; Debug.Assert(!typDerived.NeverSubtypeOf(typBase), "Normalizer should have eliminated IsType where source can never be a subtype of destination type."); // Special Case: Test whether singleton item is a Node if (typDerived.IsSingleton && (object)typBase == (object)TypeFactory.Node) { NestedVisitEnsureStack(ndIsType.Source); Debug.Assert(_iterCurr.Storage.ItemStorageType == typeof(XPathItem), "If !IsNode, then storage type should be Item"); // if (item.IsNode op true) goto LabelBranch; _helper.Call(XmlILMethods.ItemIsNode); ZeroCompare(QilNodeType.Ne, true); return ndIsType; } // Special Case: Source value is a singleton Node, and we're testing whether it is an Element, Attribute, PI, etc. if (MatchesNodeKinds(ndIsType, typDerived, typBase)) return ndIsType; // Special Case: XmlTypeCode is sufficient to describe destination type if ((object)typBase == (object)TypeFactory.Double) codeBase = XmlTypeCode.Double; else if ((object)typBase == (object)TypeFactory.String) codeBase = XmlTypeCode.String; else if ((object)typBase == (object)TypeFactory.Boolean) codeBase = XmlTypeCode.Boolean; else if ((object)typBase == (object)TypeFactory.Node) codeBase = XmlTypeCode.Node; else codeBase = XmlTypeCode.None; if (codeBase != XmlTypeCode.None) { // if (runtime.MatchesXmlType(value, code) op true) goto LabelBranch; _helper.LoadQueryRuntime(); NestedVisitEnsureStack(ndIsType.Source, typeof(XPathItem), !typDerived.IsSingleton); _helper.LoadInteger((int)codeBase); _helper.Call(typDerived.IsSingleton ? XmlILMethods.ItemMatchesCode : XmlILMethods.SeqMatchesCode); ZeroCompare(QilNodeType.Ne, true); return ndIsType; } // if (runtime.MatchesXmlType(value, idxType) op true) goto LabelBranch; _helper.LoadQueryRuntime(); NestedVisitEnsureStack(ndIsType.Source, typeof(XPathItem), !typDerived.IsSingleton); _helper.LoadInteger(_helper.StaticData.DeclareXmlType(typBase)); _helper.Call(typDerived.IsSingleton ? XmlILMethods.ItemMatchesType : XmlILMethods.SeqMatchesType); ZeroCompare(QilNodeType.Ne, true); return ndIsType; }
/// <summary> /// Find physical query plan for QilNodeType.TypeAssert. /// </summary> protected override QilNode VisitTypeAssert(QilTargetType ndTypeAssert) { if (!ndTypeAssert.Source.XmlType.IsSingleton && ndTypeAssert.XmlType.IsSingleton && !_iterCurr.HasLabelNext) { // This case occurs when a non-singleton expression is treated as cardinality One. // The trouble is that the expression will branch to an end label when it's done iterating, so // an end label must be provided. But there is no next label in the current iteration context, // so we've got to create a dummy label instead (IL requires it). This creates an infinite loop, // but since it's known statically that the expression is cardinality One, this branch will never // be taken. Label lblDummy = _helper.DefineLabel(); _helper.MarkLabel(lblDummy); NestedVisit(ndTypeAssert.Source, lblDummy); } else { // Generate code for child expression Visit(ndTypeAssert.Source); } _iterCurr.EnsureItemStorageType(ndTypeAssert.Source.XmlType, GetItemStorageType(ndTypeAssert)); return ndTypeAssert; }
//----------------------------------------------- // Type operators //----------------------------------------------- public QilTargetType TypeAssert(QilNode source, QilNode targetType) { QilTargetType n = new QilTargetType(QilNodeType.TypeAssert, source, targetType); n.XmlType = _typeCheck.CheckTypeAssert(n); TraceNode(n); return n; }
protected virtual QilNode VisitIsType(QilTargetType n) { return VisitChildren(n); }
public QilTargetType IsType(QilNode source, QilNode targetType) { QilTargetType n = new QilTargetType(QilNodeType.IsType, source, targetType); n.XmlType = this.typeCheck.CheckIsType(n); TraceNode(n); return n; }
protected override QilNode VisitIsType(QilTargetType local0) { QilNode local1 = local0[0]; QilNode local2 = local0[1]; if (this[XmlILOptimization.FoldNone]) { if ((object)((local1).XmlType) == (object)XmlQueryTypeFactory.None) { // PATTERN: [FoldNone] (IsType $x:* ^ (None? (TypeOf $x)) *) => (Nop $x) if (AllowReplace(XmlILOptimization.FoldNone, local0)) { return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1))); } } } if (this[XmlILOptimization.EliminateIsType]) { if (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects)) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ((local1).XmlType.IsSubtypeOf(local3)) { // PATTERN: [EliminateIsType] (IsType $opnd:* ^ (NoSideEffects? $opnd) (LiteralType $base:*) ^ (SubtypeOf? (TypeOf $opnd) $base)) => (True) if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) { return Replace(XmlILOptimization.EliminateIsType, local0, VisitTrue(f.True())); } } } } } if (this[XmlILOptimization.EliminateIsType]) { if (!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects)) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ((local1).XmlType.NeverSubtypeOf(local3)) { // PATTERN: [EliminateIsType] (IsType $opnd:* ^ (NoSideEffects? $opnd) (LiteralType $typ:*) ^ (NeverSubtypeOf? (TypeOf $opnd) $typ)) => (False) if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) { return Replace(XmlILOptimization.EliminateIsType, local0, VisitFalse(f.False())); } } } } } if (this[XmlILOptimization.EliminateIsType]) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ((local1).XmlType.Prime.NeverSubtypeOf(local3.Prime)) { // PATTERN: [EliminateIsType] (IsType $opnd:* (LiteralType $typ:*) ^ (NeverSubtypeOf? (Prime (TypeOf $opnd)) (Prime $typ))) => (IsEmpty $opnd) if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) { return Replace(XmlILOptimization.EliminateIsType, local0, VisitIsEmpty(f.IsEmpty(local1))); } } } } if (this[XmlILOptimization.EliminateIsType]) { if (!(!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects))) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ((local1).XmlType.IsSubtypeOf(local3)) { // PATTERN: [EliminateIsType] (IsType $opnd:* ^ ~((NoSideEffects? $opnd)) (LiteralType $base:*) ^ (SubtypeOf? (TypeOf $opnd) $base)) => (Loop (Let $opnd) (True)) if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) { return Replace(XmlILOptimization.EliminateIsType, local0, VisitLoop(f.Loop(VisitLet(f.Let(local1)), VisitTrue(f.True())))); } } } } } if (this[XmlILOptimization.EliminateIsType]) { if (!(!OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects))) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ((local1).XmlType.NeverSubtypeOf(local3)) { // PATTERN: [EliminateIsType] (IsType $opnd:* ^ ~((NoSideEffects? $opnd)) (LiteralType $typ:*) ^ (NeverSubtypeOf? (TypeOf $opnd) $typ)) => (Loop (Let $opnd) (False)) if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) { return Replace(XmlILOptimization.EliminateIsType, local0, VisitLoop(f.Loop(VisitLet(f.Let(local1)), VisitFalse(f.False())))); } } } } } return NoReplace(local0); }
protected override QilNode VisitXsltConvert(QilTargetType n) { return NoReplace(n); }
public QilTargetType XsltConvert(QilNode source, QilNode targetType) { QilTargetType n = new QilTargetType(QilNodeType.XsltConvert, source, targetType); n.XmlType = this.typeCheck.CheckXsltConvert(n); TraceNode(n); return n; }
protected virtual QilNode VisitXsltConvert(QilTargetType n) { return VisitChildren(n); }
protected override QilNode VisitTypeAssert(QilTargetType local0) { QilNode local1 = local0[0]; QilNode local2 = local0[1]; if (this[XmlILOptimization.FoldNone]) { if ( (object) ( (local1).XmlType ) == (object) XmlQueryTypeFactory.None ) { if (AllowReplace(XmlILOptimization.FoldNone, local0)) { return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1))); } } } if (this[XmlILOptimization.EliminateTypeAssert]) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ( (local1).XmlType .NeverSubtypeOf(local3) ) { if (AllowReplace(XmlILOptimization.EliminateTypeAssert, local0)) { return Replace(XmlILOptimization.EliminateTypeAssert, local0, VisitError(f.Error(VisitLiteralString(f.LiteralString(""))))); } } } } if (this[XmlILOptimization.EliminateTypeAssert]) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ( (local1).XmlType .Prime .NeverSubtypeOf( local3.Prime ) ) { if (AllowReplace(XmlILOptimization.EliminateTypeAssert, local0)) { return Replace(XmlILOptimization.EliminateTypeAssert, local0, VisitConditional(f.Conditional(VisitIsEmpty(f.IsEmpty(local1)), VisitSequence(f.Sequence()), VisitError(f.Error(VisitLiteralString(f.LiteralString(""))))))); } } } } if (this[XmlILOptimization.EliminateTypeAssertOptional]) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ( (local1).XmlType .IsSubtypeOf(local3) ) { if (AllowReplace(XmlILOptimization.EliminateTypeAssertOptional, local0)) { return Replace(XmlILOptimization.EliminateTypeAssertOptional, local0, local1); } } } } return NoReplace(local0); }
public XmlQueryType CheckXsltConvert(QilTargetType node) { CheckClassAndNodeType(node[1], typeof(QilLiteral), QilNodeType.LiteralType); return node.TargetType; }
protected override QilNode VisitIsType(QilTargetType local0) { QilNode local1 = local0[0]; QilNode local2 = local0[1]; if (this[XmlILOptimization.FoldNone]) { if ( (object) ( (local1).XmlType ) == (object) XmlQueryTypeFactory.None ) { if (AllowReplace(XmlILOptimization.FoldNone, local0)) { return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1))); } } } if (this[XmlILOptimization.EliminateIsType]) { if ( !OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects) ) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ( (local1).XmlType .IsSubtypeOf(local3) ) { if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) { return Replace(XmlILOptimization.EliminateIsType, local0, VisitTrue(f.True())); } } } } } if (this[XmlILOptimization.EliminateIsType]) { if ( !OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects) ) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ( (local1).XmlType .NeverSubtypeOf(local3) ) { if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) { return Replace(XmlILOptimization.EliminateIsType, local0, VisitFalse(f.False())); } } } } } if (this[XmlILOptimization.EliminateIsType]) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ( (local1).XmlType .Prime .NeverSubtypeOf( local3.Prime ) ) { if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) { return Replace(XmlILOptimization.EliminateIsType, local0, VisitIsEmpty(f.IsEmpty(local1))); } } } } if (this[XmlILOptimization.EliminateIsType]) { if (!( !OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects) )) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ( (local1).XmlType .IsSubtypeOf(local3) ) { if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) { return Replace(XmlILOptimization.EliminateIsType, local0, VisitLoop(f.Loop(VisitLet(f.Let(local1)), VisitTrue(f.True())))); } } } } } if (this[XmlILOptimization.EliminateIsType]) { if (!( !OptimizerPatterns.Read(local1).MatchesPattern(OptimizerPatternName.MaybeSideEffects) )) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ( (local1).XmlType .NeverSubtypeOf(local3) ) { if (AllowReplace(XmlILOptimization.EliminateIsType, local0)) { return Replace(XmlILOptimization.EliminateIsType, local0, VisitLoop(f.Loop(VisitLet(f.Let(local1)), VisitFalse(f.False())))); } } } } } return NoReplace(local0); }
public XmlQueryType CheckXsltConvert(QilTargetType node) { CheckClassAndNodeType(node[1], typeof(QilLiteral), QilNodeType.LiteralType); return(node.TargetType); }
protected override QilNode VisitXsltConvert(QilTargetType local0) { QilNode local1 = local0[0]; QilNode local2 = local0[1]; if (this[XmlILOptimization.FoldNone]) { if ( (object) ( (local1).XmlType ) == (object) XmlQueryTypeFactory.None ) { if (AllowReplace(XmlILOptimization.FoldNone, local0)) { return Replace(XmlILOptimization.FoldNone, local0, VisitNop(f.Nop(local1))); } } } if (this[XmlILOptimization.FoldXsltConvertLiteral]) { if ( IsLiteral((local1)) ) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ( CanFoldXsltConvert(local1, local3) ) { if (AllowReplace(XmlILOptimization.FoldXsltConvertLiteral, local0)) { return Replace(XmlILOptimization.FoldXsltConvertLiteral, local0, FoldXsltConvert(local1, local3) ); } } } } } if (this[XmlILOptimization.EliminateXsltConvert]) { if (local2.NodeType == QilNodeType.LiteralType) { XmlQueryType local3 = (XmlQueryType)((QilLiteral)local2).Value; if ( ( (local1).XmlType ) == (local3) ) { if (AllowReplace(XmlILOptimization.EliminateXsltConvert, local0)) { return Replace(XmlILOptimization.EliminateXsltConvert, local0, local1); } } } } return NoReplace(local0); }
protected virtual QilNode VisitXsltConvert(QilTargetType n) { return(VisitChildren(n)); }
protected override QilNode VisitTypeAssert(QilTargetType n) { return NoReplace(n); }