diff options
Diffstat (limited to 'tools/Sandcastle/Source/CCI/Updater.cs')
| -rw-r--r-- | tools/Sandcastle/Source/CCI/Updater.cs | 2979 |
1 files changed, 2979 insertions, 0 deletions
diff --git a/tools/Sandcastle/Source/CCI/Updater.cs b/tools/Sandcastle/Source/CCI/Updater.cs new file mode 100644 index 0000000..18c015a --- /dev/null +++ b/tools/Sandcastle/Source/CCI/Updater.cs @@ -0,0 +1,2979 @@ +// Copyright © Microsoft Corporation. +// This source file is subject to the Microsoft Permissive License. +// See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx. +// All other rights reserved. + +#if !MinimalReader +using System; +using System.Diagnostics; + +#if CCINamespace +namespace Microsoft.Cci{ +#else +namespace System.Compiler +{ +#endif + public class UpdateSpecification + { + public Node Original; + public Node Changes; + public Node Deletions; + public Node Insertions; + //TODO: source change list? + } + public class Updater + { + public static void UpdateOriginal(UpdateSpecification update) + { + if (update == null) { Debug.Assert(false); return; } + Updater updater = new Updater(); + updater.Visit(update.Original, update.Changes, update.Deletions, update.Insertions); + } + + public Updater callingVisitor; + public int currentSourcePositionDelta; + public Document currentDocument; + + public Updater() + { + } + public Updater(Updater callingVisitor) + { + this.callingVisitor = callingVisitor; + } + public virtual Node VisitUnknownNodeType(Node node, Node changes, Node deletions, Node insertions) + { + Updater visitor = this.GetVisitorFor(node); + if (visitor == null) return node; + if (this.callingVisitor != null) + //Allow specialized state (unknown to this visitor) to propagate all the way down to the new visitor + this.callingVisitor.TransferStateTo(visitor); + this.TransferStateTo(visitor); + node = visitor.Visit(node, changes, deletions, insertions); + visitor.TransferStateTo(this); + if (this.callingVisitor != null) + //Propagate specialized state (unknown to this visitor) all the way up the chain + visitor.TransferStateTo(this.callingVisitor); + return node; + } + public virtual void TransferStateTo(Updater target) + { + if (target == null) return; + target.currentSourcePositionDelta = this.currentSourcePositionDelta; + } + public virtual Updater GetVisitorFor(Node node) + { + if (node == null) return null; + return (Updater)node.GetVisitorFor(this, this.GetType().Name); + } + public virtual Node Visit(Node node, Node changes, Node deletions, Node insertions) + { + if (node == null) return changes; + switch (node.NodeType) + { + case NodeType.AddressDereference: + return this.VisitAddressDereference((AddressDereference)node, changes as AddressDereference, deletions as AddressDereference, insertions as AddressDereference); + case NodeType.AliasDefinition: + return this.VisitAliasDefinition((AliasDefinition)node, changes as AliasDefinition, deletions as AliasDefinition, insertions as AliasDefinition); + case NodeType.AnonymousNestedFunction: + return this.VisitAnonymousNestedFunction((AnonymousNestedFunction)node, changes as AnonymousNestedFunction, deletions as AnonymousNestedFunction, insertions as AnonymousNestedFunction); + case NodeType.ApplyToAll: + return this.VisitApplyToAll((ApplyToAll)node, changes as ApplyToAll, deletions as ApplyToAll, insertions as ApplyToAll); + case NodeType.Arglist: + return this.VisitExpression((Expression)node, changes as Expression, deletions as Expression, insertions as Expression); + case NodeType.ArrayType: + Debug.Assert(false); return null; + case NodeType.Assembly: + return this.VisitAssembly((AssemblyNode)node, changes as AssemblyNode, deletions as AssemblyNode, insertions as AssemblyNode); + case NodeType.AssemblyReference: + return this.VisitAssemblyReference((AssemblyReference)node, changes as AssemblyReference, deletions as AssemblyReference, insertions as AssemblyReference); + case NodeType.Assertion: + return this.VisitAssertion((Assertion)node, changes as Assertion, deletions as Assertion, insertions as Assertion); + case NodeType.AssignmentExpression: + return this.VisitAssignmentExpression((AssignmentExpression)node, changes as AssignmentExpression, deletions as AssignmentExpression, insertions as AssignmentExpression); + case NodeType.AssignmentStatement: + return this.VisitAssignmentStatement((AssignmentStatement)node, changes as AssignmentStatement, deletions as AssignmentStatement, insertions as AssignmentStatement); + case NodeType.Attribute: + return this.VisitAttributeNode((AttributeNode)node, changes as AttributeNode, deletions as AttributeNode, insertions as AttributeNode); + case NodeType.Base: + return this.VisitBase((Base)node, changes as Base, deletions as Base, insertions as Base); + case NodeType.Block: + return this.VisitBlock((Block)node, changes as Block, deletions as Block, insertions as Block); + case NodeType.BlockExpression: + return this.VisitBlockExpression((BlockExpression)node, changes as BlockExpression, deletions as BlockExpression, insertions as BlockExpression); + case NodeType.Branch: + Debug.Assert(false); return null; + case NodeType.Compilation: + return this.VisitCompilation((Compilation)node, changes as Compilation, deletions as Compilation, insertions as Compilation); + case NodeType.CompilationUnit: + return this.VisitCompilationUnit((CompilationUnit)node, changes as CompilationUnit, deletions as CompilationUnit, insertions as CompilationUnit); + case NodeType.CompilationUnitSnippet: + return this.VisitCompilationUnitSnippet((CompilationUnitSnippet)node, changes as CompilationUnitSnippet, deletions as CompilationUnitSnippet, insertions as CompilationUnitSnippet); +#if ExtendedRuntime + case NodeType.ConstrainedType: + return this.VisitConstrainedType((ConstrainedType)node, changes as ConstrainedType, deletions as ConstrainedType, insertions as ConstrainedType); +#endif + case NodeType.Continue: + return this.VisitContinue((Continue)node, changes as Continue, deletions as Continue, insertions as Continue); + case NodeType.CurrentClosure: + return this.VisitCurrentClosure((CurrentClosure)node, changes as CurrentClosure, deletions as CurrentClosure, insertions as CurrentClosure); + case NodeType.DebugBreak: + return node; + case NodeType.Call: + case NodeType.Calli: + case NodeType.Callvirt: + case NodeType.Jmp: + case NodeType.MethodCall: + return this.VisitMethodCall((MethodCall)node, changes as MethodCall, deletions as MethodCall, insertions as MethodCall); + case NodeType.Catch: + return this.VisitCatch((Catch)node, changes as Catch, deletions as Catch, insertions as Catch); + case NodeType.Class: + return this.VisitClass((Class)node, changes as Class, deletions as Class, insertions as Class); + case NodeType.CoerceTuple: + return this.VisitCoerceTuple((CoerceTuple)node, changes as CoerceTuple, deletions as CoerceTuple, insertions as CoerceTuple); + case NodeType.CollectionEnumerator: + return this.VisitCollectionEnumerator((CollectionEnumerator)node, changes as CollectionEnumerator, deletions as CollectionEnumerator, insertions as CollectionEnumerator); + case NodeType.Composition: + return this.VisitComposition((Composition)node, changes as Composition, deletions as Composition, insertions as Composition); + case NodeType.Construct: + return this.VisitConstruct((Construct)node, changes as Construct, deletions as Construct, insertions as Construct); + case NodeType.ConstructArray: + return this.VisitConstructArray((ConstructArray)node, changes as ConstructArray, deletions as ConstructArray, insertions as ConstructArray); + case NodeType.ConstructDelegate: + return this.VisitConstructDelegate((ConstructDelegate)node, changes as ConstructDelegate, deletions as ConstructDelegate, insertions as ConstructDelegate); + case NodeType.ConstructFlexArray: + return this.VisitConstructFlexArray((ConstructFlexArray)node, changes as ConstructFlexArray, deletions as ConstructFlexArray, insertions as ConstructFlexArray); + case NodeType.ConstructIterator: + return this.VisitConstructIterator((ConstructIterator)node, changes as ConstructIterator, deletions as ConstructIterator, insertions as ConstructIterator); + case NodeType.ConstructTuple: + return this.VisitConstructTuple((ConstructTuple)node, changes as ConstructTuple, deletions as ConstructTuple, insertions as ConstructTuple); + case NodeType.DelegateNode: + return this.VisitDelegateNode((DelegateNode)node, changes as DelegateNode, deletions as DelegateNode, insertions as DelegateNode); + case NodeType.DoWhile: + return this.VisitDoWhile((DoWhile)node, changes as DoWhile, deletions as DoWhile, insertions as DoWhile); + case NodeType.Dup: + return this.VisitExpression((Expression)node, changes as Expression, deletions as Expression, insertions as Expression); + case NodeType.EndFilter: + return this.VisitEndFilter((EndFilter)node, changes as EndFilter, deletions as EndFilter, insertions as EndFilter); + case NodeType.EndFinally: + return this.VisitEndFinally((EndFinally)node, changes as EndFinally, deletions as EndFinally, insertions as EndFinally); + case NodeType.EnumNode: + return this.VisitEnumNode((EnumNode)node, changes as EnumNode, deletions as EnumNode, insertions as EnumNode); + case NodeType.Event: + return this.VisitEvent((Event)node, changes as Event, deletions as Event, insertions as Event); + case NodeType.Exit: + return this.VisitExit((Exit)node, changes as Exit, deletions as Exit, insertions as Exit); + case NodeType.ExpressionSnippet: + return this.VisitExpressionSnippet((ExpressionSnippet)node, changes as ExpressionSnippet, deletions as ExpressionSnippet, insertions as ExpressionSnippet); + case NodeType.ExpressionStatement: + return this.VisitExpressionStatement((ExpressionStatement)node, changes as ExpressionStatement, deletions as ExpressionStatement, insertions as ExpressionStatement); + case NodeType.FaultHandler: + return this.VisitFaultHandler((FaultHandler)node, changes as FaultHandler, deletions as FaultHandler, insertions as FaultHandler); + case NodeType.Field: + return this.VisitField((Field)node, changes as Field, deletions as Field, insertions as Field); + case NodeType.FieldInitializerBlock: + return this.VisitFieldInitializerBlock((FieldInitializerBlock)node, changes as FieldInitializerBlock, deletions as FieldInitializerBlock, insertions as FieldInitializerBlock); + case NodeType.Finally: + return this.VisitFinally((Finally)node, changes as Finally, deletions as Finally, insertions as Finally); + case NodeType.Filter: + return this.VisitFilter((Filter)node, changes as Filter, deletions as Filter, insertions as Filter); + case NodeType.Fixed: + return this.VisitFixed((Fixed)node, changes as Fixed, deletions as Fixed, insertions as Fixed); + case NodeType.For: + return this.VisitFor((For)node, changes as For, deletions as For, insertions as For); + case NodeType.ForEach: + return this.VisitForEach((ForEach)node, changes as ForEach, deletions as ForEach, insertions as ForEach); + case NodeType.FunctionDeclaration: + return this.VisitFunctionDeclaration((FunctionDeclaration)node, changes as FunctionDeclaration, deletions as FunctionDeclaration, insertions as FunctionDeclaration); + case NodeType.Goto: + return this.VisitGoto((Goto)node, changes as Goto, deletions as Goto, insertions as Goto); + case NodeType.GotoCase: + return this.VisitGotoCase((GotoCase)node, changes as GotoCase, deletions as GotoCase, insertions as GotoCase); + case NodeType.Identifier: + return this.VisitIdentifier((Identifier)node, changes as Identifier, deletions as Identifier, insertions as Identifier); + case NodeType.If: + return this.VisitIf((If)node, changes as If, deletions as If, insertions as If); + case NodeType.ImplicitThis: + return this.VisitImplicitThis((ImplicitThis)node, changes as ImplicitThis, deletions as ImplicitThis, insertions as ImplicitThis); + case NodeType.Indexer: + return this.VisitIndexer((Indexer)node, changes as Indexer, deletions as Indexer, insertions as Indexer); + case NodeType.InstanceInitializer: + return this.VisitInstanceInitializer((InstanceInitializer)node, changes as InstanceInitializer, deletions as InstanceInitializer, insertions as InstanceInitializer); + case NodeType.StaticInitializer: + return this.VisitStaticInitializer((StaticInitializer)node, changes as StaticInitializer, deletions as StaticInitializer, insertions as StaticInitializer); + case NodeType.Method: + return this.VisitMethod((Method)node, changes as Method, deletions as Method, insertions as Method); + case NodeType.Interface: + return this.VisitInterface((Interface)node, changes as Interface, deletions as Interface, insertions as Interface); + case NodeType.LabeledStatement: + return this.VisitLabeledStatement((LabeledStatement)node, changes as LabeledStatement, deletions as LabeledStatement, insertions as LabeledStatement); + case NodeType.Literal: + return this.VisitLiteral((Literal)node, changes as Literal, deletions as Literal, insertions as Literal); + case NodeType.Local: + return this.VisitLocal((Local)node, changes as Local, deletions as Local, insertions as Local); + case NodeType.LocalDeclaration: + return this.VisitLocalDeclaration((LocalDeclaration)node, changes as LocalDeclaration, deletions as LocalDeclaration, insertions as LocalDeclaration); + case NodeType.LocalDeclarationsStatement: + return this.VisitLocalDeclarationsStatement((LocalDeclarationsStatement)node, changes as LocalDeclarationsStatement, deletions as LocalDeclarationsStatement, insertions as LocalDeclarationsStatement); + case NodeType.Lock: + return this.VisitLock((Lock)node, changes as Lock, deletions as Lock, insertions as Lock); + case NodeType.LRExpression: + return this.VisitLRExpression((LRExpression)node, changes as LRExpression, deletions as LRExpression, insertions as LRExpression); + case NodeType.MemberBinding: + return this.VisitMemberBinding((MemberBinding)node, changes as MemberBinding, deletions as MemberBinding, insertions as MemberBinding); + case NodeType.TemplateInstance: + return this.VisitTemplateInstance((TemplateInstance)node, changes as TemplateInstance, deletions as TemplateInstance, insertions as TemplateInstance); + case NodeType.StackAlloc: + return this.VisitStackAlloc((StackAlloc)node, changes as StackAlloc, deletions as StackAlloc, insertions as StackAlloc); + case NodeType.Module: + return this.VisitModule((Module)node, changes as Module, deletions as Module, insertions as Module); + case NodeType.ModuleReference: + return this.VisitModuleReference((ModuleReference)node, changes as ModuleReference, deletions as ModuleReference, insertions as ModuleReference); + case NodeType.NameBinding: + return this.VisitNameBinding((NameBinding)node, changes as NameBinding, deletions as NameBinding, insertions as NameBinding); + case NodeType.NamedArgument: + return this.VisitNamedArgument((NamedArgument)node, changes as NamedArgument, deletions as NamedArgument, insertions as NamedArgument); + case NodeType.Namespace: + return this.VisitNamespace((Namespace)node, changes as Namespace, deletions as Namespace, insertions as Namespace); + case NodeType.Nop: + return node; + case NodeType.OptionalModifier: + case NodeType.RequiredModifier: + return this.VisitTypeModifier((TypeModifier)node, changes as TypeModifier, deletions as TypeModifier, insertions as TypeModifier); + case NodeType.Parameter: + return this.VisitParameter((Parameter)node, changes as Parameter, deletions as Parameter, insertions as Parameter); + case NodeType.Pop: + return this.VisitExpression((Expression)node, changes as Expression, deletions as Expression, insertions as Expression); + case NodeType.PrefixExpression: + return this.VisitPrefixExpression((PrefixExpression)node, changes as PrefixExpression, deletions as PrefixExpression, insertions as PrefixExpression); + case NodeType.PostfixExpression: + return this.VisitPostfixExpression((PostfixExpression)node, changes as PostfixExpression, deletions as PostfixExpression, insertions as PostfixExpression); + case NodeType.Property: + return this.VisitProperty((Property)node, changes as Property, deletions as Property, insertions as Property); + case NodeType.QualifiedIdentifer: + return this.VisitQualifiedIdentifier((QualifiedIdentifier)node, changes as QualifiedIdentifier, deletions as QualifiedIdentifier, insertions as QualifiedIdentifier); + case NodeType.Rethrow: + case NodeType.Throw: + return this.VisitThrow((Throw)node, changes as Throw, deletions as Throw, insertions as Throw); + case NodeType.Return: + return this.VisitReturn((Return)node, changes as Return, deletions as Return, insertions as Return); + case NodeType.ResourceUse: + return this.VisitResourceUse((ResourceUse)node, changes as ResourceUse, deletions as ResourceUse, insertions as ResourceUse); + case NodeType.Repeat: + return this.VisitRepeat((Repeat)node, changes as Repeat, deletions as Repeat, insertions as Repeat); + case NodeType.SecurityAttribute: + return this.VisitSecurityAttribute((SecurityAttribute)node, changes as SecurityAttribute, deletions as SecurityAttribute, insertions as SecurityAttribute); + case NodeType.SetterValue: + return this.VisitSetterValue((SetterValue)node, changes as SetterValue, deletions as SetterValue, insertions as SetterValue); + case NodeType.StatementSnippet: + return this.VisitStatementSnippet((StatementSnippet)node, changes as StatementSnippet, deletions as StatementSnippet, insertions as StatementSnippet); + case NodeType.Struct: + return this.VisitStruct((Struct)node, changes as Struct, deletions as Struct, insertions as Struct); + case NodeType.Switch: + return this.VisitSwitch((Switch)node, changes as Switch, deletions as Switch, insertions as Switch); + case NodeType.SwitchCase: + return this.VisitSwitchCase((SwitchCase)node, changes as SwitchCase, deletions as SwitchCase, insertions as SwitchCase); + case NodeType.SwitchInstruction: + return this.VisitSwitchInstruction((SwitchInstruction)node, changes as SwitchInstruction, deletions as SwitchInstruction, insertions as SwitchInstruction); + case NodeType.Typeswitch: + return this.VisitTypeswitch((Typeswitch)node, changes as Typeswitch, deletions as Typeswitch, insertions as Typeswitch); + case NodeType.TypeswitchCase: + return this.VisitTypeswitchCase((TypeswitchCase)node, changes as TypeswitchCase, deletions as TypeswitchCase, insertions as TypeswitchCase); + case NodeType.This: + return this.VisitThis((This)node, changes as This, deletions as This, insertions as This); + case NodeType.Try: + return this.VisitTry((Try)node, changes as Try, deletions as Try, insertions as Try); +#if ExtendedRuntime + case NodeType.TupleType: + return this.VisitTupleType((TupleType)node, changes as TupleType, deletions as TupleType, insertions as TupleType); + case NodeType.TypeAlias: + return this.VisitTypeAlias((TypeAlias)node, changes as TypeAlias, deletions as TypeAlias, insertions as TypeAlias); + case NodeType.TypeIntersection: + return this.VisitTypeIntersection((TypeIntersection)node, changes as TypeIntersection, deletions as TypeIntersection, insertions as TypeIntersection); +#endif + case NodeType.TypeMemberSnippet: + return this.VisitTypeMemberSnippet((TypeMemberSnippet)node, changes as TypeMemberSnippet, deletions as TypeMemberSnippet, insertions as TypeMemberSnippet); + case NodeType.ClassParameter: + case NodeType.TypeParameter: + return this.VisitTypeParameter((TypeNode)node, changes as TypeNode, deletions as TypeNode, insertions as TypeNode); + case NodeType.TypeReference: + return this.VisitTypeReference((TypeReference)node, changes as TypeReference, deletions as TypeReference, insertions as TypeReference); +#if ExtendedRuntime + case NodeType.TypeUnion: + return this.VisitTypeUnion((TypeUnion)node, changes as TypeUnion, deletions as TypeUnion, insertions as TypeUnion); +#endif + case NodeType.UsedNamespace: + return this.VisitUsedNamespace((UsedNamespace)node, changes as UsedNamespace, deletions as UsedNamespace, insertions as UsedNamespace); + case NodeType.VariableDeclaration: + return this.VisitVariableDeclaration((VariableDeclaration)node, changes as VariableDeclaration, deletions as VariableDeclaration, insertions as VariableDeclaration); + case NodeType.While: + return this.VisitWhile((While)node, changes as While, deletions as While, insertions as While); + case NodeType.Yield: + return this.VisitYield((Yield)node, changes as Yield, deletions as Yield, insertions as Yield); + + case NodeType.Conditional: + case NodeType.Cpblk: + case NodeType.Initblk: + return this.VisitTernaryExpression((TernaryExpression)node, changes as TernaryExpression, deletions as TernaryExpression, insertions as TernaryExpression); + + case NodeType.Add: + case NodeType.Add_Ovf: + case NodeType.Add_Ovf_Un: + case NodeType.AddEventHandler: + case NodeType.And: + case NodeType.As: + case NodeType.Box: + case NodeType.Castclass: + case NodeType.Ceq: + case NodeType.Cgt: + case NodeType.Cgt_Un: + case NodeType.Clt: + case NodeType.Clt_Un: + case NodeType.Comma: + case NodeType.Div: + case NodeType.Div_Un: + case NodeType.Eq: + case NodeType.ExplicitCoercion: + case NodeType.Ge: + case NodeType.Gt: + case NodeType.Is: + case NodeType.Iff: + case NodeType.Implies: + case NodeType.Isinst: + case NodeType.Ldvirtftn: + case NodeType.Le: + case NodeType.LogicalAnd: + case NodeType.LogicalOr: + case NodeType.Lt: + case NodeType.Maplet: + case NodeType.Mkrefany: + case NodeType.Mul: + case NodeType.Mul_Ovf: + case NodeType.Mul_Ovf_Un: + case NodeType.Ne: + case NodeType.Or: + case NodeType.Range: + case NodeType.Refanyval: + case NodeType.Rem: + case NodeType.Rem_Un: + case NodeType.RemoveEventHandler: + case NodeType.Shl: + case NodeType.Shr: + case NodeType.Shr_Un: + case NodeType.Sub: + case NodeType.Sub_Ovf: + case NodeType.Sub_Ovf_Un: + case NodeType.Unbox: + case NodeType.UnboxAny: + case NodeType.Xor: + return this.VisitBinaryExpression((BinaryExpression)node, changes as BinaryExpression, deletions as BinaryExpression, insertions as BinaryExpression); + + case NodeType.AddressOf: + case NodeType.OutAddress: + case NodeType.RefAddress: + case NodeType.Ckfinite: + case NodeType.Conv_I: + case NodeType.Conv_I1: + case NodeType.Conv_I2: + case NodeType.Conv_I4: + case NodeType.Conv_I8: + case NodeType.Conv_Ovf_I: + case NodeType.Conv_Ovf_I1: + case NodeType.Conv_Ovf_I1_Un: + case NodeType.Conv_Ovf_I2: + case NodeType.Conv_Ovf_I2_Un: + case NodeType.Conv_Ovf_I4: + case NodeType.Conv_Ovf_I4_Un: + case NodeType.Conv_Ovf_I8: + case NodeType.Conv_Ovf_I8_Un: + case NodeType.Conv_Ovf_I_Un: + case NodeType.Conv_Ovf_U: + case NodeType.Conv_Ovf_U1: + case NodeType.Conv_Ovf_U1_Un: + case NodeType.Conv_Ovf_U2: + case NodeType.Conv_Ovf_U2_Un: + case NodeType.Conv_Ovf_U4: + case NodeType.Conv_Ovf_U4_Un: + case NodeType.Conv_Ovf_U8: + case NodeType.Conv_Ovf_U8_Un: + case NodeType.Conv_Ovf_U_Un: + case NodeType.Conv_R4: + case NodeType.Conv_R8: + case NodeType.Conv_R_Un: + case NodeType.Conv_U: + case NodeType.Conv_U1: + case NodeType.Conv_U2: + case NodeType.Conv_U4: + case NodeType.Conv_U8: + case NodeType.Decrement: + case NodeType.DefaultValue: + case NodeType.Increment: + case NodeType.Ldftn: + case NodeType.Ldlen: + case NodeType.Ldtoken: + case NodeType.Localloc: + case NodeType.LogicalNot: + case NodeType.Neg: + case NodeType.Not: + case NodeType.Parentheses: + case NodeType.Refanytype: + case NodeType.Sizeof: + case NodeType.SkipCheck: + case NodeType.Typeof: + case NodeType.UnaryPlus: + return this.VisitUnaryExpression((UnaryExpression)node, changes as UnaryExpression, deletions as UnaryExpression, insertions as UnaryExpression); +#if ExtendedRuntime + // query node types + case NodeType.QueryAggregate: + return this.VisitQueryAggregate((QueryAggregate)node, changes as QueryAggregate, deletions as QueryAggregate, insertions as QueryAggregate); + case NodeType.QueryAlias: + return this.VisitQueryAlias((QueryAlias)node, changes as QueryAlias, deletions as QueryAlias, insertions as QueryAlias); + case NodeType.QueryAll: + case NodeType.QueryAny: + return this.VisitQueryQuantifier((QueryQuantifier)node, changes as QueryQuantifier, deletions as QueryQuantifier, insertions as QueryQuantifier); + case NodeType.QueryAxis: + return this.VisitQueryAxis((QueryAxis)node, changes as QueryAxis, deletions as QueryAxis, insertions as QueryAxis); + case NodeType.QueryCommit: + return this.VisitQueryCommit((QueryCommit)node, changes as QueryCommit, deletions as QueryCommit, insertions as QueryCommit); + case NodeType.QueryContext: + return this.VisitQueryContext((QueryContext)node, changes as QueryContext, deletions as QueryContext, insertions as QueryContext); + case NodeType.QueryDelete: + return this.VisitQueryDelete((QueryDelete)node, changes as QueryDelete, deletions as QueryDelete, insertions as QueryDelete); + case NodeType.QueryDifference: + return this.VisitQueryDifference((QueryDifference)node, changes as QueryDifference, deletions as QueryDifference, insertions as QueryDifference); + case NodeType.QueryDistinct: + return this.VisitQueryDistinct((QueryDistinct)node, changes as QueryDistinct, deletions as QueryDistinct, insertions as QueryDistinct); + case NodeType.QueryExists: + return this.VisitQueryExists((QueryExists)node, changes as QueryExists, deletions as QueryExists, insertions as QueryExists); + case NodeType.QueryFilter: + return this.VisitQueryFilter((QueryFilter)node, changes as QueryFilter, deletions as QueryFilter, insertions as QueryFilter); + case NodeType.QueryGeneratedType: + return this.VisitQueryGeneratedType((QueryGeneratedType)node, changes as QueryGeneratedType, deletions as QueryGeneratedType, insertions as QueryGeneratedType); + case NodeType.QueryGroupBy: + return this.VisitQueryGroupBy((QueryGroupBy)node, changes as QueryGroupBy, deletions as QueryGroupBy, insertions as QueryGroupBy); + case NodeType.QueryInsert: + return this.VisitQueryInsert((QueryInsert)node, changes as QueryInsert, deletions as QueryInsert, insertions as QueryInsert); + case NodeType.QueryIntersection: + return this.VisitQueryIntersection((QueryIntersection)node, changes as QueryIntersection, deletions as QueryIntersection, insertions as QueryIntersection); + case NodeType.QueryIterator: + return this.VisitQueryIterator((QueryIterator)node, changes as QueryIterator, deletions as QueryIterator, insertions as QueryIterator); + case NodeType.QueryJoin: + return this.VisitQueryJoin((QueryJoin)node, changes as QueryJoin, deletions as QueryJoin, insertions as QueryJoin); + case NodeType.QueryLimit: + return this.VisitQueryLimit((QueryLimit)node, changes as QueryLimit, deletions as QueryLimit, insertions as QueryLimit); + case NodeType.QueryOrderBy: + return this.VisitQueryOrderBy((QueryOrderBy)node, changes as QueryOrderBy, deletions as QueryOrderBy, insertions as QueryOrderBy); + case NodeType.QueryOrderItem: + return this.VisitQueryOrderItem((QueryOrderItem)node, changes as QueryOrderItem, deletions as QueryOrderItem, insertions as QueryOrderItem); + case NodeType.QueryPosition: + return this.VisitQueryPosition((QueryPosition)node, changes as QueryPosition, deletions as QueryPosition, insertions as QueryPosition); + case NodeType.QueryProject: + return this.VisitQueryProject((QueryProject)node, changes as QueryProject, deletions as QueryProject, insertions as QueryProject); + case NodeType.QueryQuantifiedExpression: + return this.VisitQueryQuantifiedExpression((QueryQuantifiedExpression)node, changes as QueryQuantifiedExpression, deletions as QueryQuantifiedExpression, insertions as QueryQuantifiedExpression); + case NodeType.QueryRollback: + return this.VisitQueryRollback((QueryRollback)node, changes as QueryRollback, deletions as QueryRollback, insertions as QueryRollback); + case NodeType.QuerySelect: + return this.VisitQuerySelect((QuerySelect)node, changes as QuerySelect, deletions as QuerySelect, insertions as QuerySelect); + case NodeType.QuerySingleton: + return this.VisitQuerySingleton((QuerySingleton)node, changes as QuerySingleton, deletions as QuerySingleton, insertions as QuerySingleton); + case NodeType.QueryTransact: + return this.VisitQueryTransact((QueryTransact)node, changes as QueryTransact, deletions as QueryTransact, insertions as QueryTransact); + case NodeType.QueryTypeFilter: + return this.VisitQueryTypeFilter((QueryTypeFilter)node, changes as QueryTypeFilter, deletions as QueryTypeFilter, insertions as QueryTypeFilter); + case NodeType.QueryUnion: + return this.VisitQueryUnion((QueryUnion)node, changes as QueryUnion, deletions as QueryUnion, insertions as QueryUnion); + case NodeType.QueryUpdate: + return this.VisitQueryUpdate((QueryUpdate)node, changes as QueryUpdate, deletions as QueryUpdate, insertions as QueryUpdate); + case NodeType.QueryYielder: + return this.VisitQueryYielder((QueryYielder)node, changes as QueryYielder, deletions as QueryYielder, insertions as QueryYielder); +#endif + default: + return this.VisitUnknownNodeType(node, changes, deletions, insertions); + } + } + public virtual void UpdateSourceContext(Node node, Node changes) + { + } + public virtual Expression VisitAddressDereference(AddressDereference addr, AddressDereference changes, AddressDereference deletions, AddressDereference insertions) + { + this.UpdateSourceContext(addr, changes); + if (addr == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + addr.Address = this.VisitExpression(addr.Address, changes.Address, deletions.Address, insertions.Address); + addr.Alignment = changes.Alignment; + addr.Volatile = changes.Volatile; + } + } + else if (deletions != null) + return null; + return addr; + } + public virtual AliasDefinition VisitAliasDefinition(AliasDefinition aliasDefinition, AliasDefinition changes, AliasDefinition deletions, AliasDefinition insertions) + { + this.UpdateSourceContext(aliasDefinition, changes); + if (aliasDefinition == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + aliasDefinition.Alias = changes.Alias; + aliasDefinition.AliasedType = this.VisitTypeReference(aliasDefinition.AliasedType, changes.AliasedType, deletions.AliasedType, insertions.AliasedType); + aliasDefinition.AliasedExpression = changes.AliasedExpression; + aliasDefinition.AliasedUri = changes.AliasedUri; + } + } + else if (deletions != null) + return null; + return aliasDefinition; + } + public virtual AliasDefinitionList VisitAliasDefinitionList(AliasDefinitionList aliasDefinitions, AliasDefinitionList changes, AliasDefinitionList deletions, AliasDefinitionList insertions) + { + if (changes == null || deletions == null || insertions == null) return aliasDefinitions; + int n = aliasDefinitions == null ? 0 : aliasDefinitions.Count; + if (n > changes.Count) { Debug.Assert(false); n = changes.Count; } + if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; } + if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; } + if (aliasDefinitions != null) + for (int i = 0; i < n; i++) + aliasDefinitions[i] = this.VisitAliasDefinition(aliasDefinitions[i], changes[i], deletions[i], insertions[i]); + AliasDefinitionList result = new AliasDefinitionList(insertions.Count - n); + for (int i = n, m = insertions.Count; i < m; i++) + result.Add(insertions[i]); + return result; + } + public virtual Expression VisitAnonymousNestedFunction(AnonymousNestedFunction func, AnonymousNestedFunction changes, AnonymousNestedFunction deletions, AnonymousNestedFunction insertions) + { + this.UpdateSourceContext(func, changes); + if (func == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + func.Body = this.VisitBlock(func.Body, changes.Body, deletions.Body, insertions.Body); + func.Parameters = this.VisitParameterList(func.Parameters, changes.Parameters, deletions.Parameters, insertions.Parameters); + } + } + else if (deletions != null) + return null; + return func; + } + public virtual Expression VisitApplyToAll(ApplyToAll applyToAll, ApplyToAll changes, ApplyToAll deletions, ApplyToAll insertions) + { + this.UpdateSourceContext(applyToAll, changes); + if (applyToAll == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + applyToAll.Operand1 = this.VisitExpression(applyToAll.Operand1, changes.Operand1, deletions.Operand1, insertions.Operand1); + applyToAll.Operand2 = this.VisitExpression(applyToAll.Operand2, changes.Operand2, deletions.Operand2, insertions.Operand2); + } + } + else if (deletions != null) + return null; + return applyToAll; + } + public virtual AssemblyNode VisitAssembly(AssemblyNode assembly, AssemblyNode changes, AssemblyNode deletions, AssemblyNode insertions) + { + this.UpdateSourceContext(assembly, changes); + if (assembly == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + assembly.AssemblyReferences = this.VisitAssemblyReferenceList(assembly.AssemblyReferences, changes.AssemblyReferences, deletions.AssemblyReferences, insertions.AssemblyReferences); + assembly.Attributes = this.VisitAttributeList(assembly.Attributes, changes.Attributes, deletions.Attributes, insertions.Attributes); + assembly.Culture = changes.Culture; + assembly.ExportedTypes = this.VisitTypeReferenceList(assembly.ExportedTypes, changes.ExportedTypes, deletions.ExportedTypes, insertions.ExportedTypes); + assembly.Flags = changes.Flags; + assembly.Kind = changes.Kind; + assembly.ModuleAttributes = this.VisitAttributeList(assembly.ModuleAttributes, changes.ModuleAttributes, deletions.ModuleAttributes, insertions.ModuleAttributes); + assembly.ModuleReferences = this.VisitModuleReferenceList(assembly.ModuleReferences, changes.ModuleReferences, deletions.ModuleReferences, insertions.ModuleReferences); + assembly.Name = changes.Name; + assembly.SecurityAttributes = this.VisitSecurityAttributeList(assembly.SecurityAttributes, changes.SecurityAttributes, deletions.SecurityAttributes, insertions.SecurityAttributes); + assembly.Types = this.VisitTypeNodeList(assembly.Types, changes.Types, deletions.Types, insertions.Types); + assembly.Version = changes.Version; + } + } + else if (deletions != null) + return null; + return assembly; + } + public virtual AssemblyReference VisitAssemblyReference(AssemblyReference assemblyReference, AssemblyReference changes, AssemblyReference deletions, AssemblyReference insertions) + { + this.UpdateSourceContext(assemblyReference, changes); + if (assemblyReference == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + assemblyReference.Culture = changes.Culture; + assemblyReference.Flags = changes.Flags; + assemblyReference.Name = changes.Name; + assemblyReference.PublicKeyOrToken = changes.PublicKeyOrToken; + assemblyReference.Version = changes.Version; + } + } + else if (deletions != null) + return null; + return assemblyReference; + } + public virtual AssemblyReferenceList VisitAssemblyReferenceList(AssemblyReferenceList assemblyReferences, AssemblyReferenceList changes, AssemblyReferenceList deletions, AssemblyReferenceList insertions) + { + if (changes == null || deletions == null || insertions == null) return assemblyReferences; + int n = assemblyReferences == null ? 0 : assemblyReferences.Count; + if (n > changes.Count) { Debug.Assert(false); n = changes.Count; } + if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; } + if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; } + if (assemblyReferences != null) + for (int i = 0; i < n; i++) + assemblyReferences[i] = this.VisitAssemblyReference(assemblyReferences[i], changes[i], deletions[i], insertions[i]); + AssemblyReferenceList result = new AssemblyReferenceList(insertions.Count - n); + for (int i = n, m = insertions.Count; i < m; i++) + result.Add(insertions[i]); + return result; + } + public virtual Statement VisitAssertion(Assertion assertion, Assertion changes, Assertion deletions, Assertion insertions) + { + this.UpdateSourceContext(assertion, changes); + if (assertion == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + assertion.Condition = this.VisitExpression(assertion.Condition, changes.Condition, deletions.Condition, insertions.Condition); + } + } + else if (deletions != null) + return null; + return assertion; + } + public virtual Expression VisitAssignmentExpression(AssignmentExpression assignment, AssignmentExpression changes, AssignmentExpression deletions, AssignmentExpression insertions) + { + this.UpdateSourceContext(assignment, changes); + if (assignment == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + assignment.AssignmentStatement = this.VisitAssignmentStatement(assignment.AssignmentStatement as AssignmentStatement, changes.AssignmentStatement as AssignmentStatement, deletions.AssignmentStatement as AssignmentStatement, insertions.AssignmentStatement as AssignmentStatement); + } + } + else if (deletions != null) + return null; + return assignment; + } + public virtual Statement VisitAssignmentStatement(AssignmentStatement assignment, AssignmentStatement changes, AssignmentStatement deletions, AssignmentStatement insertions) + { + this.UpdateSourceContext(assignment, changes); + if (assignment == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + assignment.Operator = changes.Operator; + assignment.Source = this.VisitExpression(assignment.Source, changes.Source, deletions.Source, insertions.Source); + assignment.Target = this.VisitExpression(assignment.Target, changes.Target, deletions.Target, insertions.Target); + } + } + else if (deletions != null) + return null; + return assignment; + } + public virtual AttributeNode VisitAttributeNode(AttributeNode attribute, AttributeNode changes, AttributeNode deletions, AttributeNode insertions) + { + this.UpdateSourceContext(attribute, changes); + if (attribute == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + attribute.AllowMultiple = changes.AllowMultiple; + attribute.Constructor = this.VisitExpression(attribute.Constructor, changes.Constructor, deletions.Constructor, insertions.Constructor); + attribute.Expressions = this.VisitExpressionList(attribute.Expressions, changes.Expressions, deletions.Expressions, insertions.Expressions); + attribute.Target = changes.Target; + } + } + else if (deletions != null) + return null; + return attribute; + } + public virtual AttributeList VisitAttributeList(AttributeList attributes, AttributeList changes, AttributeList deletions, AttributeList insertions) + { + if (changes == null || deletions == null || insertions == null) return attributes; + int n = attributes == null ? 0 : attributes.Count; + if (n > changes.Count) { Debug.Assert(false); n = changes.Count; } + if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; } + if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; } + if (attributes != null) + for (int i = 0; i < n; i++) + attributes[i] = this.VisitAttributeNode(attributes[i], changes[i], deletions[i], insertions[i]); + AttributeList result = new AttributeList(insertions.Count - n); + for (int i = n, m = insertions.Count; i < m; i++) + result.Add(insertions[i]); + return result; + } + public virtual Expression VisitBase(Base Base, Base changes, Base deletions, Base insertions) + { + this.UpdateSourceContext(Base, changes); + if (Base == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Base; + } + public virtual Expression VisitBinaryExpression(BinaryExpression binaryExpression, BinaryExpression changes, BinaryExpression deletions, BinaryExpression insertions) + { + this.UpdateSourceContext(binaryExpression, changes); + if (binaryExpression == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + binaryExpression.NodeType = changes.NodeType; + binaryExpression.Operand1 = this.VisitExpression(binaryExpression.Operand1, changes.Operand1, deletions.Operand1, insertions.Operand1); + binaryExpression.Operand2 = this.VisitExpression(binaryExpression.Operand2, changes.Operand2, deletions.Operand2, insertions.Operand2); + } + } + else if (deletions != null) + return null; + return binaryExpression; + } + public virtual Block VisitBlock(Block block, Block changes, Block deletions, Block insertions) + { + this.UpdateSourceContext(block, changes); + if (block == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + block.Checked = changes.Checked; + block.Statements = this.VisitStatementList(block.Statements, changes.Statements, deletions.Statements, insertions.Statements); + block.SuppressCheck = changes.SuppressCheck; + } + } + else if (deletions != null) + return null; + return block; + } + public virtual Expression VisitBlockExpression(BlockExpression blockExpression, BlockExpression changes, BlockExpression deletions, BlockExpression insertions) + { + this.UpdateSourceContext(blockExpression, changes); + if (blockExpression == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + blockExpression.Block = this.VisitBlock(blockExpression.Block, changes.Block, deletions.Block, insertions.Block); + } + } + else if (deletions != null) + return null; + return blockExpression; + } + public virtual BlockList VisitBlockList(BlockList blockList, BlockList changes, BlockList deletions, BlockList insertions) + { + if (changes == null || deletions == null || insertions == null) return blockList; + int n = blockList == null ? 0 : blockList.Count; + if (n > changes.Count) { Debug.Assert(false); n = changes.Count; } + if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; } + if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; } + if (blockList != null) + for (int i = 0; i < n; i++) + blockList[i] = this.VisitBlock(blockList[i], changes[i], deletions[i], insertions[i]); + BlockList result = new BlockList(insertions.Count - n); + for (int i = n, m = insertions.Count; i < m; i++) + result.Add(insertions[i]); + return result; + } + public virtual Catch VisitCatch(Catch Catch, Catch changes, Catch deletions, Catch insertions) + { + this.UpdateSourceContext(Catch, changes); + if (Catch == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + Catch.Block = this.VisitBlock(Catch.Block, changes.Block, deletions.Block, insertions.Block); + Catch.Type = this.VisitTypeReference(Catch.Type, changes.Type); + Catch.Variable = this.VisitExpression(Catch.Variable, changes.Variable, deletions.Variable, insertions.Variable); + } + } + else if (deletions != null) + return null; + return Catch; + } + public virtual CatchList VisitCatchList(CatchList catchers, CatchList changes, CatchList deletions, CatchList insertions) + { + if (changes == null || deletions == null || insertions == null) return catchers; + int n = catchers == null ? 0 : catchers.Count; + if (n > changes.Count) { Debug.Assert(false); n = changes.Count; } + if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; } + if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; } + if (catchers != null) + for (int i = 0; i < n; i++) + catchers[i] = this.VisitCatch(catchers[i], changes[i], deletions[i], insertions[i]); + CatchList result = new CatchList(insertions.Count - n); + for (int i = n, m = insertions.Count; i < m; i++) + result.Add(insertions[i]); + return result; + } + public virtual Class VisitClass(Class Class, Class changes, Class deletions, Class insertions) + { + TypeNode result = this.VisitTypeNode(Class, changes, deletions, insertions); + Debug.Assert(result is Class); + return result as Class; + } + public virtual Expression VisitCoerceTuple(CoerceTuple coerceTuple, CoerceTuple changes, CoerceTuple deletions, CoerceTuple insertions) + { + this.UpdateSourceContext(coerceTuple, changes); + if (coerceTuple == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + coerceTuple.Fields = this.VisitFieldList(coerceTuple.Fields, changes.Fields, deletions.Fields, insertions.Fields); + coerceTuple.OriginalTuple = this.VisitExpression(coerceTuple.OriginalTuple, changes.OriginalTuple, deletions.OriginalTuple, insertions.OriginalTuple); + } + } + else if (deletions != null) + return null; + return coerceTuple; + } + public virtual CollectionEnumerator VisitCollectionEnumerator(CollectionEnumerator ce, CollectionEnumerator changes, CollectionEnumerator deletions, CollectionEnumerator insertions) + { + this.UpdateSourceContext(ce, changes); + if (ce == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + ce.Collection = this.VisitExpression(ce.Collection, changes.Collection, deletions.Collection, insertions.Collection); + //REVIEW: update method bindings? + } + } + else if (deletions != null) + return null; + return ce; + } + public virtual Compilation VisitCompilation(Compilation compilation, Compilation changes, Compilation deletions, Compilation insertions) + { + this.UpdateSourceContext(compilation, changes); + if (compilation == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + compilation.CompilerParameters = changes.CompilerParameters; + compilation.CompilationUnits = this.VisitCompilationUnitList(compilation.CompilationUnits, changes.CompilationUnits, deletions.CompilationUnits, insertions.CompilationUnits); + } + } + else if (deletions != null) + return null; + return compilation; + } + public virtual CompilationUnit VisitCompilationUnit(CompilationUnit cUnit, CompilationUnit changes, CompilationUnit deletions, CompilationUnit insertions) + { + this.UpdateSourceContext(cUnit, changes); + if (cUnit == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + cUnit.Nodes = this.VisitNodeList(cUnit.Nodes, changes.Nodes, deletions.Nodes, insertions.Nodes); + cUnit.PreprocessorDefinedSymbols = changes.PreprocessorDefinedSymbols; + } + } + else if (deletions != null) + return null; + return cUnit; + } + public virtual CompilationUnitList VisitCompilationUnitList(CompilationUnitList compUnits, CompilationUnitList changes, CompilationUnitList deletions, CompilationUnitList insertions) + { + if (changes == null || deletions == null || insertions == null) return compUnits; + int n = compUnits == null ? 0 : compUnits.Count; + if (n > changes.Count) { Debug.Assert(false); n = changes.Count; } + if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; } + if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; } + if (compUnits != null) + for (int i = 0; i < n; i++) + compUnits[i] = this.VisitCompilationUnit(compUnits[i], changes[i], deletions[i], insertions[i]); + CompilationUnitList result = new CompilationUnitList(insertions.Count - n); + for (int i = n, m = insertions.Count; i < m; i++) + result.Add(insertions[i]); + return result; + } + public virtual CompilationUnitSnippet VisitCompilationUnitSnippet(CompilationUnitSnippet snippet, CompilationUnitSnippet changes, CompilationUnitSnippet deletions, CompilationUnitSnippet insertions) + { + CompilationUnit cu = this.VisitCompilationUnit(snippet, changes, deletions, insertions); + Debug.Assert(cu is CompilationUnitSnippet); + return cu as CompilationUnitSnippet; + } + public virtual Node VisitComposition(Composition comp, Composition changes, Composition deletions, Composition insertions) + { + this.UpdateSourceContext(comp, changes); + if (comp == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + comp.Expression = this.VisitExpression(comp.Expression, changes.Expression, deletions.Expression, insertions.Expression); + } + } + else if (deletions != null) + return null; + return comp; + } + public virtual Expression VisitConstruct(Construct cons, Construct changes, Construct deletions, Construct insertions) + { + this.UpdateSourceContext(cons, changes); + if (cons == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + cons.Constructor = this.VisitExpression(cons.Constructor, changes.Constructor, deletions.Constructor, insertions.Constructor); + cons.Operands = this.VisitExpressionList(cons.Operands, changes.Operands, deletions.Operands, insertions.Operands); + cons.Owner = this.VisitExpression(cons.Owner, changes.Owner, deletions.Owner, insertions.Owner); + } + } + else if (deletions != null) + return null; + return cons; + } + public virtual Expression VisitConstructArray(ConstructArray consArr, ConstructArray changes, ConstructArray deletions, ConstructArray insertions) + { + this.UpdateSourceContext(consArr, changes); + if (consArr == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + consArr.ElementType = this.VisitTypeReference(consArr.ElementType, changes.ElementType); + consArr.Initializers = this.VisitExpressionList(consArr.Initializers, changes.Initializers, deletions.Initializers, insertions.Initializers); + consArr.Operands = this.VisitExpressionList(consArr.Operands, changes.Operands, deletions.Operands, insertions.Operands); + consArr.Rank = changes.Rank; + consArr.Owner = this.VisitExpression(consArr.Owner, changes.Owner, deletions.Owner, insertions.Owner); + } + } + else if (deletions != null) + return null; + return consArr; + } + public virtual Expression VisitConstructDelegate(ConstructDelegate consDelegate, ConstructDelegate changes, ConstructDelegate deletions, ConstructDelegate insertions) + { + this.UpdateSourceContext(consDelegate, changes); + if (consDelegate == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + consDelegate.DelegateType = this.VisitTypeReference(consDelegate.DelegateType, changes.DelegateType); + consDelegate.MethodName = changes.MethodName; + consDelegate.TargetObject = this.VisitExpression(consDelegate.TargetObject, changes.TargetObject, deletions.TargetObject, insertions.TargetObject); + } + } + else if (deletions != null) + return null; + return consDelegate; + } + public virtual Expression VisitConstructFlexArray(ConstructFlexArray consArr, ConstructFlexArray changes, ConstructFlexArray deletions, ConstructFlexArray insertions) + { + this.UpdateSourceContext(consArr, changes); + if (consArr == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + consArr.ElementType = this.VisitTypeReference(consArr.ElementType, changes.ElementType); + consArr.Initializers = this.VisitExpressionList(consArr.Initializers, changes.Initializers, deletions.Initializers, insertions.Initializers); + consArr.Operands = this.VisitExpressionList(consArr.Operands, changes.Operands, deletions.Operands, insertions.Operands); + } + } + else if (deletions != null) + return null; + return consArr; + } + public virtual Expression VisitConstructIterator(ConstructIterator consIterator, ConstructIterator changes, ConstructIterator deletions, ConstructIterator insertions) + { + this.UpdateSourceContext(consIterator, changes); + if (consIterator == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + consIterator.Body = this.VisitBlock(consIterator.Body, changes.Body, deletions.Body, insertions.Body); + consIterator.ElementType = this.VisitTypeReference(consIterator.ElementType, changes.ElementType); + consIterator.State = this.VisitClass(consIterator.State, changes.State, deletions.State, insertions.State); + } + } + else if (deletions != null) + return null; + return consIterator; + } + public virtual Expression VisitConstructTuple(ConstructTuple consTuple, ConstructTuple changes, ConstructTuple deletions, ConstructTuple insertions) + { + this.UpdateSourceContext(consTuple, changes); + if (consTuple == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + consTuple.Fields = this.VisitFieldList(consTuple.Fields, changes.Fields, deletions.Fields, insertions.Fields); + } + } + else if (deletions != null) + return null; + return consTuple; + } +#if ExtendedRuntime + public virtual TypeNode VisitConstrainedType(ConstrainedType cType, ConstrainedType changes, ConstrainedType deletions, ConstrainedType insertions){ + this.UpdateSourceContext(cType, changes); + if (cType == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + cType.Constraint = this.VisitExpression(cType.Constraint, changes.Constraint, deletions.Constraint, insertions.Constraint); + cType.UnderlyingType = this.VisitTypeReference(cType.UnderlyingType, changes.UnderlyingType); + } + }else if (deletions != null) + return null; + return cType; + } +#endif + public virtual Statement VisitContinue(Continue Continue, Continue changes, Continue deletions, Continue insertions) + { + this.UpdateSourceContext(Continue, changes); + if (Continue == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + Continue.Level = changes.Level; + } + } + else if (deletions != null) + return null; + return Continue; + } + public virtual Expression VisitCurrentClosure(CurrentClosure currentClosure, CurrentClosure changes, CurrentClosure deletions, CurrentClosure insertions) + { + this.UpdateSourceContext(currentClosure, changes); + if (currentClosure == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return currentClosure; + } + public virtual DelegateNode VisitDelegateNode(DelegateNode delegateNode, DelegateNode changes, DelegateNode deletions, DelegateNode insertions) + { + this.UpdateSourceContext(delegateNode, changes); + if (delegateNode == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + delegateNode.Attributes = this.VisitAttributeList(delegateNode.Attributes, changes.Attributes, deletions.Attributes, insertions.Attributes); +#if !NoXml + delegateNode.Documentation = changes.Documentation; +#endif + delegateNode.Flags = changes.Flags; + delegateNode.Parameters = this.VisitParameterList(delegateNode.Parameters, changes.Parameters, deletions.Parameters, insertions.Parameters); + delegateNode.ReturnType = this.VisitTypeReference(delegateNode.ReturnType, changes.ReturnType); + delegateNode.SecurityAttributes = this.VisitSecurityAttributeList(delegateNode.SecurityAttributes, changes.SecurityAttributes, deletions.SecurityAttributes, insertions.SecurityAttributes); + delegateNode.TemplateParameters = this.VisitTypeReferenceList(delegateNode.TemplateParameters, changes.TemplateParameters, deletions.TemplateParameters, insertions.TemplateParameters); + } + } + else if (deletions != null) + return null; + return delegateNode; + } + public virtual Statement VisitDoWhile(DoWhile doWhile, DoWhile changes, DoWhile deletions, DoWhile insertions) + { + this.UpdateSourceContext(doWhile, changes); + if (doWhile == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + doWhile.Body = this.VisitBlock(doWhile.Body, changes.Body, deletions.Body, insertions.Body); + doWhile.Condition = this.VisitExpression(doWhile.Condition, changes.Condition, deletions.Condition, insertions.Condition); + } + } + else if (deletions != null) + return null; + return doWhile; + } + public virtual Statement VisitEndFilter(EndFilter endFilter, EndFilter changes, EndFilter deletions, EndFilter insertions) + { + this.UpdateSourceContext(endFilter, changes); + if (endFilter == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + endFilter.Value = this.VisitExpression(endFilter.Value, changes.Value, deletions.Value, insertions.Value); + } + } + else if (deletions != null) + return null; + return endFilter; + } + public virtual Statement VisitEndFinally(EndFinally endFinally, EndFinally changes, EndFinally deletions, EndFinally insertions) + { + this.UpdateSourceContext(endFinally, changes); + if (endFinally == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return endFinally; + } + public virtual EnumNode VisitEnumNode(EnumNode enumNode, EnumNode changes, EnumNode deletions, EnumNode insertions) + { + if (enumNode == null) return changes; + TypeNode result = this.VisitTypeNode(enumNode, changes, deletions, insertions); + Debug.Assert(result is EnumNode); + if (result == enumNode) + { + Debug.Assert(changes != null); + if (changes != null) + enumNode.UnderlyingType = this.VisitTypeReference(enumNode.UnderlyingType, changes.UnderlyingType); + return enumNode; + } + return result as EnumNode; + } + public virtual Event VisitEvent(Event evnt, Event changes, Event deletions, Event insertions) + { + this.UpdateSourceContext(evnt, changes); + if (evnt == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + evnt.Attributes = this.VisitAttributeList(evnt.Attributes, changes.Attributes, deletions.Attributes, insertions.Attributes); +#if !NoXml + evnt.Documentation = changes.Documentation; +#endif + evnt.Flags = changes.Flags; + evnt.HandlerAdder = this.VisitMethodReference(evnt.HandlerAdder, changes.HandlerAdder); + evnt.HandlerCaller = this.VisitMethodReference(evnt.HandlerCaller, changes.HandlerCaller); + evnt.HandlerFlags = changes.HandlerFlags; + evnt.HandlerRemover = this.VisitMethodReference(evnt.HandlerRemover, changes.HandlerRemover); + evnt.HandlerType = this.VisitTypeReference(evnt.HandlerType, changes.HandlerType); + evnt.InitialHandler = this.VisitExpression(evnt.InitialHandler, changes.InitialHandler, deletions.InitialHandler, insertions.InitialHandler); + evnt.Name = changes.Name; + evnt.OtherMethods = this.VisitMethodReferenceList(evnt.OtherMethods, changes.OtherMethods); + evnt.OverridesBaseClassMember = changes.OverridesBaseClassMember; + } + } + else if (deletions != null) + return null; + return evnt; + } + public virtual Statement VisitExit(Exit exit, Exit changes, Exit deletions, Exit insertions) + { + this.UpdateSourceContext(exit, changes); + if (exit == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + exit.Level = changes.Level; + } + } + else if (deletions != null) + return null; + return exit; + } + public virtual Expression VisitExpression(Expression expression, Expression changes, Expression deletions, Expression insertions) + { + return this.Visit(expression, changes, deletions, insertions) as Expression; + } + public virtual ExpressionList VisitExpressionList(ExpressionList expressions, ExpressionList changes, ExpressionList deletions, ExpressionList insertions) + { + if (changes == null || deletions == null || insertions == null) return expressions; + int n = expressions == null ? 0 : expressions.Count; + if (n > changes.Count) { Debug.Assert(false); n = changes.Count; } + if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; } + if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; } + if (expressions != null) + for (int i = 0; i < n; i++) + expressions[i] = this.VisitExpression(expressions[i], changes[i], deletions[i], insertions[i]); + ExpressionList result = new ExpressionList(insertions.Count - n); + for (int i = n, m = insertions.Count; i < m; i++) + result.Add(insertions[i]); + return result; + } + public virtual Expression VisitExpressionSnippet(ExpressionSnippet snippet, ExpressionSnippet changes, ExpressionSnippet deletions, ExpressionSnippet insertions) + { + this.UpdateSourceContext(snippet, changes); + if (snippet == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return snippet; + } + public virtual Statement VisitExpressionStatement(ExpressionStatement statement, ExpressionStatement changes, ExpressionStatement deletions, ExpressionStatement insertions) + { + this.UpdateSourceContext(statement, changes); + if (statement == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + statement.Expression = this.VisitExpression(statement.Expression, changes.Expression, deletions.Expression, insertions.Expression); + } + } + else if (deletions != null) + return null; + return statement; + } + public virtual FaultHandler VisitFaultHandler(FaultHandler faultHandler, FaultHandler changes, FaultHandler deletions, FaultHandler insertions) + { + this.UpdateSourceContext(faultHandler, changes); + if (faultHandler == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + faultHandler.Block = this.VisitBlock(faultHandler.Block, changes.Block, deletions.Block, insertions.Block); + } + } + else if (deletions != null) + return null; + return faultHandler; + } + public virtual FaultHandlerList VisitFaultHandlerList(FaultHandlerList faultHandlers, FaultHandlerList changes, FaultHandlerList deletions, FaultHandlerList insertions) + { + if (changes == null || deletions == null || insertions == null) return faultHandlers; + int n = faultHandlers == null ? 0 : faultHandlers.Count; + if (n > changes.Count) { Debug.Assert(false); n = changes.Count; } + if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; } + if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; } + if (faultHandlers != null) + for (int i = 0; i < n; i++) + faultHandlers[i] = this.VisitFaultHandler(faultHandlers[i], changes[i], deletions[i], insertions[i]); + FaultHandlerList result = new FaultHandlerList(insertions.Count - n); + for (int i = n, m = insertions.Count; i < m; i++) + result.Add(insertions[i]); + return result; + } + public virtual Field VisitField(Field field, Field changes, Field deletions, Field insertions) + { + this.UpdateSourceContext(field, changes); + if (field == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + field.Attributes = this.VisitAttributeList(field.Attributes, changes.Attributes, deletions.Attributes, insertions.Attributes); + field.DefaultValue = this.VisitLiteral(field.DefaultValue, changes.DefaultValue, deletions.DefaultValue, insertions.DefaultValue); +#if !NoXml + field.Documentation = changes.Documentation; +#endif + field.Flags = changes.Flags; + field.HidesBaseClassMember = changes.HidesBaseClassMember; + field.ImplementedInterfaces = this.VisitInterfaceReferenceList(field.ImplementedInterfaces, changes.ImplementedInterfaces, deletions.ImplementedInterfaces, insertions.ImplementedInterfaces); + field.InitialData = changes.InitialData; + field.Initializer = changes.Initializer; + field.MarshallingInformation = changes.MarshallingInformation; + field.Name = changes.Name; + field.Offset = changes.Offset; + field.OverridesBaseClassMember = changes.OverridesBaseClassMember; + field.Section = changes.Section; + field.Type = this.VisitTypeReference(field.Type, changes.Type); + } + } + else if (deletions != null) + return null; + return field; + } + public virtual Block VisitFieldInitializerBlock(FieldInitializerBlock block, FieldInitializerBlock changes, FieldInitializerBlock deletions, FieldInitializerBlock insertions) + { + this.UpdateSourceContext(block, changes); + if (block == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + block.IsStatic = changes.IsStatic; + } + } + else if (deletions != null) + return null; + return block; + } + public virtual FieldList VisitFieldList(FieldList fields, FieldList changes, FieldList deletions, FieldList insertions) + { + if (changes == null || deletions == null || insertions == null) return fields; + int n = fields == null ? 0 : fields.Count; + if (n > changes.Count) { Debug.Assert(false); n = changes.Count; } + if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; } + if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; } + if (fields != null) + for (int i = 0; i < n; i++) + fields[i] = this.VisitField(fields[i], changes[i], deletions[i], insertions[i]); + FieldList result = new FieldList(insertions.Count - n); + for (int i = n, m = insertions.Count; i < m; i++) + result.Add(insertions[i]); + return result; + } + public virtual Statement VisitFilter(Filter filter, Filter changes, Filter deletions, Filter insertions) + { + this.UpdateSourceContext(filter, changes); + if (filter == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + filter.Block = this.VisitBlock(filter.Block, changes.Block, deletions.Block, insertions.Block); + } + } + else if (deletions != null) + return null; + return filter; + } + public virtual FilterList VisitFilterList(FilterList filters, FilterList changes, FilterList deletions, FilterList insertions) + { + if (filters == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return filters; + } + public virtual Statement VisitFinally(Finally Finally, Finally changes, Finally deletions, Finally insertions) + { + this.UpdateSourceContext(Finally, changes); + if (Finally == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Finally; + } + public virtual Statement VisitFixed(Fixed Fixed, Fixed changes, Fixed deletions, Fixed insertions) + { + this.UpdateSourceContext(Fixed, changes); + if (Fixed == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Fixed; + } + public virtual Statement VisitFor(For For, For changes, For deletions, For insertions) + { + this.UpdateSourceContext(For, changes); + if (For == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return For; + } + public virtual Statement VisitForEach(ForEach forEach, ForEach changes, ForEach deletions, ForEach insertions) + { + this.UpdateSourceContext(forEach, changes); + if (forEach == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return forEach; + } + public virtual Statement VisitFunctionDeclaration(FunctionDeclaration functionDeclaration, FunctionDeclaration changes, FunctionDeclaration deletions, FunctionDeclaration insertions) + { + this.UpdateSourceContext(functionDeclaration, changes); + if (functionDeclaration == null) return changes; + return functionDeclaration; + } + public virtual Expression VisitTemplateInstance(TemplateInstance instance, TemplateInstance changes, TemplateInstance deletions, TemplateInstance insertions) + { + this.UpdateSourceContext(instance, changes); + if (instance == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return instance; + } + public virtual Expression VisitStackAlloc(StackAlloc alloc, StackAlloc changes, StackAlloc deletions, StackAlloc insertions) + { + this.UpdateSourceContext(alloc, changes); + if (alloc == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return alloc; + } + public virtual Statement VisitGoto(Goto Goto, Goto changes, Goto deletions, Goto insertions) + { + this.UpdateSourceContext(Goto, changes); + if (Goto == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Goto; + } + public virtual Statement VisitGotoCase(GotoCase gotoCase, GotoCase changes, GotoCase deletions, GotoCase insertions) + { + this.UpdateSourceContext(gotoCase, changes); + if (gotoCase == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return gotoCase; + } + public virtual Expression VisitIdentifier(Identifier identifier, Identifier changes, Identifier deletions, Identifier insertions) + { + this.UpdateSourceContext(identifier, changes); + if (identifier == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return identifier; + } + public virtual Statement VisitIf(If If, If changes, If deletions, If insertions) + { + this.UpdateSourceContext(If, changes); + if (If == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return If; + } + public virtual Expression VisitImplicitThis(ImplicitThis implicitThis, ImplicitThis changes, ImplicitThis deletions, ImplicitThis insertions) + { + this.UpdateSourceContext(implicitThis, changes); + if (implicitThis == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return implicitThis; + } + public virtual Expression VisitIndexer(Indexer indexer, Indexer changes, Indexer deletions, Indexer insertions) + { + this.UpdateSourceContext(indexer, changes); + if (indexer == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return indexer; + } + public virtual Interface VisitInterface(Interface Interface, Interface changes, Interface deletions, Interface insertions) + { + return (Interface)this.VisitTypeNode(Interface, changes, deletions, insertions); + } + public virtual InterfaceList VisitInterfaceReferenceList(InterfaceList interfaces, InterfaceList changes, InterfaceList deletions, InterfaceList insertions) + { + if (interfaces == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return interfaces; + } + public virtual Interface VisitInterfaceReference(Interface Interface, Interface changes) + { + return (Interface)this.VisitTypeReference(Interface, changes); + } + public virtual InstanceInitializer VisitInstanceInitializer(InstanceInitializer cons, InstanceInitializer changes, InstanceInitializer deletions, InstanceInitializer insertions) + { + return (InstanceInitializer)this.VisitMethod(cons, changes, deletions, insertions); + } + public virtual Statement VisitLabeledStatement(LabeledStatement lStatement, LabeledStatement changes, LabeledStatement deletions, LabeledStatement insertions) + { + this.UpdateSourceContext(lStatement, changes); + if (lStatement == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return lStatement; + } + public virtual Literal VisitLiteral(Literal literal, Literal changes, Literal deletions, Literal insertions) + { + this.UpdateSourceContext(literal, changes); + if (literal == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return literal; + } + public virtual Expression VisitLocal(Local local, Local changes, Local deletions, Local insertions) + { + this.UpdateSourceContext(local, changes); + if (local == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return local; + } + public virtual LocalDeclaration VisitLocalDeclaration(LocalDeclaration localDeclaration, LocalDeclaration changes, LocalDeclaration deletions, LocalDeclaration insertions) + { + this.UpdateSourceContext(localDeclaration, changes); + if (localDeclaration == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return localDeclaration; + } + public virtual LocalDeclarationList VisitLocalDeclarationList(LocalDeclarationList localDeclarations, LocalDeclarationList changes, LocalDeclarationList deletions, LocalDeclarationList insertions) + { + if (localDeclarations == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return localDeclarations; + } + public virtual Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations, LocalDeclarationsStatement changes, LocalDeclarationsStatement deletions, LocalDeclarationsStatement insertions) + { + this.UpdateSourceContext(localDeclarations, changes); + if (localDeclarations == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return localDeclarations; + } + public virtual Statement VisitLock(Lock Lock, Lock changes, Lock deletions, Lock insertions) + { + this.UpdateSourceContext(Lock, changes); + if (Lock == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Lock; + } + public virtual Expression VisitLRExpression(LRExpression expr, LRExpression changes, LRExpression deletions, LRExpression insertions) + { + this.UpdateSourceContext(expr, changes); + if (expr == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return expr; + } + public virtual Expression VisitMemberBinding(MemberBinding memberBinding, MemberBinding changes, MemberBinding deletions, MemberBinding insertions) + { + this.UpdateSourceContext(memberBinding, changes); + if (memberBinding == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return memberBinding; + } + public virtual MemberList VisitMemberList(MemberList members, MemberList changes, MemberList deletions, MemberList insertions) + { + if (members == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return members; + } + public virtual Method VisitMethod(Method method, Method changes, Method deletions, Method insertions) + { + this.UpdateSourceContext(method, changes); + if (method == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return method; + } + public virtual Expression VisitMethodCall(MethodCall call, MethodCall changes, MethodCall deletions, MethodCall insertions) + { + this.UpdateSourceContext(call, changes); + if (call == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return call; + } + public virtual Method VisitMethodReference(Method method, Method changes) + { + return method; + } + public virtual MethodList VisitMethodReferenceList(MethodList methodList, MethodList changesList) + { + return methodList; + } + public virtual Module VisitModule(Module module, Module changes, Module deletions, Module insertions) + { + this.UpdateSourceContext(module, changes); + if (module == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return module; + } + public virtual ModuleReference VisitModuleReference(ModuleReference moduleReference, ModuleReference changes, ModuleReference deletions, ModuleReference insertions) + { + this.UpdateSourceContext(moduleReference, changes); + if (moduleReference == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return moduleReference; + } + public virtual ModuleReferenceList VisitModuleReferenceList(ModuleReferenceList moduleReferences, ModuleReferenceList changes, ModuleReferenceList deletions, ModuleReferenceList insertions) + { + return moduleReferences; + } + public virtual Expression VisitNameBinding(NameBinding nameBinding, NameBinding changes, NameBinding deletions, NameBinding insertions) + { + this.UpdateSourceContext(nameBinding, changes); + if (nameBinding == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return nameBinding; + } + public virtual Expression VisitNamedArgument(NamedArgument namedArgument, NamedArgument changes, NamedArgument deletions, NamedArgument insertions) + { + this.UpdateSourceContext(namedArgument, changes); + if (namedArgument == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return namedArgument; + } + public virtual Namespace VisitNamespace(Namespace nspace, Namespace changes, Namespace deletions, Namespace insertions) + { + this.UpdateSourceContext(nspace, changes); + if (nspace == null) return changes; + return nspace; + } + public virtual NamespaceList VisitNamespaceList(NamespaceList namespaces, NamespaceList changes, NamespaceList deletions, NamespaceList insertions) + { + if (namespaces == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return namespaces; + } + public virtual NodeList VisitNodeList(NodeList nodeList, NodeList changes, NodeList deletions, NodeList insertions) + { + if (changes == null || deletions == null || insertions == null) return nodeList; + int n = nodeList == null ? 0 : nodeList.Count; + if (n > changes.Count) { Debug.Assert(false); n = changes.Count; } + if (n > deletions.Count) { Debug.Assert(false); n = deletions.Count; } + if (n > insertions.Count) { Debug.Assert(false); n = insertions.Count; } + if (nodeList != null) + for (int i = 0; i < n; i++) + nodeList[i] = this.Visit(nodeList[i], changes[i], deletions[i], insertions[i]); + NodeList result = new NodeList(insertions.Count - n); + for (int i = n, m = insertions.Count; i < m; i++) + result.Add(insertions[i]); + return result; + } + public virtual Expression VisitParameter(Parameter parameter, Parameter changes, Parameter deletions, Parameter insertions) + { + this.UpdateSourceContext(parameter, changes); + if (parameter == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return parameter; + } + public virtual ParameterList VisitParameterList(ParameterList parameterList, ParameterList changes, ParameterList deletions, ParameterList insertions) + { + if (parameterList == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return parameterList; + } + public virtual Expression VisitPrefixExpression(PrefixExpression pExpr, PrefixExpression changes, PrefixExpression deletions, PrefixExpression insertions) + { + this.UpdateSourceContext(pExpr, changes); + if (pExpr == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return pExpr; + } + public virtual Expression VisitPostfixExpression(PostfixExpression pExpr, PostfixExpression changes, PostfixExpression deletions, PostfixExpression insertions) + { + this.UpdateSourceContext(pExpr, changes); + if (pExpr == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return pExpr; + } + public virtual Property VisitProperty(Property property, Property changes, Property deletions, Property insertions) + { + this.UpdateSourceContext(property, changes); + if (property == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return property; + } + public virtual Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier, QualifiedIdentifier changes, QualifiedIdentifier deletions, QualifiedIdentifier insertions) + { + this.UpdateSourceContext(qualifiedIdentifier, changes); + if (qualifiedIdentifier == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return qualifiedIdentifier; + } + public virtual Statement VisitRepeat(Repeat repeat, Repeat changes, Repeat deletions, Repeat insertions) + { + this.UpdateSourceContext(repeat, changes); + if (repeat == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return repeat; + } + public virtual Statement VisitResourceUse(ResourceUse resourceUse, ResourceUse changes, ResourceUse deletions, ResourceUse insertions) + { + this.UpdateSourceContext(resourceUse, changes); + if (resourceUse == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return resourceUse; + } + public virtual Statement VisitReturn(Return Return, Return changes, Return deletions, Return insertions) + { + this.UpdateSourceContext(Return, changes); + if (Return == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Return; + } + public virtual SecurityAttribute VisitSecurityAttribute(SecurityAttribute attribute, SecurityAttribute changes, SecurityAttribute deletions, SecurityAttribute insertions) + { + this.UpdateSourceContext(attribute, changes); + if (attribute == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return attribute; + } + public virtual SecurityAttributeList VisitSecurityAttributeList(SecurityAttributeList attributes, SecurityAttributeList changes, SecurityAttributeList deletions, SecurityAttributeList insertions) + { + if (attributes == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return attributes; + } + public virtual Expression VisitSetterValue(SetterValue value, SetterValue changes, SetterValue deletions, SetterValue insertions) + { + this.UpdateSourceContext(value, changes); + if (value == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return value; + } + public virtual StatementList VisitStatementList(StatementList statements, StatementList changes, StatementList deletions, StatementList insertions) + { + if (statements == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return statements; + } + public virtual StatementSnippet VisitStatementSnippet(StatementSnippet snippet, StatementSnippet changes, StatementSnippet deletions, StatementSnippet insertions) + { + this.UpdateSourceContext(snippet, changes); + if (snippet == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return snippet; + } + public virtual StaticInitializer VisitStaticInitializer(StaticInitializer cons, StaticInitializer changes, StaticInitializer deletions, StaticInitializer insertions) + { + return (StaticInitializer)this.VisitMethod(cons, changes, deletions, insertions); + } + public virtual Struct VisitStruct(Struct Struct, Struct changes, Struct deletions, Struct insertions) + { + return (Struct)this.VisitTypeNode(Struct, changes, deletions, insertions); + } + public virtual Statement VisitSwitch(Switch Switch, Switch changes, Switch deletions, Switch insertions) + { + this.UpdateSourceContext(Switch, changes); + if (Switch == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Switch; + } + public virtual SwitchCase VisitSwitchCase(SwitchCase switchCase, SwitchCase changes, SwitchCase deletions, SwitchCase insertions) + { + this.UpdateSourceContext(switchCase, changes); + if (switchCase == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return switchCase; + } + public virtual SwitchCaseList VisitSwitchCaseList(SwitchCaseList switchCases, SwitchCaseList changes, SwitchCaseList deletions, SwitchCaseList insertions) + { + if (switchCases == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return switchCases; + } + public virtual Statement VisitSwitchInstruction(SwitchInstruction switchInstruction, SwitchInstruction changes, SwitchInstruction deletions, SwitchInstruction insertions) + { + this.UpdateSourceContext(switchInstruction, changes); + if (switchInstruction == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return switchInstruction; + } + public virtual Statement VisitTypeswitch(Typeswitch Typeswitch, Typeswitch changes, Typeswitch deletions, Typeswitch insertions) + { + this.UpdateSourceContext(Typeswitch, changes); + if (Typeswitch == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Typeswitch; + } + public virtual TypeswitchCase VisitTypeswitchCase(TypeswitchCase typeswitchCase, TypeswitchCase changes, TypeswitchCase deletions, TypeswitchCase insertions) + { + this.UpdateSourceContext(typeswitchCase, changes); + if (typeswitchCase == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return typeswitchCase; + } + public virtual TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases, TypeswitchCaseList changes, TypeswitchCaseList deletions, TypeswitchCaseList insertions) + { + if (typeswitchCases == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return typeswitchCases; + } + public virtual Expression VisitTargetExpression(Expression expression, Expression changes, Expression deletions, Expression insertions) + { + return this.VisitExpression(expression, changes, deletions, insertions); + } + public virtual Expression VisitTernaryExpression(TernaryExpression expression, TernaryExpression changes, TernaryExpression deletions, TernaryExpression insertions) + { + this.UpdateSourceContext(expression, changes); + if (expression == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return expression; + } + public virtual Expression VisitThis(This This, This changes, This deletions, This insertions) + { + this.UpdateSourceContext(This, changes); + if (This == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return This; + } + public virtual Statement VisitThrow(Throw Throw, Throw changes, Throw deletions, Throw insertions) + { + this.UpdateSourceContext(Throw, changes); + if (Throw == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Throw; + } + public virtual Statement VisitTry(Try Try, Try changes, Try deletions, Try insertions) + { + this.UpdateSourceContext(Try, changes); + if (Try == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Try; + } +#if ExtendedRuntime + public virtual TupleType VisitTupleType(TupleType tuple, TupleType changes, TupleType deletions, TupleType insertions){ + return (TupleType)this.VisitTypeNode(tuple, changes, deletions, insertions); + } + public virtual TypeAlias VisitTypeAlias(TypeAlias tAlias, TypeAlias changes, TypeAlias deletions, TypeAlias insertions){ + this.UpdateSourceContext(tAlias, changes); + if (tAlias == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return tAlias; + } + public virtual TypeIntersection VisitTypeIntersection(TypeIntersection typeIntersection, TypeIntersection changes, TypeIntersection deletions, TypeIntersection insertions){ + return (TypeIntersection)this.VisitTypeNode(typeIntersection, changes, deletions, insertions); + } +#endif + public virtual TypeMemberSnippet VisitTypeMemberSnippet(TypeMemberSnippet snippet, TypeMemberSnippet changes, TypeMemberSnippet deletions, TypeMemberSnippet insertions) + { + this.UpdateSourceContext(snippet, changes); + return snippet; + } + public virtual TypeModifier VisitTypeModifier(TypeModifier typeModifier, TypeModifier changes, TypeModifier deletions, TypeModifier insertions) + { + this.UpdateSourceContext(typeModifier, changes); + if (typeModifier == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return typeModifier; + } + public virtual TypeNode VisitTypeNode(TypeNode typeNode, TypeNode changes, TypeNode deletions, TypeNode insertions) + { + this.UpdateSourceContext(typeNode, changes); + if (typeNode == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return typeNode; + } + public virtual TypeNodeList VisitTypeNodeList(TypeNodeList types, TypeNodeList changes, TypeNodeList deletions, TypeNodeList insertions) + { + if (types == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return types; + } + public virtual TypeNode VisitTypeParameter(TypeNode typeParameter, TypeNode changes, TypeNode deletions, TypeNode insertions) + { + this.UpdateSourceContext(typeParameter, changes); + if (typeParameter == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return typeParameter; + } + public virtual TypeNodeList VisitTypeParameterList(TypeNodeList typeParameters, TypeNodeList changes, TypeNodeList deletions, TypeNodeList insertions) + { + if (typeParameters == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return typeParameters; + } + public virtual TypeNode VisitTypeReference(TypeNode type, TypeNode changes) + { + return type; + } + public virtual TypeReference VisitTypeReference(TypeReference type, TypeReference changes, TypeReference deletions, TypeReference insertions) + { + return type; + } + public virtual TypeNodeList VisitTypeReferenceList(TypeNodeList typeReferences, TypeNodeList changes, TypeNodeList deletions, TypeNodeList insertions) + { + if (typeReferences == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return typeReferences; + } +#if ExtendedRuntime + public virtual TypeUnion VisitTypeUnion(TypeUnion typeUnion, TypeUnion changes, TypeUnion deletions, TypeUnion insertions){ + return (TypeUnion)this.VisitTypeNode(typeUnion, changes, deletions, insertions); + } +#endif + public virtual Expression VisitUnaryExpression(UnaryExpression unaryExpression, UnaryExpression changes, UnaryExpression deletions, UnaryExpression insertions) + { + this.UpdateSourceContext(unaryExpression, changes); + if (unaryExpression == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return unaryExpression; + } + public virtual Statement VisitVariableDeclaration(VariableDeclaration variableDeclaration, VariableDeclaration changes, VariableDeclaration deletions, VariableDeclaration insertions) + { + this.UpdateSourceContext(variableDeclaration, changes); + if (variableDeclaration == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return variableDeclaration; + } + public virtual UsedNamespace VisitUsedNamespace(UsedNamespace usedNamespace, UsedNamespace changes, UsedNamespace deletions, UsedNamespace insertions) + { + this.UpdateSourceContext(usedNamespace, changes); + if (usedNamespace == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return usedNamespace; + } + public virtual UsedNamespaceList VisitUsedNamespaceList(UsedNamespaceList usedNspaces, UsedNamespaceList changes, UsedNamespaceList deletions, UsedNamespaceList insertions) + { + if (usedNspaces == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return usedNspaces; + } + public virtual Statement VisitWhile(While While, While changes, While deletions, While insertions) + { + this.UpdateSourceContext(While, changes); + if (While == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return While; + } + public virtual Statement VisitYield(Yield Yield, Yield changes, Yield deletions, Yield insertions) + { + this.UpdateSourceContext(Yield, changes); + if (Yield == null) return changes; + if (changes != null) + { + if (deletions == null || insertions == null) + Debug.Assert(false); + else + { + } + } + else if (deletions != null) + return null; + return Yield; + } +#if ExtendedRuntime + // query nodes + public virtual Node VisitQueryAggregate(QueryAggregate qa, QueryAggregate changes, QueryAggregate deletions, QueryAggregate insertions){ + this.UpdateSourceContext(qa, changes); + if (qa == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return qa; + } + public virtual Node VisitQueryAlias(QueryAlias alias, QueryAlias changes, QueryAlias deletions, QueryAlias insertions){ + this.UpdateSourceContext(alias, changes); + if (alias == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return alias; + } + public virtual Node VisitQueryAxis(QueryAxis axis, QueryAxis changes, QueryAxis deletions, QueryAxis insertions){ + this.UpdateSourceContext(axis, changes); + if (axis == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return axis; + } + public virtual Node VisitQueryCommit(QueryCommit qc, QueryCommit changes, QueryCommit deletions, QueryCommit insertions){ + this.UpdateSourceContext(qc, changes); + if (qc == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return qc; + } + public virtual Node VisitQueryContext(QueryContext context, QueryContext changes, QueryContext deletions, QueryContext insertions){ + this.UpdateSourceContext(context, changes); + if (context == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return context; + } + public virtual Node VisitQueryDelete(QueryDelete delete, QueryDelete changes, QueryDelete deletions, QueryDelete insertions){ + this.UpdateSourceContext(delete, changes); + if (delete == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return delete; + } + public virtual Node VisitQueryDifference(QueryDifference diff, QueryDifference changes, QueryDifference deletions, QueryDifference insertions){ + this.UpdateSourceContext(diff, changes); + if (diff == null) return changes; + return diff; + } + public virtual Node VisitQueryDistinct(QueryDistinct distinct, QueryDistinct changes, QueryDistinct deletions, QueryDistinct insertions){ + this.UpdateSourceContext(distinct, changes); + if (distinct == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return distinct; + } + public virtual Node VisitQueryExists(QueryExists exists, QueryExists changes, QueryExists deletions, QueryExists insertions){ + this.UpdateSourceContext(exists, changes); + if (exists == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return exists; + } + public virtual Node VisitQueryFilter(QueryFilter filter, QueryFilter changes, QueryFilter deletions, QueryFilter insertions){ + this.UpdateSourceContext(filter, changes); + if (filter == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return filter; + } + public virtual Node VisitQueryGroupBy(QueryGroupBy groupby, QueryGroupBy changes, QueryGroupBy deletions, QueryGroupBy insertions){ + this.UpdateSourceContext(groupby, changes); + if (groupby == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return groupby; + } + public virtual Statement VisitQueryGeneratedType(QueryGeneratedType qgt, QueryGeneratedType changes, QueryGeneratedType deletions, QueryGeneratedType insertions){ + this.UpdateSourceContext(qgt, changes); + if (qgt == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return qgt; + } + public virtual Node VisitQueryInsert(QueryInsert insert, QueryInsert changes, QueryInsert deletions, QueryInsert insertions){ + this.UpdateSourceContext(insert, changes); + if (insert == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return insert; + } + public virtual Node VisitQueryIntersection(QueryIntersection intersection, QueryIntersection changes, QueryIntersection deletions, QueryIntersection insertions){ + this.UpdateSourceContext(intersection, changes); + if (intersection == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return intersection; + } + public virtual Node VisitQueryIterator(QueryIterator xiterator, QueryIterator changes, QueryIterator deletions, QueryIterator insertions){ + this.UpdateSourceContext(xiterator, changes); + if (xiterator == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return xiterator; + } + public virtual Node VisitQueryJoin(QueryJoin join, QueryJoin changes, QueryJoin deletions, QueryJoin insertions){ + this.UpdateSourceContext(join, changes); + if (join == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return join; + } + public virtual Node VisitQueryLimit(QueryLimit limit, QueryLimit changes, QueryLimit deletions, QueryLimit insertions){ + this.UpdateSourceContext(limit, changes); + if (limit == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return limit; + } + public virtual Node VisitQueryOrderBy(QueryOrderBy orderby, QueryOrderBy changes, QueryOrderBy deletions, QueryOrderBy insertions){ + this.UpdateSourceContext(orderby, changes); + if (orderby == null) return changes; + return orderby; + } + public virtual Node VisitQueryOrderItem(QueryOrderItem item, QueryOrderItem changes, QueryOrderItem deletions, QueryOrderItem insertions){ + this.UpdateSourceContext(item, changes); + if (item == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return item; + } + public virtual Node VisitQueryPosition(QueryPosition position, QueryPosition changes, QueryPosition deletions, QueryPosition insertions){ + this.UpdateSourceContext(position, changes); + if (position == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return position; + } + public virtual Node VisitQueryProject(QueryProject project, QueryProject changes, QueryProject deletions, QueryProject insertions){ + this.UpdateSourceContext(project, changes); + if (project == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return project; + } + public virtual Node VisitQueryRollback(QueryRollback qr, QueryRollback changes, QueryRollback deletions, QueryRollback insertions){ + this.UpdateSourceContext(qr, changes); + if (qr == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return qr; + } + public virtual Node VisitQueryQuantifier(QueryQuantifier qq, QueryQuantifier changes, QueryQuantifier deletions, QueryQuantifier insertions){ + this.UpdateSourceContext(qq, changes); + if (qq == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return qq; + } + public virtual Node VisitQueryQuantifiedExpression(QueryQuantifiedExpression qqe, QueryQuantifiedExpression changes, QueryQuantifiedExpression deletions, QueryQuantifiedExpression insertions){ + this.UpdateSourceContext(qqe, changes); + if (qqe == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return qqe; + } + public virtual Node VisitQuerySelect(QuerySelect select, QuerySelect changes, QuerySelect deletions, QuerySelect insertions){ + this.UpdateSourceContext(select, changes); + if (select == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return select; + } + public virtual Node VisitQuerySingleton(QuerySingleton singleton, QuerySingleton changes, QuerySingleton deletions, QuerySingleton insertions){ + this.UpdateSourceContext(singleton, changes); + if (singleton == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return singleton; + } + public virtual Node VisitQueryTransact(QueryTransact qt, QueryTransact changes, QueryTransact deletions, QueryTransact insertions){ + this.UpdateSourceContext(qt, changes); + if (qt == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return qt; + } + public virtual Node VisitQueryTypeFilter(QueryTypeFilter filter, QueryTypeFilter changes, QueryTypeFilter deletions, QueryTypeFilter insertions){ + this.UpdateSourceContext(filter, changes); + if (filter == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return filter; + } + public virtual Node VisitQueryUnion(QueryUnion union, QueryUnion changes, QueryUnion deletions, QueryUnion insertions){ + this.UpdateSourceContext(union, changes); + if (union == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return union; + } + public virtual Node VisitQueryUpdate(QueryUpdate update, QueryUpdate changes, QueryUpdate deletions, QueryUpdate insertions){ + this.UpdateSourceContext(update, changes); + if (update == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return update; + } + public virtual Node VisitQueryYielder(QueryYielder yielder, QueryYielder changes, QueryYielder deletions, QueryYielder insertions){ + this.UpdateSourceContext(yielder, changes); + if (yielder == null) return changes; + if (changes != null){ + if (deletions == null || insertions == null) + Debug.Assert(false); + else{ + } + }else if (deletions != null) + return null; + return yielder; + } +#endif + } +} +#endif
\ No newline at end of file |