// 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.Collections;
using System.Diagnostics;
#if CCINamespace
namespace Microsoft.Cci{
#else
namespace System.Compiler
{
#endif
///
/// Base for all classes that process two IR trees, possibily transforming one of them.
///
public abstract class DoubleVisitor
{
///
/// Switches on node.NodeType to call a visitor method that has been specialized for node.
///
/// Returns null if node1 is null. Otherwise returns an updated node (possibly a different object).
public abstract Node Visit(Node node1, Node node2);
///
/// Transfers the state from one visitor to another. This enables separate visitor instances to cooperative process a single IR.
///
public virtual void TransferStateTo(DoubleVisitor targetVisitor)
{
}
}
///
/// Walks an IR, mutuating it into a new form
///
public abstract class StandardDoubleVisitor : DoubleVisitor
{
public DoubleVisitor callingVisitor;
protected StandardDoubleVisitor()
{
}
protected StandardDoubleVisitor(DoubleVisitor callingVisitor)
{
this.callingVisitor = callingVisitor;
}
public virtual Node VisitUnknownNodeType(Node node1, Node node2)
{
if (node1 == null) { Debug.Fail(""); return null; }
DoubleVisitor visitor = this.GetVisitorFor(node1);
if (visitor == null) return node1;
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);
node1 = visitor.Visit(node1, node2);
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 node1;
}
public virtual DoubleVisitor GetVisitorFor(Node/*!*/ node1)
{
if (node1 == null) { Debug.Fail(""); return null; }
return (DoubleVisitor)node1.GetVisitorFor(this, this.GetType().Name);
}
public override Node Visit(Node node1, Node node2)
{
if (node1 == null) return null;
switch (node1.NodeType)
{
case NodeType.AddressDereference:
return this.VisitAddressDereference((AddressDereference)node1, node2 as AddressDereference);
case NodeType.AliasDefinition:
return this.VisitAliasDefinition((AliasDefinition)node1, node2 as AliasDefinition);
case NodeType.AnonymousNestedFunction:
return this.VisitAnonymousNestedFunction((AnonymousNestedFunction)node1, node2 as AnonymousNestedFunction);
case NodeType.ApplyToAll:
return this.VisitApplyToAll((ApplyToAll)node1, node2 as ApplyToAll);
case NodeType.Arglist:
return this.VisitExpression((Expression)node1, node2 as Expression);
case NodeType.ArrayType:
Debug.Assert(false); return null;
case NodeType.Assembly:
return this.VisitAssembly((AssemblyNode)node1, node2 as AssemblyNode);
case NodeType.AssemblyReference:
return this.VisitAssemblyReference((AssemblyReference)node1, node2 as AssemblyReference);
case NodeType.Assertion:
return this.VisitAssertion((Assertion)node1, node2 as Assertion);
case NodeType.Assumption:
return this.VisitAssumption((Assumption)node1, node2 as Assumption);
case NodeType.AssignmentExpression:
return this.VisitAssignmentExpression((AssignmentExpression)node1, node2 as AssignmentExpression);
case NodeType.AssignmentStatement:
return this.VisitAssignmentStatement((AssignmentStatement)node1, node2 as AssignmentStatement);
case NodeType.Attribute:
return this.VisitAttributeNode((AttributeNode)node1, node2 as AttributeNode);
case NodeType.Base:
return this.VisitBase((Base)node1, node2 as Base);
case NodeType.Block:
return this.VisitBlock((Block)node1, node2 as Block);
case NodeType.BlockExpression:
return this.VisitBlockExpression((BlockExpression)node1, node2 as BlockExpression);
case NodeType.Branch:
return this.VisitBranch((Branch)node1, node2 as Branch);
case NodeType.Compilation:
return this.VisitCompilation((Compilation)node1, node2 as Compilation);
case NodeType.CompilationUnit:
return this.VisitCompilationUnit((CompilationUnit)node1, node2 as CompilationUnit);
case NodeType.CompilationUnitSnippet:
return this.VisitCompilationUnitSnippet((CompilationUnitSnippet)node1, node2 as CompilationUnitSnippet);
#if ExtendedRuntime
case NodeType.ConstrainedType:
return this.VisitConstrainedType((ConstrainedType)node1, node2 as ConstrainedType);
#endif
case NodeType.Continue:
return this.VisitContinue((Continue)node1, node2 as Continue);
case NodeType.CurrentClosure:
return this.VisitCurrentClosure((CurrentClosure)node1, node2 as CurrentClosure);
case NodeType.DebugBreak:
return node1;
case NodeType.Call:
case NodeType.Calli:
case NodeType.Callvirt:
case NodeType.Jmp:
case NodeType.MethodCall:
return this.VisitMethodCall((MethodCall)node1, node2 as MethodCall);
case NodeType.Catch:
return this.VisitCatch((Catch)node1, node2 as Catch);
case NodeType.Class:
return this.VisitClass((Class)node1, node2 as Class);
case NodeType.CoerceTuple:
return this.VisitCoerceTuple((CoerceTuple)node1, node2 as CoerceTuple);
case NodeType.CollectionEnumerator:
return this.VisitCollectionEnumerator((CollectionEnumerator)node1, node2 as CollectionEnumerator);
case NodeType.Composition:
return this.VisitComposition((Composition)node1, node2 as Composition);
case NodeType.Construct:
return this.VisitConstruct((Construct)node1, node2 as Construct);
case NodeType.ConstructArray:
return this.VisitConstructArray((ConstructArray)node1, node2 as ConstructArray);
case NodeType.ConstructDelegate:
return this.VisitConstructDelegate((ConstructDelegate)node1, node2 as ConstructDelegate);
case NodeType.ConstructFlexArray:
return this.VisitConstructFlexArray((ConstructFlexArray)node1, node2 as ConstructFlexArray);
case NodeType.ConstructIterator:
return this.VisitConstructIterator((ConstructIterator)node1, node2 as ConstructIterator);
case NodeType.ConstructTuple:
return this.VisitConstructTuple((ConstructTuple)node1, node2 as ConstructTuple);
case NodeType.DelegateNode:
return this.VisitDelegateNode((DelegateNode)node1, node2 as DelegateNode);
case NodeType.DoWhile:
return this.VisitDoWhile((DoWhile)node1, node2 as DoWhile);
case NodeType.Dup:
return this.VisitExpression((Expression)node1, node2 as Expression);
case NodeType.EndFilter:
return this.VisitEndFilter((EndFilter)node1, node2 as EndFilter);
case NodeType.EndFinally:
return this.VisitEndFinally((EndFinally)node1, node2 as EndFinally);
case NodeType.EnumNode:
return this.VisitEnumNode((EnumNode)node1, node2 as EnumNode);
case NodeType.Event:
return this.VisitEvent((Event)node1, node2 as Event);
#if ExtendedRuntime
case NodeType.EnsuresExceptional :
return this.VisitEnsuresExceptional((EnsuresExceptional)node1, node2 as EnsuresExceptional);
#endif
case NodeType.Exit:
return this.VisitExit((Exit)node1, node2 as Exit);
case NodeType.Read:
case NodeType.Write:
return this.VisitExpose((Expose)node1, node2 as Expose);
case NodeType.ExpressionSnippet:
return this.VisitExpressionSnippet((ExpressionSnippet)node1, node2 as ExpressionSnippet);
case NodeType.ExpressionStatement:
return this.VisitExpressionStatement((ExpressionStatement)node1, node2 as ExpressionStatement);
case NodeType.FaultHandler:
return this.VisitFaultHandler((FaultHandler)node1, node2 as FaultHandler);
case NodeType.Field:
return this.VisitField((Field)node1, node2 as Field);
case NodeType.FieldInitializerBlock:
return this.VisitFieldInitializerBlock((FieldInitializerBlock)node1, node2 as FieldInitializerBlock);
case NodeType.Finally:
return this.VisitFinally((Finally)node1, node2 as Finally);
case NodeType.Filter:
return this.VisitFilter((Filter)node1, node2 as Filter);
case NodeType.Fixed:
return this.VisitFixed((Fixed)node1, node2 as Fixed);
case NodeType.For:
return this.VisitFor((For)node1, node2 as For);
case NodeType.ForEach:
return this.VisitForEach((ForEach)node1, node2 as ForEach);
case NodeType.FunctionDeclaration:
return this.VisitFunctionDeclaration((FunctionDeclaration)node1, node2 as FunctionDeclaration);
case NodeType.Goto:
return this.VisitGoto((Goto)node1, node2 as Goto);
case NodeType.GotoCase:
return this.VisitGotoCase((GotoCase)node1, node2 as GotoCase);
case NodeType.Identifier:
return this.VisitIdentifier((Identifier)node1, node2 as Identifier);
case NodeType.If:
return this.VisitIf((If)node1, node2 as If);
case NodeType.ImplicitThis:
return this.VisitImplicitThis((ImplicitThis)node1, node2 as ImplicitThis);
case NodeType.Indexer:
return this.VisitIndexer((Indexer)node1, node2 as Indexer);
case NodeType.InstanceInitializer:
return this.VisitInstanceInitializer((InstanceInitializer)node1, node2 as InstanceInitializer);
case NodeType.Interface:
return this.VisitInterface((Interface)node1, node2 as Interface);
#if ExtendedRuntime
case NodeType.Invariant :
return this.VisitInvariant((Invariant)node1, node2 as Invariant);
#endif
case NodeType.LabeledStatement:
return this.VisitLabeledStatement((LabeledStatement)node1, node2 as LabeledStatement);
case NodeType.Literal:
return this.VisitLiteral((Literal)node1, node2 as Literal);
case NodeType.Local:
return this.VisitLocal((Local)node1, node2 as Local);
case NodeType.LocalDeclaration:
return this.VisitLocalDeclaration((LocalDeclaration)node1, node2 as LocalDeclaration);
case NodeType.LocalDeclarationsStatement:
return this.VisitLocalDeclarationsStatement((LocalDeclarationsStatement)node1, node2 as LocalDeclarationsStatement);
case NodeType.Lock:
return this.VisitLock((Lock)node1, node2 as Lock);
case NodeType.LRExpression:
return this.VisitLRExpression((LRExpression)node1, node2 as LRExpression);
case NodeType.MemberBinding:
return this.VisitMemberBinding((MemberBinding)node1, node2 as MemberBinding);
case NodeType.Method:
return this.VisitMethod((Method)node1, node2 as Method);
#if ExtendedRuntime
case NodeType.MethodContract :
return this.VisitMethodContract((MethodContract)node1, node2 as MethodContract);
#endif
case NodeType.TemplateInstance:
return this.VisitTemplateInstance((TemplateInstance)node1, node2 as TemplateInstance);
case NodeType.StackAlloc:
return this.VisitStackAlloc((StackAlloc)node1, node2 as StackAlloc);
case NodeType.Module:
return this.VisitModule((Module)node1, node2 as Module);
case NodeType.ModuleReference:
return this.VisitModuleReference((ModuleReference)node1, node2 as ModuleReference);
case NodeType.NameBinding:
return this.VisitNameBinding((NameBinding)node1, node2 as NameBinding);
case NodeType.NamedArgument:
return this.VisitNamedArgument((NamedArgument)node1, node2 as NamedArgument);
case NodeType.Namespace:
return this.VisitNamespace((Namespace)node1, node2 as Namespace);
case NodeType.Nop:
return node1;
#if ExtendedRuntime
case NodeType.EnsuresNormal :
return this.VisitEnsuresNormal((EnsuresNormal)node1, node2 as EnsuresNormal);
case NodeType.OldExpression :
return this.VisitOldExpression((OldExpression)node1, node2 as OldExpression);
case NodeType.RequiresOtherwise :
return this.VisitRequiresOtherwise((RequiresOtherwise)node1, node2 as RequiresOtherwise);
case NodeType.RequiresPlain :
return this.VisitRequiresPlain((RequiresPlain)node1, node2 as RequiresPlain);
#endif
case NodeType.OptionalModifier:
case NodeType.RequiredModifier:
return this.VisitTypeModifier((TypeModifier)node1, node2 as TypeModifier);
case NodeType.Parameter:
return this.VisitParameter((Parameter)node1, node2 as Parameter);
case NodeType.Pop:
return this.VisitExpression((Expression)node1, node2 as Expression);
case NodeType.PrefixExpression:
return this.VisitPrefixExpression((PrefixExpression)node1, node2 as PrefixExpression);
case NodeType.PostfixExpression:
return this.VisitPostfixExpression((PostfixExpression)node1, node2 as PostfixExpression);
case NodeType.Property:
return this.VisitProperty((Property)node1, node2 as Property);
case NodeType.Quantifier:
return this.VisitQuantifier((Quantifier)node1, node2 as Quantifier);
case NodeType.Comprehension:
return this.VisitComprehension((Comprehension)node1, node2 as Comprehension);
case NodeType.ComprehensionBinding:
return this.VisitComprehensionBinding((ComprehensionBinding)node1, node2 as ComprehensionBinding);
case NodeType.QualifiedIdentifer:
return this.VisitQualifiedIdentifier((QualifiedIdentifier)node1, node2 as QualifiedIdentifier);
case NodeType.Rethrow:
case NodeType.Throw:
return this.VisitThrow((Throw)node1, node2 as Throw);
case NodeType.Return:
return this.VisitReturn((Return)node1, node2 as Return);
case NodeType.ResourceUse:
return this.VisitResourceUse((ResourceUse)node1, node2 as ResourceUse);
case NodeType.Repeat:
return this.VisitRepeat((Repeat)node1, node2 as Repeat);
case NodeType.SecurityAttribute:
return this.VisitSecurityAttribute((SecurityAttribute)node1, node2 as SecurityAttribute);
case NodeType.SetterValue:
return this.VisitSetterValue((SetterValue)node1, node2 as SetterValue);
case NodeType.StaticInitializer:
return this.VisitStaticInitializer((StaticInitializer)node1, node2 as StaticInitializer);
case NodeType.StatementSnippet:
return this.VisitStatementSnippet((StatementSnippet)node1, node2 as StatementSnippet);
case NodeType.Struct:
return this.VisitStruct((Struct)node1, node2 as Struct);
case NodeType.Switch:
return this.VisitSwitch((Switch)node1, node2 as Switch);
case NodeType.SwitchCase:
return this.VisitSwitchCase((SwitchCase)node1, node2 as SwitchCase);
case NodeType.SwitchInstruction:
return this.VisitSwitchInstruction((SwitchInstruction)node1, node2 as SwitchInstruction);
case NodeType.Typeswitch:
return this.VisitTypeswitch((Typeswitch)node1, node2 as Typeswitch);
case NodeType.TypeswitchCase:
return this.VisitTypeswitchCase((TypeswitchCase)node1, node2 as TypeswitchCase);
case NodeType.This:
return this.VisitThis((This)node1, node2 as This);
case NodeType.Try:
return this.VisitTry((Try)node1, node2 as Try);
#if ExtendedRuntime
case NodeType.TupleType:
return this.VisitTupleType((TupleType)node1, node2 as TupleType);
case NodeType.TypeAlias:
return this.VisitTypeAlias((TypeAlias)node1, node2 as TypeAlias);
case NodeType.TypeIntersection:
return this.VisitTypeIntersection((TypeIntersection)node1, node2 as TypeIntersection);
case NodeType.TypeContract :
return this.VisitTypeContract((TypeContract)node1, node2 as TypeContract);
#endif
case NodeType.TypeMemberSnippet:
return this.VisitTypeMemberSnippet((TypeMemberSnippet)node1, node2 as TypeMemberSnippet);
case NodeType.ClassParameter:
case NodeType.TypeParameter:
return this.VisitTypeParameter((TypeNode)node1, node2 as TypeNode);
#if ExtendedRuntime
case NodeType.TypeUnion:
return this.VisitTypeUnion((TypeUnion)node1, node2 as TypeUnion);
#endif
case NodeType.TypeReference:
return this.VisitTypeReference((TypeReference)node1, node2 as TypeReference);
case NodeType.UsedNamespace:
return this.VisitUsedNamespace((UsedNamespace)node1, node2 as UsedNamespace);
case NodeType.VariableDeclaration:
return this.VisitVariableDeclaration((VariableDeclaration)node1, node2 as VariableDeclaration);
case NodeType.While:
return this.VisitWhile((While)node1, node2 as While);
case NodeType.Yield:
return this.VisitYield((Yield)node1, node2 as Yield);
case NodeType.Conditional:
case NodeType.Cpblk:
case NodeType.Initblk:
return this.VisitTernaryExpression((TernaryExpression)node1, node2 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.Mkrefany:
case NodeType.Maplet:
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)node1, node2 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)node1, node2 as UnaryExpression);
#if ExtendedRuntime
// query node1 types
case NodeType.QueryAggregate:
return this.VisitQueryAggregate((QueryAggregate)node1, node2 as QueryAggregate);
case NodeType.QueryAlias:
return this.VisitQueryAlias((QueryAlias)node1, node2 as QueryAlias);
case NodeType.QueryAll:
case NodeType.QueryAny:
return this.VisitQueryQuantifier((QueryQuantifier)node1, node2 as QueryQuantifier);
case NodeType.QueryAxis:
return this.VisitQueryAxis((QueryAxis)node1, node2 as QueryAxis);
case NodeType.QueryCommit:
return this.VisitQueryCommit((QueryCommit)node1, node2 as QueryCommit);
case NodeType.QueryContext:
return this.VisitQueryContext((QueryContext)node1, node2 as QueryContext);
case NodeType.QueryDelete:
return this.VisitQueryDelete((QueryDelete)node1, node2 as QueryDelete);
case NodeType.QueryDifference:
return this.VisitQueryDifference((QueryDifference)node1, node2 as QueryDifference);
case NodeType.QueryDistinct:
return this.VisitQueryDistinct((QueryDistinct)node1, node2 as QueryDistinct);
case NodeType.QueryExists:
return this.VisitQueryExists((QueryExists)node1, node2 as QueryExists);
case NodeType.QueryFilter:
return this.VisitQueryFilter((QueryFilter)node1, node2 as QueryFilter);
case NodeType.QueryGeneratedType:
return this.VisitQueryGeneratedType((QueryGeneratedType)node1, node2 as QueryGeneratedType);
case NodeType.QueryGroupBy:
return this.VisitQueryGroupBy((QueryGroupBy)node1, node2 as QueryGroupBy);
case NodeType.QueryInsert:
return this.VisitQueryInsert((QueryInsert)node1, node2 as QueryInsert);
case NodeType.QueryIntersection:
return this.VisitQueryIntersection((QueryIntersection)node1, node2 as QueryIntersection);
case NodeType.QueryIterator:
return this.VisitQueryIterator((QueryIterator)node1, node2 as QueryIterator);
case NodeType.QueryJoin:
return this.VisitQueryJoin((QueryJoin)node1, node2 as QueryJoin);
case NodeType.QueryLimit:
return this.VisitQueryLimit((QueryLimit)node1, node2 as QueryLimit);
case NodeType.QueryOrderBy:
return this.VisitQueryOrderBy((QueryOrderBy)node1, node2 as QueryOrderBy);
case NodeType.QueryOrderItem:
return this.VisitQueryOrderItem((QueryOrderItem)node1, node2 as QueryOrderItem);
case NodeType.QueryPosition:
return this.VisitQueryPosition((QueryPosition)node1, node2 as QueryPosition);
case NodeType.QueryProject:
return this.VisitQueryProject((QueryProject)node1, node2 as QueryProject);
case NodeType.QueryQuantifiedExpression:
return this.VisitQueryQuantifiedExpression((QueryQuantifiedExpression)node1, node2 as QueryQuantifiedExpression);
case NodeType.QueryRollback:
return this.VisitQueryRollback((QueryRollback)node1, node2 as QueryRollback);
case NodeType.QuerySelect:
return this.VisitQuerySelect((QuerySelect)node1, node2 as QuerySelect);
case NodeType.QuerySingleton:
return this.VisitQuerySingleton((QuerySingleton)node1, node2 as QuerySingleton);
case NodeType.QueryTransact:
return this.VisitQueryTransact((QueryTransact)node1, node2 as QueryTransact);
case NodeType.QueryTypeFilter:
return this.VisitQueryTypeFilter((QueryTypeFilter)node1, node2 as QueryTypeFilter);
case NodeType.QueryUnion:
return this.VisitQueryUnion((QueryUnion)node1, node2 as QueryUnion);
case NodeType.QueryUpdate:
return this.VisitQueryUpdate((QueryUpdate)node1, node2 as QueryUpdate);
case NodeType.QueryYielder:
return this.VisitQueryYielder((QueryYielder)node1, node2 as QueryYielder);
#endif
default:
return this.VisitUnknownNodeType(node1, node2);
}
}
public virtual Expression VisitAddressDereference(AddressDereference addr1, AddressDereference addr2)
{
if (addr1 == null) return null;
if (addr2 == null)
addr1.Address = this.VisitExpression(addr1.Address, null);
else
addr1.Address = this.VisitExpression(addr1.Address, addr2.Address);
return addr1;
}
public virtual AliasDefinition VisitAliasDefinition(AliasDefinition aliasDefinition1, AliasDefinition aliasDefinition2)
{
if (aliasDefinition1 == null) return null;
if (aliasDefinition2 == null)
aliasDefinition1.AliasedType = this.VisitTypeReference(aliasDefinition1.AliasedType, null);
else
aliasDefinition1.AliasedType = this.VisitTypeReference(aliasDefinition1.AliasedType, aliasDefinition2.AliasedType);
return aliasDefinition1;
}
public virtual AliasDefinitionList VisitAliasDefinitionList(AliasDefinitionList aliasDefinitions1, AliasDefinitionList aliasDefinitions2)
{
if (aliasDefinitions1 == null) return null;
for (int i = 0, n = aliasDefinitions1.Count, m = aliasDefinitions2 == null ? 0 : aliasDefinitions2.Count; i < n; i++)
{
//^ assert aliasDefinitions2 != null;
if (i >= m)
aliasDefinitions1[i] = this.VisitAliasDefinition(aliasDefinitions1[i], null);
else
aliasDefinitions1[i] = this.VisitAliasDefinition(aliasDefinitions1[i], aliasDefinitions2[i]);
}
return aliasDefinitions1;
}
public virtual Expression VisitAnonymousNestedFunction(AnonymousNestedFunction func1, AnonymousNestedFunction func2)
{
if (func1 == null) return null;
if (func2 == null)
{
func1.Parameters = this.VisitParameterList(func1.Parameters, null);
func1.Body = this.VisitBlock(func1.Body, null);
}
else
{
func1.Parameters = this.VisitParameterList(func1.Parameters, func2.Parameters);
func1.Body = this.VisitBlock(func1.Body, func2.Body);
}
return func1;
}
public virtual Expression VisitApplyToAll(ApplyToAll applyToAll1, ApplyToAll applyToAll2)
{
if (applyToAll1 == null) return null;
if (applyToAll2 == null)
{
applyToAll1.Operand1 = this.VisitExpression(applyToAll1.Operand1, null);
applyToAll1.Operand2 = this.VisitExpression(applyToAll1.Operand2, null);
}
else
{
applyToAll1.Operand1 = this.VisitExpression(applyToAll1.Operand1, applyToAll2.Operand1);
applyToAll1.Operand2 = this.VisitExpression(applyToAll1.Operand2, applyToAll2.Operand2);
}
return applyToAll1;
}
public ArrayType VisitArrayType(ArrayType array1, ArrayType array2)
{
Debug.Assert(false, "An array type exists only at runtime. It should be referred to, but never visited.");
return null;
}
public virtual AssemblyNode VisitAssembly(AssemblyNode assembly1, AssemblyNode assembly2)
{
if (assembly1 == null) return null;
this.VisitModule(assembly1, assembly2);
if (assembly2 == null)
{
assembly1.ModuleAttributes = this.VisitAttributeList(assembly1.ModuleAttributes, null);
assembly1.SecurityAttributes = this.VisitSecurityAttributeList(assembly1.SecurityAttributes, null);
}
else
{
assembly1.ModuleAttributes = this.VisitAttributeList(assembly1.ModuleAttributes, assembly2.ModuleAttributes);
assembly1.SecurityAttributes = this.VisitSecurityAttributeList(assembly1.SecurityAttributes, assembly2.SecurityAttributes);
}
return assembly1;
}
public virtual AssemblyReference VisitAssemblyReference(AssemblyReference assemblyReference1, AssemblyReference assemblyReference2)
{
return assemblyReference1;
}
public virtual Statement VisitAssertion(Assertion assertion1, Assertion assertion2)
{
if (assertion1 == null) return null;
if (assertion2 == null)
assertion1.Condition = this.VisitExpression(assertion1.Condition, null);
else
assertion1.Condition = this.VisitExpression(assertion1.Condition, assertion2.Condition);
return assertion1;
}
public virtual Statement VisitAssumption(Assumption Assumption1, Assumption Assumption2)
{
if (Assumption1 == null) return null;
if (Assumption2 == null)
Assumption1.Condition = this.VisitExpression(Assumption1.Condition, null);
else
Assumption1.Condition = this.VisitExpression(Assumption1.Condition, Assumption2.Condition);
return Assumption1;
}
public virtual Expression VisitAssignmentExpression(AssignmentExpression assignment1, AssignmentExpression assignment2)
{
if (assignment1 == null) return null;
if (assignment2 == null)
assignment1.AssignmentStatement = (Statement)this.Visit(assignment1.AssignmentStatement, null);
else
assignment1.AssignmentStatement = (Statement)this.Visit(assignment1.AssignmentStatement, assignment2.AssignmentStatement);
return assignment1;
}
public virtual Statement VisitAssignmentStatement(AssignmentStatement assignment1, AssignmentStatement assignment2)
{
if (assignment1 == null) return null;
if (assignment2 == null)
{
assignment1.Target = this.VisitTargetExpression(assignment1.Target, null);
assignment1.Source = this.VisitExpression(assignment1.Source, null);
}
else
{
assignment1.Target = this.VisitTargetExpression(assignment1.Target, assignment2.Target);
assignment1.Source = this.VisitExpression(assignment1.Source, assignment2.Source);
}
return assignment1;
}
public virtual Expression VisitAttributeConstructor(AttributeNode attribute1, AttributeNode attribute2)
{
if (attribute1 == null) return null;
if (attribute2 == null)
return this.VisitExpression(attribute1.Constructor, null);
else
return this.VisitExpression(attribute1.Constructor, attribute2.Constructor);
}
public virtual AttributeNode VisitAttributeNode(AttributeNode attribute1, AttributeNode attribute2)
{
if (attribute1 == null) return null;
if (attribute2 == null)
{
attribute1.Constructor = this.VisitAttributeConstructor(attribute1, null);
attribute1.Expressions = this.VisitExpressionList(attribute1.Expressions, null);
}
else
{
attribute1.Constructor = this.VisitAttributeConstructor(attribute1, attribute2);
attribute1.Expressions = this.VisitExpressionList(attribute1.Expressions, attribute2.Expressions);
}
return attribute1;
}
public virtual AttributeList VisitAttributeList(AttributeList attributes1, AttributeList attributes2)
{
if (attributes1 == null) return null;
for (int i = 0, n = attributes1.Count, m = attributes2 == null ? 0 : attributes2.Count; i < n; i++)
{
//^ assert attributes2 != null;
if (i >= m)
attributes1[i] = this.VisitAttributeNode(attributes1[i], null);
else
attributes1[i] = this.VisitAttributeNode(attributes1[i], attributes2[i]);
}
return attributes1;
}
public virtual Expression VisitBase(Base Base1, Base Base2)
{
return Base1;
}
public virtual Expression VisitBinaryExpression(BinaryExpression binaryExpression1, BinaryExpression binaryExpression2)
{
if (binaryExpression1 == null) return null;
if (binaryExpression2 == null)
{
binaryExpression1.Operand1 = this.VisitExpression(binaryExpression1.Operand1, null);
binaryExpression1.Operand2 = this.VisitExpression(binaryExpression1.Operand2, null);
}
else
{
binaryExpression1.Operand1 = this.VisitExpression(binaryExpression1.Operand1, binaryExpression2.Operand1);
binaryExpression1.Operand2 = this.VisitExpression(binaryExpression1.Operand2, binaryExpression2.Operand2);
}
return binaryExpression1;
}
public virtual Block VisitBlock(Block block1, Block block2)
{
if (block1 == null) return null;
if (block2 == null)
block1.Statements = this.VisitStatementList(block1.Statements, null);
else
block1.Statements = this.VisitStatementList(block1.Statements, block2.Statements);
return block1;
}
public virtual Expression VisitBlockExpression(BlockExpression blockExpression1, BlockExpression blockExpression2)
{
if (blockExpression1 == null) return null;
if (blockExpression2 == null)
blockExpression1.Block = this.VisitBlock(blockExpression1.Block, null);
else
blockExpression1.Block = this.VisitBlock(blockExpression1.Block, blockExpression2.Block);
return blockExpression1;
}
public virtual BlockList VisitBlockList(BlockList blockList1, BlockList blockList2)
{
if (blockList1 == null) return null;
for (int i = 0, n = blockList1.Count, m = blockList2 == null ? 0 : blockList2.Count; i < n; i++)
{
//^ assert blockList2 != null;
if (i >= m)
blockList1[i] = this.VisitBlock(blockList1[i], null);
else
blockList1[i] = this.VisitBlock(blockList1[i], blockList2[i]);
}
return blockList1;
}
public virtual Statement VisitBranch(Branch branch1, Branch branch2)
{
if (branch1 == null) return null;
if (branch2 == null)
branch1.Condition = this.VisitExpression(branch1.Condition, null);
else
branch1.Condition = this.VisitExpression(branch1.Condition, branch2.Condition);
return branch1;
}
public virtual Statement VisitCatch(Catch Catch1, Catch Catch2)
{
if (Catch1 == null) return null;
if (Catch2 == null)
{
Catch1.Variable = this.VisitTargetExpression(Catch1.Variable, null);
Catch1.Type = this.VisitTypeReference(Catch1.Type, null);
Catch1.Block = this.VisitBlock(Catch1.Block, null);
}
else
{
Catch1.Variable = this.VisitTargetExpression(Catch1.Variable, Catch2.Variable);
Catch1.Type = this.VisitTypeReference(Catch1.Type, Catch2.Type);
Catch1.Block = this.VisitBlock(Catch1.Block, Catch2.Block);
}
return Catch1;
}
public virtual CatchList VisitCatchList(CatchList catchers1, CatchList catchers2)
{
if (catchers1 == null) return null;
for (int i = 0, n = catchers1.Count, m = catchers2 == null ? 0 : catchers2.Count; i < n; i++)
{
//^ assert catchers2 != null;
if (i >= m)
catchers1[i] = (Catch)this.VisitCatch(catchers1[i], null);
else
catchers1[i] = (Catch)this.VisitCatch(catchers1[i], catchers2[i]);
}
return catchers1;
}
public virtual Class VisitClass(Class Class1, Class Class2)
{
return (Class)this.VisitTypeNode(Class1, Class2);
}
public virtual Expression VisitCoerceTuple(CoerceTuple coerceTuple1, CoerceTuple coerceTuple2)
{
if (coerceTuple1 == null) return null;
if (coerceTuple2 == null)
coerceTuple1.OriginalTuple = this.VisitExpression(coerceTuple1.OriginalTuple, null);
else
coerceTuple1.OriginalTuple = this.VisitExpression(coerceTuple1.OriginalTuple, coerceTuple2.OriginalTuple);
return this.VisitConstructTuple(coerceTuple1, coerceTuple2);
}
public virtual CollectionEnumerator VisitCollectionEnumerator(CollectionEnumerator ce1, CollectionEnumerator ce2)
{
if (ce1 == null) return null;
if (ce2 == null)
ce1.Collection = this.VisitExpression(ce1.Collection, null);
else
ce1.Collection = this.VisitExpression(ce1.Collection, ce2.Collection);
return ce1;
}
public virtual Compilation VisitCompilation(Compilation compilation1, Compilation compilation2)
{
if (compilation1 == null) return null;
Module module1 = compilation1.TargetModule;
AssemblyNode assem1 = module1 as AssemblyNode;
Module module2 = compilation2 == null ? null : compilation2.TargetModule;
AssemblyNode assem2 = module2 as AssemblyNode;
if (module1 != null)
{
if (module2 == null)
module1.Attributes = this.VisitAttributeList(module1.Attributes, null);
else
module1.Attributes = this.VisitAttributeList(module1.Attributes, module2.Attributes);
}
if (assem1 != null)
{
if (assem2 == null)
assem1.ModuleAttributes = this.VisitAttributeList(assem1.ModuleAttributes, null);
else
assem1.ModuleAttributes = this.VisitAttributeList(assem1.ModuleAttributes, assem2.ModuleAttributes);
}
compilation1.CompilationUnits = this.VisitCompilationUnitList(compilation1.CompilationUnits, compilation2 == null ? null : compilation2.CompilationUnits);
return null;
}
public virtual CompilationUnit VisitCompilationUnit(CompilationUnit cUnit1, CompilationUnit cUnit2)
{
if (cUnit1 == null) return null;
cUnit1.Nodes = this.VisitNodeList(cUnit1.Nodes, cUnit2 == null ? null : cUnit2.Nodes);
return cUnit1;
}
public virtual CompilationUnitList VisitCompilationUnitList(CompilationUnitList cUnits1, CompilationUnitList cUnits2)
{
if (cUnits1 == null) return null;
for (int i = 0, n = cUnits1.Count, m = cUnits2 == null ? 0 : cUnits2.Count; i < n; i++)
{
//^ assert cUnits2 != null;
if (i >= m)
cUnits1[i] = (CompilationUnit)this.VisitCompilationUnit(cUnits1[i], null);
else
cUnits1[i] = (CompilationUnit)this.VisitCompilationUnit(cUnits1[i], cUnits2[i]);
}
return cUnits1;
}
public virtual CompilationUnitSnippet VisitCompilationUnitSnippet(CompilationUnitSnippet snippet1, CompilationUnitSnippet snippet2)
{
return snippet1;
}
public virtual Node VisitComposition(Composition comp1, Composition comp2)
{
if (comp1 == null) return null;
if (comp1.GetType() == typeof(Composition))
{
comp1.Expression = (Expression)this.Visit(comp1.Expression, comp2 == null ? null : comp2.Expression);
return comp1;
}
return this.VisitUnknownNodeType(comp1, comp2);
}
public virtual Expression VisitConstruct(Construct cons1, Construct cons2)
{
if (cons1 == null) return null;
if (cons2 == null)
{
cons1.Constructor = this.VisitExpression(cons1.Constructor, null);
cons1.Operands = this.VisitExpressionList(cons1.Operands, null);
cons1.Owner = this.VisitExpression(cons1.Owner, null);
}
else
{
cons1.Constructor = this.VisitExpression(cons1.Constructor, cons2.Constructor);
cons1.Operands = this.VisitExpressionList(cons1.Operands, cons2.Operands);
cons1.Owner = this.VisitExpression(cons1.Owner, cons2.Owner);
}
return cons1;
}
public virtual Expression VisitConstructArray(ConstructArray consArr1, ConstructArray consArr2)
{
if (consArr1 == null) return null;
if (consArr2 == null)
{
consArr1.ElementType = this.VisitTypeReference(consArr1.ElementType, null);
consArr1.Operands = this.VisitExpressionList(consArr1.Operands, null);
consArr1.Initializers = this.VisitExpressionList(consArr1.Initializers, null);
consArr1.Owner = this.VisitExpression(consArr1.Owner, null);
}
else
{
consArr1.ElementType = this.VisitTypeReference(consArr1.ElementType, consArr2.ElementType);
consArr1.Operands = this.VisitExpressionList(consArr1.Operands, consArr2.Operands);
consArr1.Initializers = this.VisitExpressionList(consArr1.Initializers, consArr2.Initializers);
consArr1.Owner = this.VisitExpression(consArr1.Owner, consArr2.Owner);
}
return consArr1;
}
public virtual Expression VisitConstructDelegate(ConstructDelegate consDelegate1, ConstructDelegate consDelegate2)
{
if (consDelegate1 == null) return null;
if (consDelegate2 == null)
{
consDelegate1.DelegateType = this.VisitTypeReference(consDelegate1.DelegateType, null);
consDelegate1.TargetObject = this.VisitExpression(consDelegate1.TargetObject, null);
}
else
{
consDelegate1.DelegateType = this.VisitTypeReference(consDelegate1.DelegateType, consDelegate2.DelegateType);
consDelegate1.TargetObject = this.VisitExpression(consDelegate1.TargetObject, consDelegate2.TargetObject);
}
return consDelegate1;
}
public virtual Expression VisitConstructFlexArray(ConstructFlexArray consArr1, ConstructFlexArray consArr2)
{
if (consArr1 == null) return null;
if (consArr2 == null)
{
consArr1.ElementType = this.VisitTypeReference(consArr1.ElementType, null);
consArr1.Operands = this.VisitExpressionList(consArr1.Operands, null);
consArr1.Initializers = this.VisitExpressionList(consArr1.Initializers, null);
}
else
{
consArr1.ElementType = this.VisitTypeReference(consArr1.ElementType, consArr2.ElementType);
consArr1.Operands = this.VisitExpressionList(consArr1.Operands, consArr2.Operands);
consArr1.Initializers = this.VisitExpressionList(consArr1.Initializers, consArr2.Initializers);
}
return consArr1;
}
public virtual Expression VisitConstructIterator(ConstructIterator consIterator1, ConstructIterator consIterator2)
{
return consIterator1;
}
public virtual Expression VisitConstructTuple(ConstructTuple consTuple1, ConstructTuple consTuple2)
{
if (consTuple1 == null) return null;
if (consTuple2 == null)
consTuple1.Fields = this.VisitFieldList(consTuple1.Fields, null);
else
consTuple1.Fields = this.VisitFieldList(consTuple1.Fields, consTuple2.Fields);
return consTuple1;
}
#if ExtendedRuntime
public virtual TypeNode VisitConstrainedType(ConstrainedType cType1, ConstrainedType cType2){
if (cType1 == null) return null;
if (cType2 == null){
cType1.UnderlyingType = this.VisitTypeReference(cType1.UnderlyingType, null);
cType1.Constraint = this.VisitExpression(cType1.Constraint, null);
}else{
cType1.UnderlyingType = this.VisitTypeReference(cType1.UnderlyingType, cType2.UnderlyingType);
cType1.Constraint = this.VisitExpression(cType1.Constraint, cType2.Constraint);
}
return cType1;
}
#endif
public virtual Statement VisitContinue(Continue Continue1, Continue Continue2)
{
return Continue1;
}
public virtual Expression VisitCurrentClosure(CurrentClosure currentClosure1, CurrentClosure currentClosure2)
{
return currentClosure1;
}
public virtual DelegateNode VisitDelegateNode(DelegateNode delegateNode1, DelegateNode delegateNode2)
{
if (delegateNode1 == null) return null;
if (delegateNode2 == null)
{
delegateNode1 = (DelegateNode)this.VisitTypeNode(delegateNode1, null);
if (delegateNode1 == null) return null;
delegateNode1.Parameters = this.VisitParameterList(delegateNode1.Parameters, null);
delegateNode1.ReturnType = this.VisitTypeReference(delegateNode1.ReturnType, null);
}
else
{
delegateNode1 = (DelegateNode)this.VisitTypeNode(delegateNode1, delegateNode2);
if (delegateNode1 == null) return null;
delegateNode1.Parameters = this.VisitParameterList(delegateNode1.Parameters, delegateNode2.Parameters);
delegateNode1.ReturnType = this.VisitTypeReference(delegateNode1.ReturnType, delegateNode2.ReturnType);
}
return delegateNode1;
}
public virtual Statement VisitDoWhile(DoWhile doWhile1, DoWhile doWhile2)
{
if (doWhile1 == null) return null;
if (doWhile2 == null)
{
doWhile1.Invariants = this.VisitExpressionList(doWhile1.Invariants, null);
doWhile1.Body = this.VisitBlock(doWhile1.Body, null);
doWhile1.Condition = this.VisitExpression(doWhile1.Condition, null);
}
else
{
doWhile1.Invariants = this.VisitExpressionList(doWhile1.Invariants, doWhile2.Invariants);
doWhile1.Body = this.VisitBlock(doWhile1.Body, doWhile2.Body);
doWhile1.Condition = this.VisitExpression(doWhile1.Condition, doWhile2.Condition);
}
return doWhile1;
}
public virtual Statement VisitEndFilter(EndFilter endFilter1, EndFilter endFilter2)
{
if (endFilter1 == null) return null;
if (endFilter2 == null)
endFilter1.Value = this.VisitExpression(endFilter1.Value, null);
else
endFilter1.Value = this.VisitExpression(endFilter1.Value, endFilter2.Value);
return endFilter1;
}
public virtual Statement VisitEndFinally(EndFinally endFinally1, EndFinally endFinally2)
{
return endFinally1;
}
#if ExtendedRuntime
public virtual EnsuresList VisitEnsuresList(EnsuresList ensures1, EnsuresList ensures2) {
if (ensures1 == null) return null;
for (int i = 0, n = ensures1.Count, m = ensures2 == null ? 0 : ensures2.Count; i < n; i++) {
//^ assert ensures2 != null;
if (i >= m)
ensures1[i] = (Ensures)this.Visit(ensures1[i], null);
else
ensures1[i] = (Ensures)this.Visit(ensures1[i], ensures2[i]);
}
return ensures1;
}
#endif
public virtual EnumNode VisitEnumNode(EnumNode enumNode1, EnumNode enumNode2)
{
return (EnumNode)this.VisitTypeNode(enumNode1, enumNode2);
}
public virtual Event VisitEvent(Event evnt1, Event evnt2)
{
if (evnt1 == null) return null;
if (evnt2 == null)
{
evnt1.Attributes = this.VisitAttributeList(evnt1.Attributes, null);
evnt1.HandlerType = this.VisitTypeReference(evnt1.HandlerType, null);
}
else
{
evnt1.Attributes = this.VisitAttributeList(evnt1.Attributes, evnt2.Attributes);
evnt1.HandlerType = this.VisitTypeReference(evnt1.HandlerType, evnt2.HandlerType);
}
return evnt1;
}
#if ExtendedRuntime
public virtual EnsuresExceptional VisitEnsuresExceptional(EnsuresExceptional exceptional1, EnsuresExceptional exceptional2) {
if (exceptional1 == null) return null;
if (exceptional2 == null) {
exceptional1.PostCondition = this.VisitExpression(exceptional1.PostCondition, null);
exceptional1.Type = this.VisitTypeReference(exceptional1.Type, null);
exceptional1.Variable = this.VisitExpression(exceptional1.Variable, null);
}else{
exceptional1.PostCondition = this.VisitExpression(exceptional1.PostCondition, exceptional2.PostCondition);
exceptional1.Type = this.VisitTypeReference(exceptional1.Type, exceptional2.Type);
exceptional1.Variable = this.VisitExpression(exceptional1.Variable, exceptional2.Variable);
}
return exceptional1;
}
#endif
public virtual Statement VisitExit(Exit exit1, Exit exit2)
{
return exit1;
}
public virtual Statement VisitExpose(Expose expose1, Expose expose2)
{
if (expose1 == null) return null;
if (expose2 == null)
{
expose1.Instance = this.VisitExpression(expose1.Instance, null);
expose1.Body = this.VisitBlock(expose1.Body, null);
}
else
{
expose1.Instance = this.VisitExpression(expose1.Instance, expose1.Instance);
expose1.Body = this.VisitBlock(expose1.Body, expose2.Body);
}
return expose1;
}
public virtual Expression VisitExpression(Expression expression1, Expression expression2)
{
if (expression1 == null) return null;
switch (expression1.NodeType)
{
case NodeType.Dup:
case NodeType.Arglist:
return expression1;
case NodeType.Pop:
UnaryExpression uex1 = expression1 as UnaryExpression;
UnaryExpression uex2 = expression2 as UnaryExpression;
if (uex1 != null)
{
uex1.Operand = this.VisitExpression(uex1.Operand, uex2 == null ? null : uex2.Operand);
return uex1;
}
return expression1;
default:
return (Expression)this.Visit(expression1, expression2);
}
}
public virtual ExpressionList VisitExpressionList(ExpressionList list1, ExpressionList list2)
{
if (list1 == null) return null;
for (int i = 0, n = list1.Count, m = list2 == null ? 0 : list2.Count; i < n; i++)
{
//^ assert list2 != null;
if (i >= m)
list1[i] = (Expression)this.Visit(list1[i], null);
else
list1[i] = (Expression)this.Visit(list1[i], list2[i]);
}
return list1;
}
public virtual Expression VisitExpressionSnippet(ExpressionSnippet snippet1, ExpressionSnippet snippet2)
{
return snippet1;
}
public virtual Statement VisitExpressionStatement(ExpressionStatement statement1, ExpressionStatement statement2)
{
if (statement1 == null) return null;
if (statement2 == null)
statement1.Expression = this.VisitExpression(statement1.Expression, null);
else
statement1.Expression = this.VisitExpression(statement1.Expression, statement2.Expression);
return statement1;
}
public virtual Statement VisitFaultHandler(FaultHandler faultHandler1, FaultHandler faultHandler2)
{
if (faultHandler1 == null) return null;
if (faultHandler2 == null)
faultHandler1.Block = this.VisitBlock(faultHandler1.Block, null);
else
faultHandler1.Block = this.VisitBlock(faultHandler1.Block, faultHandler2.Block);
return faultHandler1;
}
public virtual FaultHandlerList VisitFaultHandlerList(FaultHandlerList faultHandlers1, FaultHandlerList faultHandlers2)
{
if (faultHandlers1 == null) return null;
for (int i = 0, n = faultHandlers1.Count, m = faultHandlers2 == null ? 0 : faultHandlers2.Count; i < n; i++)
{
//^ assert faultHandlers2 != null;
if (i >= m)
faultHandlers1[i] = (FaultHandler)this.VisitFaultHandler(faultHandlers1[i], null);
else
faultHandlers1[i] = (FaultHandler)this.VisitFaultHandler(faultHandlers1[i], faultHandlers2[i]);
}
return faultHandlers1;
}
public virtual Field VisitField(Field field1, Field field2)
{
if (field1 == null) return null;
if (field2 == null)
{
field1.Attributes = this.VisitAttributeList(field1.Attributes, null);
field1.Type = this.VisitTypeReference(field1.Type, null);
field1.Initializer = this.VisitExpression(field1.Initializer, null);
field1.ImplementedInterfaces = this.VisitInterfaceReferenceList(field1.ImplementedInterfaces, null);
}
else
{
field1.Attributes = this.VisitAttributeList(field1.Attributes, field2.Attributes);
field1.Type = this.VisitTypeReference(field1.Type, field2.Type);
field1.Initializer = this.VisitExpression(field1.Initializer, field2.Initializer);
field1.ImplementedInterfaces = this.VisitInterfaceReferenceList(field1.ImplementedInterfaces, field2.ImplementedInterfaces);
}
return field1;
}
public virtual Block VisitFieldInitializerBlock(FieldInitializerBlock block1, FieldInitializerBlock block2)
{
if (block1 == null) return null;
if (block2 == null)
block1.Type = this.VisitTypeReference(block1.Type, null);
else
block1.Type = this.VisitTypeReference(block1.Type, block2.Type);
return this.VisitBlock(block1, block2);
}
public virtual FieldList VisitFieldList(FieldList fields1, FieldList fields2)
{
if (fields1 == null) return null;
for (int i = 0, n = fields1.Count, m = fields2 == null ? 0 : fields2.Count; i < n; i++)
{
//^ assert fields2 != null;
if (i >= m)
fields1[i] = this.VisitField(fields1[i], null);
else
fields1[i] = this.VisitField(fields1[i], fields2[i]);
}
return fields1;
}
public virtual Statement VisitFilter(Filter filter1, Filter filter2)
{
if (filter1 == null) return null;
if (filter2 == null)
{
filter1.Expression = this.VisitExpression(filter1.Expression, null);
filter1.Block = this.VisitBlock(filter1.Block, null);
}
else
{
filter1.Expression = this.VisitExpression(filter1.Expression, filter2.Expression);
filter1.Block = this.VisitBlock(filter1.Block, filter2.Block);
}
return filter1;
}
public virtual FilterList VisitFilterList(FilterList filters1, FilterList filters2)
{
if (filters1 == null) return null;
for (int i = 0, n = filters1.Count, m = filters2 == null ? 0 : filters2.Count; i < n; i++)
{
//^ assert filters2 != null;
if (i >= m)
filters1[i] = (Filter)this.VisitFilter(filters1[i], null);
else
filters1[i] = (Filter)this.VisitFilter(filters1[i], filters2[i]);
}
return filters1;
}
public virtual Statement VisitFinally(Finally Finally1, Finally Finally2)
{
if (Finally1 == null) return null;
if (Finally2 == null)
Finally1.Block = this.VisitBlock(Finally1.Block, null);
else
Finally1.Block = this.VisitBlock(Finally1.Block, Finally2.Block);
return Finally1;
}
public virtual Statement VisitFixed(Fixed fixed1, Fixed fixed2)
{
if (fixed1 == null) return null;
if (fixed2 == null)
{
fixed1.Declarators = (Statement)this.Visit(fixed1.Declarators, null);
fixed1.Body = this.VisitBlock(fixed1.Body, null);
}
else
{
fixed1.Declarators = (Statement)this.Visit(fixed1.Declarators, fixed2.Declarators);
fixed1.Body = this.VisitBlock(fixed1.Body, fixed2.Body);
}
return fixed1;
}
public virtual Statement VisitFor(For For1, For For2)
{
if (For1 == null) return null;
if (For2 == null)
{
For1.Initializer = this.VisitStatementList(For1.Initializer, null);
For1.Invariants = this.VisitExpressionList(For1.Invariants, null);
For1.Condition = this.VisitExpression(For1.Condition, null);
For1.Incrementer = this.VisitStatementList(For1.Incrementer, null);
For1.Body = this.VisitBlock(For1.Body, null);
}
else
{
For1.Initializer = this.VisitStatementList(For1.Initializer, For2.Initializer);
For1.Invariants = this.VisitExpressionList(For1.Invariants, For2.Invariants);
For1.Condition = this.VisitExpression(For1.Condition, For2.Condition);
For1.Incrementer = this.VisitStatementList(For1.Incrementer, For2.Incrementer);
For1.Body = this.VisitBlock(For1.Body, For2.Body);
}
return For1;
}
public virtual Statement VisitForEach(ForEach forEach1, ForEach forEach2)
{
if (forEach1 == null) return null;
if (forEach2 == null)
{
forEach1.TargetVariableType = this.VisitTypeReference(forEach1.TargetVariableType, null);
forEach1.TargetVariable = this.VisitTargetExpression(forEach1.TargetVariable, null);
forEach1.SourceEnumerable = this.VisitExpression(forEach1.SourceEnumerable, null);
forEach1.InductionVariable = this.VisitTargetExpression(forEach1.InductionVariable, null);
forEach1.Invariants = this.VisitExpressionList(forEach1.Invariants, null);
forEach1.Body = this.VisitBlock(forEach1.Body, null);
}
else
{
forEach1.TargetVariableType = this.VisitTypeReference(forEach1.TargetVariableType, forEach2.TargetVariableType);
forEach1.TargetVariable = this.VisitTargetExpression(forEach1.TargetVariable, forEach2.TargetVariable);
forEach1.SourceEnumerable = this.VisitExpression(forEach1.SourceEnumerable, forEach2.SourceEnumerable);
forEach1.InductionVariable = this.VisitTargetExpression(forEach1.InductionVariable, forEach2.InductionVariable);
forEach1.Invariants = this.VisitExpressionList(forEach1.Invariants, forEach2.Invariants);
forEach1.Body = this.VisitBlock(forEach1.Body, forEach2.Body);
}
return forEach1;
}
public virtual Statement VisitFunctionDeclaration(FunctionDeclaration functionDeclaration1, FunctionDeclaration functionDeclaration2)
{
if (functionDeclaration1 == null) return null;
if (functionDeclaration2 == null)
{
functionDeclaration1.Parameters = this.VisitParameterList(functionDeclaration1.Parameters, null);
functionDeclaration1.ReturnType = this.VisitTypeReference(functionDeclaration1.ReturnType, null);
functionDeclaration1.Body = this.VisitBlock(functionDeclaration1.Body, null);
}
else
{
functionDeclaration1.Parameters = this.VisitParameterList(functionDeclaration1.Parameters, functionDeclaration2.Parameters);
functionDeclaration1.ReturnType = this.VisitTypeReference(functionDeclaration1.ReturnType, functionDeclaration2.ReturnType);
functionDeclaration1.Body = this.VisitBlock(functionDeclaration1.Body, functionDeclaration2.Body);
}
return functionDeclaration1;
}
public virtual Expression VisitTemplateInstance(TemplateInstance genericInstance1, TemplateInstance genericInstance2)
{
if (genericInstance1 == null) return null;
if (genericInstance2 == null)
{
genericInstance1.Expression = this.VisitExpression(genericInstance1.Expression, null);
genericInstance1.TypeArguments = this.VisitTypeReferenceList(genericInstance1.TypeArguments, null);
}
else
{
genericInstance1.Expression = this.VisitExpression(genericInstance1.Expression, genericInstance2.Expression);
genericInstance1.TypeArguments = this.VisitTypeReferenceList(genericInstance1.TypeArguments, genericInstance2.TypeArguments);
}
return genericInstance1;
}
public virtual Expression VisitStackAlloc(StackAlloc alloc1, StackAlloc alloc2)
{
if (alloc1 == null) return null;
if (alloc2 == null)
{
alloc1.ElementType = this.VisitTypeReference(alloc1.ElementType, null);
alloc1.NumberOfElements = this.VisitExpression(alloc1.NumberOfElements, null);
}
else
{
alloc1.ElementType = this.VisitTypeReference(alloc1.ElementType, alloc2.ElementType);
alloc1.NumberOfElements = this.VisitExpression(alloc1.NumberOfElements, alloc2.NumberOfElements);
}
return alloc1;
}
public virtual Statement VisitGoto(Goto Goto1, Goto Goto2)
{
return Goto1;
}
public virtual Statement VisitGotoCase(GotoCase gotoCase1, GotoCase gotoCase2)
{
if (gotoCase1 == null) return null;
if (gotoCase2 == null)
{
gotoCase1.CaseLabel = this.VisitExpression(gotoCase1.CaseLabel, null);
}
else
{
gotoCase1.CaseLabel = this.VisitExpression(gotoCase1.CaseLabel, gotoCase2.CaseLabel);
}
return gotoCase1;
}
public virtual Expression VisitIdentifier(Identifier identifier1, Identifier identifier2)
{
return identifier1;
}
public virtual Statement VisitIf(If If1, If If2)
{
if (If1 == null) return null;
if (If2 == null)
{
If1.Condition = this.VisitExpression(If1.Condition, null);
If1.TrueBlock = this.VisitBlock(If1.TrueBlock, null);
If1.FalseBlock = this.VisitBlock(If1.FalseBlock, null);
}
else
{
If1.Condition = this.VisitExpression(If1.Condition, If2.Condition);
If1.TrueBlock = this.VisitBlock(If1.TrueBlock, If2.TrueBlock);
If1.FalseBlock = this.VisitBlock(If1.FalseBlock, If2.FalseBlock);
}
return If1;
}
public virtual Expression VisitImplicitThis(ImplicitThis implicitThis1, ImplicitThis implicitThis2)
{
return implicitThis1;
}
public virtual Expression VisitIndexer(Indexer indexer1, Indexer indexer2)
{
if (indexer1 == null) return null;
if (indexer2 == null)
{
indexer1.Object = this.VisitExpression(indexer1.Object, null);
indexer1.Operands = this.VisitExpressionList(indexer1.Operands, null);
}
else
{
indexer1.Object = this.VisitExpression(indexer1.Object, indexer2.Object);
indexer1.Operands = this.VisitExpressionList(indexer1.Operands, indexer2.Operands);
}
return indexer1;
}
public virtual Interface VisitInterface(Interface Interface1, Interface Interface2)
{
return (Interface)this.VisitTypeNode(Interface1, Interface2);
}
public virtual Interface VisitInterfaceReference(Interface Interface1, Interface Interface2)
{
return (Interface)this.VisitTypeReference(Interface1, Interface2);
}
public virtual InterfaceList VisitInterfaceReferenceList(InterfaceList interfaceReferences1, InterfaceList interfaceReferences2)
{
if (interfaceReferences1 == null) return null;
for (int i = 0, n = interfaceReferences1.Count, m = interfaceReferences2 == null ? 0 : interfaceReferences2.Count; i < n; i++)
{
//^ assert interfaceReferences2 != null;
if (i >= m)
interfaceReferences1[i] = this.VisitInterfaceReference(interfaceReferences1[i], null);
else
interfaceReferences1[i] = this.VisitInterfaceReference(interfaceReferences1[i], interfaceReferences2[i]);
}
return interfaceReferences1;
}
#if ExtendedRuntime
public virtual Invariant VisitInvariant(Invariant invariant1, Invariant invariant2){
if (invariant1 == null) return null;
if (invariant2 == null){
invariant1.Condition = this.VisitExpression(invariant1.Condition, null);
}else{
invariant1.Condition = this.VisitExpression(invariant1.Condition, invariant2.Condition);
}
return invariant1;
}
public virtual InvariantList VisitInvariantList(InvariantList Invariants1, InvariantList Invariants2){
if (Invariants1 == null) return null;
for (int i = 0, n = Invariants1.Count, m = Invariants2 == null ? 0 : Invariants2.Count; i < n; i++){
//^ assert Invariants2 != null;
if (i >= m)
Invariants1[i] = this.VisitInvariant(Invariants1[i], null);
else
Invariants1[i] = this.VisitInvariant(Invariants1[i], Invariants2[i]);
}
return Invariants1;
}
#endif
public virtual InstanceInitializer VisitInstanceInitializer(InstanceInitializer cons1, InstanceInitializer cons2)
{
return (InstanceInitializer)this.VisitMethod(cons1, cons2);
}
public virtual Statement VisitLabeledStatement(LabeledStatement lStatement1, LabeledStatement lStatement2)
{
if (lStatement1 == null) return null;
if (lStatement2 == null)
lStatement1.Statement = (Statement)this.Visit(lStatement1.Statement, null);
else
lStatement1.Statement = (Statement)this.Visit(lStatement1.Statement, lStatement2.Statement);
return lStatement1;
}
public virtual Expression VisitLiteral(Literal literal1, Literal literal2)
{
return literal1;
}
public virtual Expression VisitLocal(Local local1, Local local2)
{
if (local1 == null) return null;
if (local2 == null)
local1.Type = this.VisitTypeReference(local1.Type, null);
else
local1.Type = this.VisitTypeReference(local1.Type, local2.Type);
return local1;
}
public virtual LocalDeclaration VisitLocalDeclaration(LocalDeclaration localDeclaration1, LocalDeclaration localDeclaration2)
{
if (localDeclaration1 == null) return null;
if (localDeclaration2 == null)
localDeclaration1.InitialValue = this.VisitExpression(localDeclaration1.InitialValue, null);
else
localDeclaration1.InitialValue = this.VisitExpression(localDeclaration1.InitialValue, localDeclaration2.InitialValue);
return localDeclaration1;
}
public virtual LocalDeclarationList VisitLocalDeclarationList(LocalDeclarationList localDeclarations1, LocalDeclarationList localDeclarations2)
{
if (localDeclarations1 == null) return null;
for (int i = 0, n = localDeclarations1.Count, m = localDeclarations2 == null ? 0 : localDeclarations2.Count; i < n; i++)
{
//^ assert localDeclarations2 != null;
if (i >= m)
localDeclarations1[i] = this.VisitLocalDeclaration(localDeclarations1[i], null);
else
localDeclarations1[i] = this.VisitLocalDeclaration(localDeclarations1[i], localDeclarations2[i]);
}
return localDeclarations1;
}
public virtual Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations1, LocalDeclarationsStatement localDeclarations2)
{
if (localDeclarations1 == null) return null;
if (localDeclarations2 == null)
{
localDeclarations1.Type = this.VisitTypeReference(localDeclarations1.Type, null);
localDeclarations1.Declarations = this.VisitLocalDeclarationList(localDeclarations1.Declarations, null);
}
else
{
localDeclarations1.Type = this.VisitTypeReference(localDeclarations1.Type, localDeclarations2.Type);
localDeclarations1.Declarations = this.VisitLocalDeclarationList(localDeclarations1.Declarations, localDeclarations2.Declarations);
}
return localDeclarations1;
}
public virtual Statement VisitLock(Lock lock1, Lock lock2)
{
if (lock1 == null) return null;
if (lock2 == null)
{
lock1.Guard = this.VisitExpression(lock1.Guard, null);
lock1.Body = this.VisitBlock(lock1.Body, null);
}
else
{
lock1.Guard = this.VisitExpression(lock1.Guard, lock2.Guard);
lock1.Body = this.VisitBlock(lock1.Body, lock2.Body);
}
return lock1;
}
public virtual Expression VisitLRExpression(LRExpression expr1, LRExpression expr2)
{
if (expr1 == null) return null;
if (expr2 == null)
expr1.Expression = this.VisitExpression(expr1.Expression, null);
else
expr1.Expression = this.VisitExpression(expr1.Expression, expr2.Expression);
return expr1;
}
public virtual Expression VisitMemberBinding(MemberBinding memberBinding1, MemberBinding memberBinding2)
{
if (memberBinding1 == null) return null;
if (memberBinding2 == null)
memberBinding1.TargetObject = this.VisitExpression(memberBinding1.TargetObject, null);
else
memberBinding1.TargetObject = this.VisitExpression(memberBinding1.TargetObject, memberBinding2.TargetObject);
return memberBinding1;
}
public virtual MemberList VisitMemberList(MemberList members1, MemberList members2)
{
if (members1 == null) return null;
for (int i = 0, n = members1.Count, m = members2 == null ? 0 : members2.Count; i < n; i++)
{
//^ assert members2 != null;
if (i >= m)
members1[i] = (Member)this.Visit(members1[i], null);
else
members1[i] = (Member)this.Visit(members1[i], members2[i]);
}
return members1;
}
public virtual Method VisitMethod(Method method1, Method method2)
{
if (method1 == null) return null;
if (method2 == null)
{
method1.Attributes = this.VisitAttributeList(method1.Attributes, null);
method1.ReturnAttributes = this.VisitAttributeList(method1.ReturnAttributes, null);
method1.SecurityAttributes = this.VisitSecurityAttributeList(method1.SecurityAttributes, null);
method1.ReturnType = this.VisitTypeReference(method1.ReturnType, null);
method1.ImplementedTypes = this.VisitTypeReferenceList(method1.ImplementedTypes, null);
method1.Parameters = this.VisitParameterList(method1.Parameters, null);
method1.Body = this.VisitBlock(method1.Body, null);
}
else
{
method1.Attributes = this.VisitAttributeList(method1.Attributes, method2.Attributes);
method1.ReturnAttributes = this.VisitAttributeList(method1.ReturnAttributes, method2.ReturnAttributes);
method1.SecurityAttributes = this.VisitSecurityAttributeList(method1.SecurityAttributes, method2.SecurityAttributes);
method1.ReturnType = this.VisitTypeReference(method1.ReturnType, method2.ReturnType);
method1.ImplementedTypes = this.VisitTypeReferenceList(method1.ImplementedTypes, method2.ImplementedTypes);
method1.Parameters = this.VisitParameterList(method1.Parameters, method2.Parameters);
#if ExtendedRuntime
method1.Contract = this.VisitMethodContract(method1.Contract, method2.Contract);
#endif
method1.Body = this.VisitBlock(method1.Body, method2.Body);
}
return method1;
}
public virtual Expression VisitMethodCall(MethodCall call1, MethodCall call2)
{
if (call1 == null) return null;
if (call2 == null)
{
call1.Callee = this.VisitExpression(call1.Callee, null);
call1.Operands = this.VisitExpressionList(call1.Operands, null);
}
else
{
call1.Callee = this.VisitExpression(call1.Callee, call2.Callee);
call1.Operands = this.VisitExpressionList(call1.Operands, call2.Operands);
}
return call1;
}
#if ExtendedRuntime
public virtual MethodContract VisitMethodContract(MethodContract contract1, MethodContract contract2) {
if (contract1 == null) return null;
if (contract2 == null) {
// don't visit contract.DeclaringMethod
// don't visit contract.OverriddenMethods
contract1.Requires = this.VisitRequiresList(contract1.Requires, null);
contract1.Ensures = this.VisitEnsuresList(contract1.Ensures, null);
contract1.Modifies = this.VisitExpressionList(contract1.Modifies, null);
}else{
// don't visit contract.DeclaringMethod
// don't visit contract.OverriddenMethods
contract1.Requires = this.VisitRequiresList(contract1.Requires,contract2.Requires);
contract1.Ensures = this.VisitEnsuresList(contract1.Ensures,contract2.Ensures);
contract1.Modifies = this.VisitExpressionList(contract1.Modifies,contract2.Modifies);
}
return contract1;
}
#endif
public virtual Module VisitModule(Module module1, Module module2)
{
if (module1 == null) return null;
if (module2 == null)
{
module1.Attributes = this.VisitAttributeList(module1.Attributes, null);
module1.Types = this.VisitTypeNodeList(module1.Types, null);
}
else
{
module1.Attributes = this.VisitAttributeList(module1.Attributes, module2.Attributes);
module1.Types = this.VisitTypeNodeList(module1.Types, module2.Types);
}
return module1;
}
public virtual ModuleReference VisitModuleReference(ModuleReference moduleReference1, ModuleReference moduleReference2)
{
return moduleReference1;
}
public virtual Expression VisitNameBinding(NameBinding nameBinding1, NameBinding nameBinding2)
{
return nameBinding1;
}
public virtual Expression VisitNamedArgument(NamedArgument namedArgument1, NamedArgument namedArgument2)
{
if (namedArgument1 == null) return null;
if (namedArgument2 == null)
namedArgument1.Value = this.VisitExpression(namedArgument1.Value, null);
else
namedArgument1.Value = this.VisitExpression(namedArgument1.Value, namedArgument2.Value);
return namedArgument1;
}
public virtual Namespace VisitNamespace(Namespace nspace1, Namespace nspace2)
{
if (nspace1 == null) return null;
if (nspace2 == null)
{
nspace1.AliasDefinitions = this.VisitAliasDefinitionList(nspace1.AliasDefinitions, null);
nspace1.UsedNamespaces = this.VisitUsedNamespaceList(nspace1.UsedNamespaces, null);
nspace1.Attributes = this.VisitAttributeList(nspace1.Attributes, null);
nspace1.Types = this.VisitTypeNodeList(nspace1.Types, null);
nspace1.NestedNamespaces = this.VisitNamespaceList(nspace1.NestedNamespaces, null);
}
else
{
nspace1.AliasDefinitions = this.VisitAliasDefinitionList(nspace1.AliasDefinitions, nspace2.AliasDefinitions);
nspace1.UsedNamespaces = this.VisitUsedNamespaceList(nspace1.UsedNamespaces, nspace2.UsedNamespaces);
nspace1.Attributes = this.VisitAttributeList(nspace1.Attributes, nspace2.Attributes);
nspace1.Types = this.VisitTypeNodeList(nspace1.Types, nspace2.Types);
nspace1.NestedNamespaces = this.VisitNamespaceList(nspace1.NestedNamespaces, nspace2.NestedNamespaces);
}
return nspace1;
}
public virtual NamespaceList VisitNamespaceList(NamespaceList namespaces1, NamespaceList namespaces2)
{
if (namespaces1 == null) return null;
for (int i = 0, n = namespaces1.Count, m = namespaces2 == null ? 0 : namespaces2.Count; i < n; i++)
{
//^ assert namespaces2 != null;
if (i >= m)
namespaces1[i] = this.VisitNamespace(namespaces1[i], null);
else
namespaces1[i] = this.VisitNamespace(namespaces1[i], namespaces2[i]);
}
return namespaces1;
}
public virtual NodeList VisitNodeList(NodeList nodes1, NodeList nodes2)
{
if (nodes1 == null) return null;
for (int i = 0, n = nodes1.Count, m = nodes2 == null ? 0 : nodes2.Count; i < n; i++)
{
//^ assert nodes2 != null;
if (i >= m)
nodes1[i] = (CompilationUnit)this.Visit(nodes1[i], null);
else
nodes1[i] = (CompilationUnit)this.Visit(nodes1[i], nodes2[i]);
}
return nodes1;
}
#if ExtendedRuntime
public virtual EnsuresNormal VisitEnsuresNormal(EnsuresNormal normal1, EnsuresNormal normal2) {
if (normal1 == null) return null;
if (normal2 == null)
normal1.PostCondition = this.VisitExpression(normal1.PostCondition, null);
else
normal1.PostCondition = this.VisitExpression(normal1.PostCondition, normal2.PostCondition);
return normal1;
}
public virtual Expression VisitOldExpression(OldExpression oldExpression1, OldExpression oldExpression2) {
if (oldExpression1 == null) return null;
if (oldExpression2 == null)
oldExpression1.expression = this.VisitExpression(oldExpression1.expression, null);
else
oldExpression1.expression = this.VisitExpression(oldExpression1.expression, oldExpression2.expression);
return oldExpression1;
}
public virtual RequiresOtherwise VisitRequiresOtherwise(RequiresOtherwise otherwise1, RequiresOtherwise otherwise2) {
if (otherwise1 == null) return null;
if (otherwise2 == null) {
otherwise1.Condition = this.VisitExpression(otherwise1.Condition, null);
otherwise1.ThrowException = this.VisitExpression(otherwise1.ThrowException, null);
}else{
otherwise1.Condition = this.VisitExpression(otherwise1.Condition, otherwise2.Condition);
otherwise1.ThrowException = this.VisitExpression(otherwise1.ThrowException, otherwise2.ThrowException);
}
return otherwise1;
}
#endif
public virtual Expression VisitParameter(Parameter parameter1, Parameter parameter2)
{
if (parameter1 == null) return null;
if (parameter2 == null)
{
parameter1.Attributes = this.VisitAttributeList(parameter1.Attributes, null);
parameter1.Type = this.VisitTypeReference(parameter1.Type, null);
parameter1.DefaultValue = this.VisitExpression(parameter1.DefaultValue, null);
}
else
{
parameter1.Attributes = this.VisitAttributeList(parameter1.Attributes, parameter2.Attributes);
parameter1.Type = this.VisitTypeReference(parameter1.Type, parameter2.Type);
parameter1.DefaultValue = this.VisitExpression(parameter1.DefaultValue, parameter2.DefaultValue);
}
return parameter1;
}
public virtual ParameterList VisitParameterList(ParameterList parameterList1, ParameterList parameterList2)
{
if (parameterList1 == null) return null;
for (int i = 0, n = parameterList1.Count, m = parameterList2 == null ? 0 : parameterList2.Count; i < n; i++)
{
//^ assert parameterList2 != null;
if (i >= m)
parameterList1[i] = (Parameter)this.VisitParameter(parameterList1[i], null);
else
parameterList1[i] = (Parameter)this.VisitParameter(parameterList1[i], parameterList2[i]);
}
return parameterList1;
}
#if ExtendedRuntime
public virtual RequiresPlain VisitRequiresPlain(RequiresPlain plain1, RequiresPlain plain2) {
if (plain1 == null) return null;
if (plain2 == null)
plain1.Condition = this.VisitExpression(plain1.Condition, null);
else
plain1.Condition = this.VisitExpression(plain1.Condition, plain2.Condition);
return plain1;
}
#endif
public virtual Expression VisitPrefixExpression(PrefixExpression pExpr1, PrefixExpression pExpr2)
{
if (pExpr1 == null) return null;
if (pExpr2 == null)
pExpr1.Expression = this.VisitExpression(pExpr1.Expression, null);
else
pExpr1.Expression = this.VisitExpression(pExpr1.Expression, pExpr2.Expression);
return pExpr1;
}
public virtual Expression VisitPostfixExpression(PostfixExpression pExpr1, PostfixExpression pExpr2)
{
if (pExpr1 == null) return null;
if (pExpr2 == null)
pExpr1.Expression = this.VisitExpression(pExpr1.Expression, null);
else
pExpr1.Expression = this.VisitExpression(pExpr1.Expression, pExpr2.Expression);
return pExpr1;
}
public virtual Property VisitProperty(Property property1, Property property2)
{
if (property1 == null) return null;
if (property2 == null)
{
property1.Attributes = this.VisitAttributeList(property1.Attributes, null);
property1.Parameters = this.VisitParameterList(property1.Parameters, null);
property1.Type = this.VisitTypeReference(property1.Type, null);
}
else
{
property1.Attributes = this.VisitAttributeList(property1.Attributes, property2.Attributes);
property1.Parameters = this.VisitParameterList(property1.Parameters, property2.Parameters);
property1.Type = this.VisitTypeReference(property1.Type, property2.Type);
}
return property1;
}
public virtual Expression VisitQuantifier(Quantifier quantifier1, Quantifier quantifier2)
{
if (quantifier1 == null) return null;
if (quantifier2 == null)
{
quantifier1.Comprehension = (Comprehension)this.VisitComprehension(quantifier1.Comprehension, null);
}
else
{
quantifier1.Comprehension = (Comprehension)this.VisitComprehension(quantifier1.Comprehension, quantifier2.Comprehension);
}
return quantifier1;
}
public virtual Expression VisitComprehension(Comprehension comprehension1, Comprehension comprehension2)
{
if (comprehension1 == null) return null;
if (comprehension2 == null)
{
comprehension1.BindingsAndFilters = this.VisitExpressionList(comprehension1.BindingsAndFilters, null);
comprehension1.Elements = this.VisitExpressionList(comprehension1.Elements, null);
}
else
{
comprehension1.BindingsAndFilters = this.VisitExpressionList(comprehension1.BindingsAndFilters, comprehension2.BindingsAndFilters);
comprehension1.Elements = this.VisitExpressionList(comprehension1.Elements, comprehension2.Elements);
}
return comprehension1;
}
public virtual ComprehensionBinding VisitComprehensionBinding(ComprehensionBinding comprehensionBinding1, ComprehensionBinding comprehensionBinding2)
{
if (comprehensionBinding1 == null) return null;
if (comprehensionBinding2 == null)
{
comprehensionBinding1.TargetVariableType = this.VisitTypeReference(comprehensionBinding1.TargetVariableType, null);
comprehensionBinding1.TargetVariable = this.VisitTargetExpression(comprehensionBinding1.TargetVariable, null);
comprehensionBinding1.SourceEnumerable = this.VisitExpression(comprehensionBinding1.SourceEnumerable, null);
}
else
{
comprehensionBinding1.TargetVariableType = this.VisitTypeReference(comprehensionBinding1.TargetVariableType, comprehensionBinding2.TargetVariableType);
comprehensionBinding1.TargetVariable = this.VisitTargetExpression(comprehensionBinding1.TargetVariable, comprehensionBinding2.TargetVariable);
comprehensionBinding1.SourceEnumerable = this.VisitExpression(comprehensionBinding1.SourceEnumerable, comprehensionBinding2.SourceEnumerable);
}
return comprehensionBinding1;
}
public virtual Expression VisitQualifiedIdentifier(QualifiedIdentifier qualifiedIdentifier1, QualifiedIdentifier qualifiedIdentifier2)
{
if (qualifiedIdentifier1 == null) return null;
if (qualifiedIdentifier2 == null)
qualifiedIdentifier1.Qualifier = this.VisitExpression(qualifiedIdentifier1.Qualifier, null);
else
qualifiedIdentifier1.Qualifier = this.VisitExpression(qualifiedIdentifier1.Qualifier, qualifiedIdentifier2.Qualifier);
return qualifiedIdentifier1;
}
public virtual Statement VisitRepeat(Repeat repeat1, Repeat repeat2)
{
if (repeat1 == null) return null;
if (repeat2 == null)
{
repeat1.Body = this.VisitBlock(repeat1.Body, null);
repeat1.Condition = this.VisitExpression(repeat1.Condition, null);
}
else
{
repeat1.Body = this.VisitBlock(repeat1.Body, repeat2.Body);
repeat1.Condition = this.VisitExpression(repeat1.Condition, repeat2.Condition);
}
return repeat1;
}
#if ExtendedRuntime
public virtual RequiresList VisitRequiresList(RequiresList requires1, RequiresList requires2) {
if (requires1 == null) return null;
for (int i = 0, n = requires1.Count, m = requires2 == null ? 0 : requires2.Count; i < n; i++) {
//^ assert requires2 != null;
if (i >= m)
requires1[i] = (Requires)this.Visit(requires1[i], null);
else
requires1[i] = (Requires)this.Visit(requires1[i], requires2[i]);
}
return requires1;
}
#endif
public virtual Statement VisitResourceUse(ResourceUse resourceUse1, ResourceUse resourceUse2)
{
if (resourceUse1 == null) return null;
if (resourceUse2 == null)
{
resourceUse1.ResourceAcquisition = (Statement)this.Visit(resourceUse1.ResourceAcquisition, null);
resourceUse1.Body = this.VisitBlock(resourceUse1.Body, null);
}
else
{
resourceUse1.ResourceAcquisition = (Statement)this.Visit(resourceUse1.ResourceAcquisition, resourceUse2.ResourceAcquisition);
resourceUse1.Body = this.VisitBlock(resourceUse1.Body, resourceUse2.Body);
}
return resourceUse1;
}
public virtual Statement VisitReturn(Return Return1, Return Return2)
{
if (Return1 == null) return null;
if (Return2 == null)
Return1.Expression = this.VisitExpression(Return1.Expression, null);
else
Return1.Expression = this.VisitExpression(Return1.Expression, Return2.Expression);
return Return1;
}
public virtual SecurityAttribute VisitSecurityAttribute(SecurityAttribute attribute1, SecurityAttribute attribute2)
{
return attribute1;
}
public virtual SecurityAttributeList VisitSecurityAttributeList(SecurityAttributeList attributes1, SecurityAttributeList attributes2)
{
if (attributes1 == null) return null;
for (int i = 0, n = attributes1.Count, m = attributes2 == null ? 0 : attributes2.Count; i < n; i++)
{
//^ assert attributes2 != null;
if (i >= m)
attributes1[i] = this.VisitSecurityAttribute(attributes1[i], null);
else
attributes1[i] = this.VisitSecurityAttribute(attributes1[i], attributes2[i]);
}
return attributes1;
}
public virtual Expression VisitSetterValue(SetterValue value1, SetterValue value2)
{
return value1;
}
public virtual StatementList VisitStatementList(StatementList statements1, StatementList statements2)
{
if (statements1 == null) return null;
for (int i = 0, n = statements1.Count, m = statements2 == null ? 0 : statements2.Count; i < n; i++)
{
//^ assert statements2 != null;
if (i >= m)
statements1[i] = (Statement)this.Visit(statements1[i], null);
else
statements1[i] = (Statement)this.Visit(statements1[i], statements2[i]);
}
return statements1;
}
public virtual StatementSnippet VisitStatementSnippet(StatementSnippet snippet1, StatementSnippet snippet2)
{
return snippet1;
}
public virtual StaticInitializer VisitStaticInitializer(StaticInitializer cons1, StaticInitializer cons2)
{
return (StaticInitializer)this.VisitMethod(cons1, cons2);
}
public virtual Struct VisitStruct(Struct Struct1, Struct Struct2)
{
return (Struct)this.VisitTypeNode(Struct1, Struct2);
}
public virtual Statement VisitSwitch(Switch Switch1, Switch Switch2)
{
if (Switch1 == null) return null;
if (Switch2 == null)
{
Switch1.Expression = this.VisitExpression(Switch1.Expression, null);
Switch1.Cases = this.VisitSwitchCaseList(Switch1.Cases, null);
}
else
{
Switch1.Expression = this.VisitExpression(Switch1.Expression, Switch2.Expression);
Switch1.Cases = this.VisitSwitchCaseList(Switch1.Cases, Switch2.Cases);
}
return Switch1;
}
public virtual SwitchCase VisitSwitchCase(SwitchCase switchCase1, SwitchCase switchCase2)
{
if (switchCase1 == null) return null;
if (switchCase2 == null)
{
switchCase1.Label = this.VisitExpression(switchCase1.Label, null);
switchCase1.Body = this.VisitBlock(switchCase1.Body, null);
}
else
{
switchCase1.Label = this.VisitExpression(switchCase1.Label, switchCase2.Label);
switchCase1.Body = this.VisitBlock(switchCase1.Body, switchCase2.Body);
}
return switchCase1;
}
public virtual SwitchCaseList VisitSwitchCaseList(SwitchCaseList switchCases1, SwitchCaseList switchCases2)
{
if (switchCases1 == null) return null;
for (int i = 0, n = switchCases1.Count, m = switchCases2 == null ? 0 : switchCases2.Count; i < n; i++)
{
//^ assert switchCases2 != null;
if (i >= m)
switchCases1[i] = this.VisitSwitchCase(switchCases1[i], null);
else
switchCases1[i] = this.VisitSwitchCase(switchCases1[i], switchCases2[i]);
}
return switchCases1;
}
public virtual Statement VisitSwitchInstruction(SwitchInstruction switchInstruction1, SwitchInstruction switchInstruction2)
{
if (switchInstruction1 == null) return null;
if (switchInstruction2 == null)
switchInstruction1.Expression = this.VisitExpression(switchInstruction1.Expression, null);
else
switchInstruction1.Expression = this.VisitExpression(switchInstruction1.Expression, switchInstruction2.Expression);
return switchInstruction1;
}
public virtual Statement VisitTypeswitch(Typeswitch Typeswitch1, Typeswitch Typeswitch2)
{
if (Typeswitch1 == null) return null;
if (Typeswitch2 == null)
{
Typeswitch1.Expression = this.VisitExpression(Typeswitch1.Expression, null);
Typeswitch1.Cases = this.VisitTypeswitchCaseList(Typeswitch1.Cases, null);
}
else
{
Typeswitch1.Expression = this.VisitExpression(Typeswitch1.Expression, Typeswitch2.Expression);
Typeswitch1.Cases = this.VisitTypeswitchCaseList(Typeswitch1.Cases, Typeswitch2.Cases);
}
return Typeswitch1;
}
public virtual TypeswitchCase VisitTypeswitchCase(TypeswitchCase typeswitchCase1, TypeswitchCase typeswitchCase2)
{
if (typeswitchCase1 == null) return null;
if (typeswitchCase2 == null)
{
typeswitchCase1.LabelType = this.VisitTypeReference(typeswitchCase1.LabelType, null);
typeswitchCase1.LabelVariable = this.VisitTargetExpression(typeswitchCase1.LabelVariable, null);
typeswitchCase1.Body = this.VisitBlock(typeswitchCase1.Body, null);
}
else
{
typeswitchCase1.LabelType = this.VisitTypeReference(typeswitchCase1.LabelType, typeswitchCase2.LabelType);
typeswitchCase1.LabelVariable = this.VisitTargetExpression(typeswitchCase1.LabelVariable, typeswitchCase2.LabelVariable);
typeswitchCase1.Body = this.VisitBlock(typeswitchCase1.Body, typeswitchCase2.Body);
}
return typeswitchCase1;
}
public virtual TypeswitchCaseList VisitTypeswitchCaseList(TypeswitchCaseList typeswitchCases1, TypeswitchCaseList typeswitchCases2)
{
if (typeswitchCases1 == null) return null;
for (int i = 0, n = typeswitchCases1.Count, m = typeswitchCases2 == null ? 0 : typeswitchCases2.Count; i < n; i++)
{
//^ assert typeswitchCases2 != null;
if (i >= m)
typeswitchCases1[i] = this.VisitTypeswitchCase(typeswitchCases1[i], null);
else
typeswitchCases1[i] = this.VisitTypeswitchCase(typeswitchCases1[i], typeswitchCases2[i]);
}
return typeswitchCases1;
}
public virtual Expression VisitTargetExpression(Expression expression1, Expression expression2)
{
return this.VisitExpression(expression1, expression2);
}
public virtual Expression VisitTernaryExpression(TernaryExpression expression1, TernaryExpression expression2)
{
if (expression1 == null) return null;
if (expression2 == null)
{
expression1.Operand1 = this.VisitExpression(expression1.Operand1, null);
expression1.Operand2 = this.VisitExpression(expression1.Operand2, null);
expression1.Operand3 = this.VisitExpression(expression1.Operand3, null);
}
else
{
expression1.Operand1 = this.VisitExpression(expression1.Operand1, expression2.Operand1);
expression1.Operand2 = this.VisitExpression(expression1.Operand2, expression2.Operand2);
expression1.Operand3 = this.VisitExpression(expression1.Operand3, expression2.Operand3);
}
return expression1;
}
public virtual Expression VisitThis(This This1, This This2)
{
if (This1 == null) return null;
if (This2 == null)
This1.Type = this.VisitTypeReference(This1.Type, null);
else
This1.Type = this.VisitTypeReference(This1.Type, This2.Type);
return This1;
}
public virtual Statement VisitThrow(Throw Throw1, Throw Throw2)
{
if (Throw1 == null) return null;
if (Throw2 == null)
Throw1.Expression = this.VisitExpression(Throw1.Expression, null);
else
Throw1.Expression = this.VisitExpression(Throw1.Expression, Throw2.Expression);
return Throw1;
}
public virtual Statement VisitTry(Try Try1, Try Try2)
{
if (Try1 == null) return null;
if (Try2 == null)
{
Try1.TryBlock = this.VisitBlock(Try1.TryBlock, null);
Try1.Catchers = this.VisitCatchList(Try1.Catchers, null);
Try1.Filters = this.VisitFilterList(Try1.Filters, null);
Try1.FaultHandlers = this.VisitFaultHandlerList(Try1.FaultHandlers, null);
Try1.Finally = (Finally)this.VisitFinally(Try1.Finally, null);
}
else
{
Try1.TryBlock = this.VisitBlock(Try1.TryBlock, Try2.TryBlock);
Try1.Catchers = this.VisitCatchList(Try1.Catchers, Try2.Catchers);
Try1.Filters = this.VisitFilterList(Try1.Filters, Try2.Filters);
Try1.FaultHandlers = this.VisitFaultHandlerList(Try1.FaultHandlers, Try2.FaultHandlers);
Try1.Finally = (Finally)this.VisitFinally(Try1.Finally, Try2.Finally);
}
return Try1;
}
#if ExtendedRuntime
public virtual TupleType VisitTupleType(TupleType tuple1, TupleType tuple2){
return (TupleType)this.VisitTypeNode(tuple1, tuple2);
}
public virtual TypeAlias VisitTypeAlias(TypeAlias tAlias1, TypeAlias tAlias2){
if (tAlias1 == null) return null;
if (tAlias2 == null){
if (tAlias1.AliasedType is ConstrainedType)
//The type alias defines the constrained type, rather than just referencing it
tAlias1.AliasedType = this.VisitConstrainedType((ConstrainedType)tAlias1.AliasedType, null);
else
tAlias1.AliasedType = this.VisitTypeReference(tAlias1.AliasedType, null);
}else{
if (tAlias1.AliasedType is ConstrainedType)
//The type alias defines the constrained type, rather than just referencing it
tAlias1.AliasedType = this.VisitConstrainedType((ConstrainedType)tAlias1.AliasedType, tAlias2.AliasedType as ConstrainedType);
else
tAlias1.AliasedType = this.VisitTypeReference(tAlias1.AliasedType, tAlias2.AliasedType);
}
return tAlias1;
}
public virtual TypeIntersection VisitTypeIntersection(TypeIntersection typeIntersection1, TypeIntersection typeIntersection2){
return (TypeIntersection)this.VisitTypeNode(typeIntersection1, typeIntersection2);
}
public virtual TypeContract VisitTypeContract(TypeContract contract1, TypeContract contract2) {
if (contract1 == null) return null;
if (contract2 == null) {
// don't visit contract.DeclaringType
// don't visit contract.InheitedContracts
contract1.Invariants = this.VisitInvariantList(contract1.Invariants, null);
}else{
// don't visit contract.DeclaringType
// don't visit contract.InheitedContracts
contract1.Invariants = this.VisitInvariantList(contract1.Invariants, contract2.Invariants);
}
return contract1;
}
#endif
public virtual TypeMemberSnippet VisitTypeMemberSnippet(TypeMemberSnippet snippet1, TypeMemberSnippet snippet2)
{
return snippet1;
}
public virtual TypeModifier VisitTypeModifier(TypeModifier typeModifier1, TypeModifier typeModifier2)
{
if (typeModifier1 == null) return null;
if (typeModifier2 == null)
{
typeModifier1.Modifier = this.VisitTypeReference(typeModifier1.Modifier, null);
typeModifier1.ModifiedType = this.VisitTypeReference(typeModifier1.ModifiedType, null);
}
else
{
typeModifier1.Modifier = this.VisitTypeReference(typeModifier1.Modifier, typeModifier2.Modifier);
typeModifier1.ModifiedType = this.VisitTypeReference(typeModifier1.ModifiedType, typeModifier2.ModifiedType);
}
return typeModifier1;
}
public virtual TypeNode VisitTypeNode(TypeNode typeNode1, TypeNode typeNode2)
{
if (typeNode1 == null) return null;
if (typeNode2 == null)
{
typeNode1.Attributes = this.VisitAttributeList(typeNode1.Attributes, null);
typeNode1.SecurityAttributes = this.VisitSecurityAttributeList(typeNode1.SecurityAttributes, null);
Class c = typeNode1 as Class;
if (c != null) c.BaseClass = (Class)this.VisitTypeReference(c.BaseClass, null);
typeNode1.Interfaces = this.VisitInterfaceReferenceList(typeNode1.Interfaces, null);
typeNode1.TemplateArguments = this.VisitTypeReferenceList(typeNode1.TemplateArguments, null);
typeNode1.TemplateParameters = this.VisitTypeParameterList(typeNode1.TemplateParameters, null);
typeNode1.Members = this.VisitMemberList(typeNode1.Members, null);
}
else
{
typeNode1.Attributes = this.VisitAttributeList(typeNode1.Attributes, typeNode2.Attributes);
typeNode1.SecurityAttributes = this.VisitSecurityAttributeList(typeNode1.SecurityAttributes, typeNode2.SecurityAttributes);
Class c1 = typeNode1 as Class;
Class c2 = typeNode2 as Class;
if (c1 != null) c1.BaseClass = (Class)this.VisitTypeReference(c1.BaseClass, c2 == null ? null : c2.BaseClass);
typeNode1.Interfaces = this.VisitInterfaceReferenceList(typeNode1.Interfaces, typeNode2.Interfaces);
typeNode1.TemplateArguments = this.VisitTypeReferenceList(typeNode1.TemplateArguments, typeNode2.TemplateArguments);
typeNode1.TemplateParameters = this.VisitTypeParameterList(typeNode1.TemplateParameters, typeNode2.TemplateParameters);
typeNode1.Members = this.VisitMemberList(typeNode1.Members, typeNode2.Members);
}
return typeNode1;
}
public virtual TypeNodeList VisitTypeNodeList(TypeNodeList types1, TypeNodeList types2)
{
if (types1 == null) return null;
if (types2 == null)
{
for (int i = 0; i < types1.Count; i++) //Visiting a type may result in a new type being appended to this list
types1[i] = (TypeNode)this.Visit(types1[i], null);
}
else
{
for (int i = 0; i < types1.Count; i++)
{ //Visiting a type may result in a new type being appended to this list
if (i >= types2.Count)
types1[i] = (TypeNode)this.Visit(types1[i], null);
else
types1[i] = (TypeNode)this.Visit(types1[i], types2[i]);
}
}
return types1;
}
public virtual TypeNode VisitTypeParameter(TypeNode typeParameter1, TypeNode typeParameter2)
{
if (typeParameter1 == null) return null;
if (typeParameter2 == null)
typeParameter1.Interfaces = this.VisitInterfaceReferenceList(typeParameter1.Interfaces, null);
else
typeParameter1.Interfaces = this.VisitInterfaceReferenceList(typeParameter1.Interfaces, typeParameter2.Interfaces);
return typeParameter1;
}
public virtual TypeNodeList VisitTypeParameterList(TypeNodeList typeParameters1, TypeNodeList typeParameters2)
{
if (typeParameters1 == null) return null;
for (int i = 0, n = typeParameters1.Count, m = typeParameters2 == null ? 0 : typeParameters2.Count; i < n; i++)
{
//^ assert typeParameters2 != null;
if (i >= m)
typeParameters1[i] = this.VisitTypeParameter(typeParameters1[i], null);
else
typeParameters1[i] = this.VisitTypeParameter(typeParameters1[i], typeParameters2[i]);
}
return typeParameters1;
}
public virtual TypeNode VisitTypeReference(TypeNode type1, TypeNode type2)
{
return type1;
}
public virtual TypeReference VisitTypeReference(TypeReference typeReference1, TypeReference variableDeclaration2)
{
if (typeReference1 == null) return null;
if (variableDeclaration2 == null)
{
typeReference1.Type = this.VisitTypeReference(typeReference1.Type, null);
typeReference1.Expression = this.VisitTypeReference(typeReference1.Expression, null);
}
else
{
typeReference1.Type = this.VisitTypeReference(typeReference1.Type, variableDeclaration2.Type);
typeReference1.Expression = this.VisitTypeReference(typeReference1.Expression, variableDeclaration2.Expression);
}
return typeReference1;
}
public virtual TypeNodeList VisitTypeReferenceList(TypeNodeList typeReferences1, TypeNodeList typeReferences2)
{
if (typeReferences1 == null) return null;
for (int i = 0, n = typeReferences1.Count, m = typeReferences2 == null ? 0 : typeReferences2.Count; i < n; i++)
{
//^ assert typeReferences2 != null;
if (i >= m)
typeReferences1[i] = this.VisitTypeReference(typeReferences1[i], null);
else
typeReferences1[i] = this.VisitTypeReference(typeReferences1[i], typeReferences2[i]);
}
return typeReferences1;
}
#if ExtendedRuntime
public virtual TypeUnion VisitTypeUnion(TypeUnion typeUnion1, TypeUnion typeUnion2){
return (TypeUnion)this.VisitTypeNode(typeUnion1, typeUnion2);
}
#endif
public virtual Expression VisitUnaryExpression(UnaryExpression unaryExpression1, UnaryExpression unaryExpression2)
{
if (unaryExpression1 == null) return null;
if (unaryExpression2 == null)
unaryExpression1.Operand = this.VisitExpression(unaryExpression1.Operand, null);
else
unaryExpression1.Operand = this.VisitExpression(unaryExpression1.Operand, unaryExpression2.Operand);
return unaryExpression1;
}
public virtual Statement VisitVariableDeclaration(VariableDeclaration variableDeclaration1, VariableDeclaration variableDeclaration2)
{
if (variableDeclaration1 == null) return null;
if (variableDeclaration2 == null)
{
variableDeclaration1.Type = this.VisitTypeReference(variableDeclaration1.Type, null);
variableDeclaration1.Initializer = this.VisitExpression(variableDeclaration1.Initializer, null);
}
else
{
variableDeclaration1.Type = this.VisitTypeReference(variableDeclaration1.Type, variableDeclaration2.Type);
variableDeclaration1.Initializer = this.VisitExpression(variableDeclaration1.Initializer, variableDeclaration2.Initializer);
}
return variableDeclaration1;
}
public virtual UsedNamespace VisitUsedNamespace(UsedNamespace usedNamespace1, UsedNamespace usedNamespace2)
{
return usedNamespace1;
}
public virtual UsedNamespaceList VisitUsedNamespaceList(UsedNamespaceList usedNspaces1, UsedNamespaceList usedNspaces2)
{
if (usedNspaces1 == null) return null;
for (int i = 0, n = usedNspaces1.Count, m = usedNspaces2 == null ? 0 : usedNspaces2.Count; i < n; i++)
{
//^ assert usedNspaces2 != null;
if (i >= m)
usedNspaces1[i] = this.VisitUsedNamespace(usedNspaces1[i], null);
else
usedNspaces1[i] = this.VisitUsedNamespace(usedNspaces1[i], usedNspaces2[i]);
}
return usedNspaces1;
}
public virtual Statement VisitWhile(While While1, While While2)
{
if (While1 == null) return null;
if (While2 == null)
{
While1.Invariants = this.VisitExpressionList(While1.Invariants, null);
While1.Condition = this.VisitExpression(While1.Condition, null);
While1.Body = this.VisitBlock(While1.Body, null);
}
else
{
While1.Invariants = this.VisitExpressionList(While1.Invariants, While2.Invariants);
While1.Condition = this.VisitExpression(While1.Condition, While2.Condition);
While1.Body = this.VisitBlock(While1.Body, While2.Body);
}
return While1;
}
public virtual Statement VisitYield(Yield Yield1, Yield Yield2)
{
if (Yield1 == null) return null;
if (Yield2 == null)
Yield1.Expression = this.VisitExpression(Yield1.Expression, null);
else
Yield1.Expression = this.VisitExpression(Yield1.Expression, Yield2.Expression);
return Yield1;
}
#if ExtendedRuntime
// query nodes
public virtual Node VisitQueryAggregate(QueryAggregate qa1, QueryAggregate qa2){
if (qa1 == null) return null;
if (qa2 == null)
qa1.Expression = this.VisitExpression(qa1.Expression, null);
else
qa1.Expression = this.VisitExpression(qa1.Expression, qa2.Expression);
return qa1;
}
public virtual Node VisitQueryAlias(QueryAlias alias1, QueryAlias alias2){
if (alias1 == null) return null;
if (alias2 == null)
alias1.Expression = this.VisitExpression(alias1.Expression, null);
else
alias1.Expression = this.VisitExpression(alias1.Expression, alias2.Expression);
return alias1;
}
public virtual Node VisitQueryAxis(QueryAxis axis1, QueryAxis axis2){
if (axis1 == null) return null;
if (axis2 == null)
axis1.Source = this.VisitExpression(axis1.Source, null);
else
axis1.Source = this.VisitExpression(axis1.Source, axis2.Source);
return axis1;
}
public virtual Node VisitQueryCommit(QueryCommit qc1, QueryCommit qc2){
return qc1;
}
public virtual Node VisitQueryContext(QueryContext context1, QueryContext context2){
return context1;
}
public virtual Node VisitQueryDelete(QueryDelete delete1, QueryDelete delete2){
if (delete1 == null) return null;
if (delete2 == null){
delete1.Source = this.VisitExpression(delete1.Source, null);
/*delete1.Target =*/ this.VisitExpression(delete1.Target, null); //REVIEW: why should this not be updated?
}else{
delete1.Source = this.VisitExpression(delete1.Source, delete2.Source);
/*delete1.Target =*/ this.VisitExpression(delete1.Target, delete2.Target); //REVIEW: why should this not be updated?
}
return delete1;
}
public virtual Node VisitQueryDifference(QueryDifference diff1, QueryDifference diff2){
if (diff1 == null) return null;
if (diff2 == null){
diff1.LeftSource = this.VisitExpression(diff1.LeftSource, null);
diff1.RightSource = this.VisitExpression(diff1.RightSource, null);
}else{
diff1.LeftSource = this.VisitExpression(diff1.LeftSource, diff2.LeftSource);
diff1.RightSource = this.VisitExpression(diff1.RightSource, diff2.RightSource);
}
return diff1;
}
public virtual Node VisitQueryDistinct(QueryDistinct distinct1, QueryDistinct distinct2){
if (distinct1 == null) return null;
if (distinct2 == null)
distinct1.Source = this.VisitExpression(distinct1.Source, null);
else
distinct1.Source = this.VisitExpression(distinct1.Source, distinct2.Source);
return distinct1;
}
public virtual Node VisitQueryExists(QueryExists exists1, QueryExists exists2){
if (exists1 == null) return null;
if (exists2 == null)
exists1.Source = this.VisitExpression(exists1.Source, null);
else
exists1.Source = this.VisitExpression(exists1.Source, exists2.Source);
return exists1;
}
public virtual Node VisitQueryFilter(QueryFilter filter1, QueryFilter filter2){
if (filter1 == null) return null;
if (filter2 == null){
filter1.Source = this.VisitExpression(filter1.Source, null);
filter1.Expression = this.VisitExpression(filter1.Expression, null);
}else{
filter1.Source = this.VisitExpression(filter1.Source, filter2.Source);
filter1.Expression = this.VisitExpression(filter1.Expression, filter2.Expression);
}
return filter1;
}
public virtual Node VisitQueryGroupBy(QueryGroupBy groupby1, QueryGroupBy groupby2){
if (groupby1 == null) return null;
if (groupby2 == null){
groupby1.Source = this.VisitExpression(groupby1.Source, null);
groupby1.GroupList = this.VisitExpressionList(groupby1.GroupList, null);
groupby1.Having = this.VisitExpression(groupby1.Having, null);
}else{
groupby1.Source = this.VisitExpression(groupby1.Source, groupby2.Source);
groupby1.GroupList = this.VisitExpressionList(groupby1.GroupList, groupby2.GroupList);
groupby1.Having = this.VisitExpression(groupby1.Having, groupby2.Having);
}
return groupby1;
}
public virtual Statement VisitQueryGeneratedType(QueryGeneratedType qgt1, QueryGeneratedType qgt2){
return qgt1;
}
public virtual Node VisitQueryInsert(QueryInsert insert1, QueryInsert insert2){
if (insert1 == null) return null;
if (insert2 == null){
insert1.Location = this.VisitExpression(insert1.Location, null);
insert1.HintList = this.VisitExpressionList(insert1.HintList, null);
insert1.InsertList = this.VisitExpressionList(insert1.InsertList, null);
}else{
insert1.Location = this.VisitExpression(insert1.Location, insert2.Location);
insert1.HintList = this.VisitExpressionList(insert1.HintList, insert2.HintList);
insert1.InsertList = this.VisitExpressionList(insert1.InsertList, insert2.InsertList);
}
return insert1;
}
public virtual Node VisitQueryIntersection(QueryIntersection intersection1, QueryIntersection intersection2){
if (intersection1 == null) return null;
if (intersection2 == null){
intersection1.LeftSource = this.VisitExpression(intersection1.LeftSource, null);
intersection1.RightSource = this.VisitExpression(intersection1.RightSource, null);
intersection1.Type = intersection1.LeftSource == null ? null : intersection1.LeftSource.Type;
}else{
intersection1.LeftSource = this.VisitExpression(intersection1.LeftSource, intersection2.LeftSource);
intersection1.RightSource = this.VisitExpression(intersection1.RightSource, intersection2.RightSource);
intersection1.Type = intersection1.LeftSource == null ? null : intersection1.LeftSource.Type;
}
return intersection1;
}
public virtual Node VisitQueryIterator(QueryIterator xiterator1, QueryIterator xiterator2){
if (xiterator1 == null) return null;
if (xiterator2 == null){
xiterator1.Expression = this.VisitExpression(xiterator1.Expression, null);
xiterator1.HintList = this.VisitExpressionList(xiterator1.HintList, null);
}else{
xiterator1.Expression = this.VisitExpression(xiterator1.Expression, xiterator2.Expression);
xiterator1.HintList = this.VisitExpressionList(xiterator1.HintList, xiterator2.HintList);
}
return xiterator1;
}
public virtual Node VisitQueryJoin(QueryJoin join1, QueryJoin join2){
if (join1 == null) return null;
if (join2 == null){
join1.LeftOperand = this.VisitExpression(join1.LeftOperand, null);
join1.RightOperand = this.VisitExpression(join1.RightOperand, null);
join1.JoinExpression = this.VisitExpression(join1.JoinExpression, null);
}else{
join1.LeftOperand = this.VisitExpression(join1.LeftOperand, join2.LeftOperand);
join1.RightOperand = this.VisitExpression(join1.RightOperand, join2.RightOperand);
join1.JoinExpression = this.VisitExpression(join1.JoinExpression, join2.JoinExpression);
}
return join1;
}
public virtual Node VisitQueryLimit(QueryLimit limit1, QueryLimit limit2){
if (limit1 == null) return null;
if (limit2 == null){
limit1.Source = this.VisitExpression(limit1.Source, null);
limit1.Expression = this.VisitExpression(limit1.Expression, null);
}else{
limit1.Source = this.VisitExpression(limit1.Source, limit2.Source);
limit1.Expression = this.VisitExpression(limit1.Expression, limit2.Expression);
}
return limit1;
}
public virtual Node VisitQueryOrderBy(QueryOrderBy orderby1, QueryOrderBy orderby2){
if (orderby1 == null) return null;
if (orderby2 == null){
orderby1.Source = this.VisitExpression(orderby1.Source, null);
orderby1.OrderList = this.VisitExpressionList(orderby1.OrderList, null);
}else{
orderby1.Source = this.VisitExpression(orderby1.Source, orderby2.Source);
orderby1.OrderList = this.VisitExpressionList(orderby1.OrderList, orderby2.OrderList);
}
return orderby1;
}
public virtual Node VisitQueryOrderItem(QueryOrderItem item1, QueryOrderItem item2){
if (item1 == null) return null;
if (item2 == null)
item1.Expression = this.VisitExpression(item1.Expression, null);
else
item1.Expression = this.VisitExpression(item1.Expression, item2.Expression);
return item1;
}
public virtual Node VisitQueryPosition(QueryPosition position1, QueryPosition position2){
return position1;
}
public virtual Node VisitQueryProject(QueryProject project1, QueryProject project2){
if (project1 == null) return null;
if (project2 == null){
project1.Source = this.VisitExpression(project1.Source, null);
project1.ProjectionList = this.VisitExpressionList(project1.ProjectionList, null);
}else{
project1.Source = this.VisitExpression(project1.Source, project2.Source);
project1.ProjectionList = this.VisitExpressionList(project1.ProjectionList, project2.ProjectionList);
}
return project1;
}
public virtual Node VisitQueryRollback(QueryRollback qr1, QueryRollback qr2){
return qr1;
}
public virtual Node VisitQueryQuantifier(QueryQuantifier qq1, QueryQuantifier qq2){
if (qq1 == null) return null;
if (qq2 == null)
qq1.Expression = this.VisitExpression(qq1.Expression, null);
else
qq1.Expression = this.VisitExpression(qq1.Expression, qq2.Expression);
return qq1;
}
public virtual Node VisitQueryQuantifiedExpression(QueryQuantifiedExpression qqe1, QueryQuantifiedExpression qqe2){
if (qqe1 == null) return null;
if (qqe2 == null)
qqe1.Expression = this.VisitExpression(qqe1.Expression, null);
else
qqe1.Expression = this.VisitExpression(qqe1.Expression, qqe2.Expression);
return qqe1;
}
public virtual Node VisitQuerySelect(QuerySelect select1, QuerySelect select2){
if (select1 == null) return null;
if (select2 == null)
select1.Source = this.VisitExpression(select1.Source, null);
else
select1.Source = this.VisitExpression(select1.Source, select2.Source);
return select1;
}
public virtual Node VisitQuerySingleton(QuerySingleton singleton1, QuerySingleton singleton2){
if (singleton1 == null) return null;
if (singleton2 == null)
singleton1.Source = this.VisitExpression(singleton1.Source, null);
else
singleton1.Source = this.VisitExpression(singleton1.Source, singleton2.Source);
return singleton1;
}
public virtual Node VisitQueryTransact(QueryTransact qt1, QueryTransact qt2){
if (qt1 == null) return null;
if (qt2 == null){
qt1.Source = this.VisitExpression(qt1.Source, null);
qt1.Body = this.VisitBlock(qt1.Body, null);
qt1.CommitBody = this.VisitBlock(qt1.CommitBody, null);
qt1.RollbackBody = this.VisitBlock(qt1.RollbackBody, null);
}else{
qt1.Source = this.VisitExpression(qt1.Source, qt2.Source);
qt1.Body = this.VisitBlock(qt1.Body, qt2.Body);
qt1.CommitBody = this.VisitBlock(qt1.CommitBody, qt2.CommitBody);
qt1.RollbackBody = this.VisitBlock(qt1.RollbackBody, qt2.RollbackBody);
}
return qt1;
}
public virtual Node VisitQueryTypeFilter(QueryTypeFilter filter1, QueryTypeFilter filter2){
if (filter1 == null) return null;
if (filter2 == null)
filter1.Source = this.VisitExpression(filter1.Source, null);
else
filter1.Source = this.VisitExpression(filter1.Source, filter2.Source);
return filter1;
}
public virtual Node VisitQueryUnion(QueryUnion union1, QueryUnion union2){
if (union1 == null) return null;
if (union2 == null){
union1.LeftSource = this.VisitExpression(union1.LeftSource, null);
union1.RightSource = this.VisitExpression(union1.RightSource, null);
}else{
union1.LeftSource = this.VisitExpression(union1.LeftSource, union2.LeftSource);
union1.RightSource = this.VisitExpression(union1.RightSource, union2.RightSource);
}
return union1;
}
public virtual Node VisitQueryUpdate(QueryUpdate update1, QueryUpdate update2){
if (update1 == null) return null;
if (update2 == null){
update1.Source = this.VisitExpression(update1.Source, null);
update1.UpdateList = this.VisitExpressionList(update1.UpdateList, null);
}else{
update1.Source = this.VisitExpression(update1.Source, update2.Source);
update1.UpdateList = this.VisitExpressionList(update1.UpdateList, update2.UpdateList);
}
return update1;
}
public virtual Node VisitQueryYielder(QueryYielder yielder1, QueryYielder yielder2){
if (yielder1 == null) return null;
if (yielder2 == null){
yielder1.Source = this.VisitExpression(yielder1.Source, null);
yielder1.Target = this.VisitExpression(yielder1.Target, null);
yielder1.Body = this.VisitBlock(yielder1.Body, null);
}else{
yielder1.Source = this.VisitExpression(yielder1.Source, yielder2.Source);
yielder1.Target = this.VisitExpression(yielder1.Target, yielder2.Target);
yielder1.Body = this.VisitBlock(yielder1.Body, yielder2.Body);
}
return yielder1;
}
#endif
}
}
#endif