mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.AST.Visitors/DefaultNodeVisitor.cs

   1 //
   2 // DefaultNodeVisitor.cs
   3 //
   4 // Authors:
   5 //      Alexander Chebaturkin (chebaturkin@gmail.com)
   6 //
   7 // Copyright (C) 2011 Alexander Chebaturkin
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System.Collections.Generic;
  30
  31 namespace Mono.CodeContracts.Static.AST.Visitors {
  32         class DefaultNodeVisitor : NodeVisitor {
  33                 #region Overrides of NodeVisitor
  34                 public override Node Visit (Node node)
  35                 {
  36                         if (node == null)
  37                                 return null;
  38                         switch (node.NodeType) {
  39                         case NodeType.Nop:
  40                                 return node;
  41
  42                                 #region Binary
  43                         case NodeType.Add:
  44                         case NodeType.Sub:
  45                         case NodeType.Rem:
  46                         case NodeType.Clt:
  47                         case NodeType.Cgt:
  48                         case NodeType.Ceq:
  49                         case NodeType.Box:
  50                         case NodeType.Le:
  51                         case NodeType.Mul:
  52                         case NodeType.Div:
  53                         case NodeType.Div_Un:
  54                         case NodeType.Rem_Un:
  55                         case NodeType.And:
  56                         case NodeType.Or:
  57                         case NodeType.Shr:
  58                         case NodeType.Xor:
  59                         case NodeType.Shl:
  60                         case NodeType.Shr_Un:
  61                         case NodeType.Ne:
  62                         case NodeType.Ge:
  63                         case NodeType.Gt:
  64                         case NodeType.Lt:
  65                         case NodeType.Eq:
  66                                 return VisitBinaryExpression ((BinaryExpression) node);
  67                                 #endregion
  68
  69                         case NodeType.Call:
  70                         case NodeType.Jmp:
  71                         case NodeType.MethodCall:
  72                                 return VisitMethodCall ((MethodCall) node);
  73
  74                         case NodeType.Conv:
  75                         case NodeType.Conv_I1:
  76                         case NodeType.Conv_I2:
  77                         case NodeType.Conv_I8:
  78                         case NodeType.Conv_I4:
  79                         case NodeType.Conv_R4:
  80                         case NodeType.Conv_R8:
  81                         case NodeType.Neg:
  82                         case NodeType.Not:
  83                         case NodeType.LogicalNot:
  84                                 return VisitUnaryExpression ((UnaryExpression) node);
  85
  86                         case NodeType.Literal:
  87                                 return VisitLiteral ((Literal) node);
  88                         case NodeType.This:
  89                                 return VisitThis ((This) node);
  90
  91                         case NodeType.Block:
  92                                 return VisitBlock ((Block) node);
  93                         case NodeType.Branch:
  94                                 return VisitBranch ((Branch) node);
  95                         case NodeType.Return:
  96                                 return VisitReturn ((Return) node);
  97                         case NodeType.AssignmentStatement:
  98                                 return VisitAssignmentStatement ((AssignmentStatement) node);
  99                         case NodeType.Local:
 100                                 return VisitLocal ((Local) node);
 101                         case NodeType.Parameter:
 102                                 return VisitParameter ((Parameter) node);
 103                         case NodeType.ExpressionStatement:
 104                                 return VisitExpressionStatement ((ExpressionStatement) node);
 105                         case NodeType.Method:
 106                                 return VisitMethod ((Method) node);
 107                         case NodeType.MethodContract:
 108                                 return VisitMethodContract ((MethodContract) node);
 109                         case NodeType.Requires:
 110                                 return VisitRequires ((Requires) node);
 111                         case NodeType.Ensures:
 112                                 return VisitEnsures ((Ensures) node);
 113                         case NodeType.TypeNode:
 114                                 return VisitTypeNode ((TypeNode) node);
 115                         case NodeType.Assembly:
 116                                 return VisitAssembly ((AssemblyNode) node);
 117                         case NodeType.Module:
 118                                 return VisitModule ((Module) node);
 119                         case NodeType.MemberBinding:
 120                                 return VisitMemberBinding ((MemberBinding) node);
 121                         case NodeType.Construct:
 122                                 return VisitConstruct ((Construct) node);
 123                         }
 124
 125                         return VisitUnknownNodeType (node);
 126                 }
 127
 128                 public virtual AssemblyNode VisitAssembly (AssemblyNode node)
 129                 {
 130                         if (node == null)
 131                                 return null;
 132
 133                         VisitModuleList (node.Modules);
 134
 135
 136                         return node;
 137                 }
 138
 139                 public virtual void VisitModuleList (IEnumerable<Module> node)
 140                 {
 141                         if (node == null)
 142                                 return;
 143
 144                         foreach (Module module in node)
 145                                 VisitModule (module);
 146                 }
 147
 148                 private Module VisitModule (Module node)
 149                 {
 150                         if (node == null)
 151                                 return null;
 152
 153                         VisitTypeNodeList (node.Types);
 154
 155                         return node;
 156                 }
 157
 158                 public virtual Statement VisitAssignmentStatement (AssignmentStatement node)
 159                 {
 160                         if (node == null)
 161                                 return node;
 162                         node.Target = VisitTargetExpression (node.Target);
 163                         node.Source = VisitExpression (node.Source);
 164
 165                         return node;
 166                 }
 167
 168                 public virtual Expression VisitBinaryExpression (BinaryExpression node)
 169                 {
 170                         if (node == null)
 171                                 return node;
 172
 173                         node.Operand1 = VisitExpression (node.Operand1);
 174                         node.Operand2 = VisitExpression (node.Operand2);
 175
 176                         return node;
 177                 }
 178
 179                 public virtual Block VisitBlock (Block node)
 180                 {
 181                         if (node == null)
 182                                 return null;
 183
 184                         node.Statements = VisitStatementList (node.Statements);
 185
 186                         return node;
 187                 }
 188
 189                 public virtual List<Statement> VisitStatementList (List<Statement> node)
 190                 {
 191                         if (node == null)
 192                                 return null;
 193
 194                         for (int i = 0; i < node.Count; i++)
 195                                 node [i] = (Statement) Visit (node [i]);
 196
 197                         return node;
 198                 }
 199
 200                 public virtual Statement VisitBranch (Branch node)
 201                 {
 202                         if (node == null)
 203                                 return null;
 204
 205                         node.Condition = VisitExpression (node.Condition);
 206
 207                         return node;
 208                 }
 209
 210                 public virtual Expression VisitConstruct (Construct node)
 211                 {
 212                         if (node == null)
 213                                 return null;
 214
 215                         node.Constructor = VisitExpression (node.Constructor);
 216                         node.Arguments = VisitExpressionList (node.Arguments);
 217
 218                         return node;
 219                 }
 220
 221                 public virtual Ensures VisitEnsures (Ensures node)
 222                 {
 223                         if (node == null)
 224                                 return null;
 225
 226                         node.Assertion = VisitExpression (node.Assertion);
 227                         node.UserMessage = VisitExpression (node.UserMessage);
 228
 229                         return node;
 230                 }
 231
 232                 public virtual Expression VisitExpression (Expression node)
 233                 {
 234                         if (node == null)
 235                                 return null;
 236
 237                         return node;
 238                 }
 239
 240                 public virtual Statement VisitExpressionStatement (ExpressionStatement node)
 241                 {
 242                         if (node == null)
 243                                 return null;
 244
 245                         node.Expression = VisitExpression (node.Expression);
 246
 247                         return node;
 248                 }
 249
 250                 public virtual Expression VisitLiteral (Literal node)
 251                 {
 252                         return node;
 253                 }
 254
 255                 public virtual Expression VisitLocal (Local node)
 256                 {
 257                         if (node == null)
 258                                 return null;
 259
 260                         node.Type = VisitTypeNode (node.Type);
 261
 262                         //todo: maybe there should be something else
 263
 264                         return node;
 265                 }
 266
 267                 public virtual Expression VisitMemberBinding (MemberBinding node)
 268                 {
 269                         if (node == null)
 270                                 return null;
 271
 272                         node.TargetObject = VisitExpression (node.TargetObject);
 273
 274                         return node;
 275                 }
 276
 277                 public virtual Method VisitMethod (Method node)
 278                 {
 279                         if (node == null)
 280                                 return null;
 281
 282                         node.ReturnType = VisitTypeNode (node.ReturnType);
 283                         node.Parameters = VisitParameterList (node.Parameters);
 284                         node.MethodContract = VisitMethodContract (node.MethodContract);
 285                         node.Body = VisitBlock (node.Body);
 286
 287                         return node;
 288                 }
 289
 290                 public virtual List<Parameter> VisitParameterList (List<Parameter> node)
 291                 {
 292                         if (node == null)
 293                                 return null;
 294
 295                         for (int i = 0; i < node.Count; i++)
 296                                 node [i] = VisitParameter (node [i]);
 297
 298                         return node;
 299                 }
 300
 301                 public virtual Expression VisitMethodCall (MethodCall node)
 302                 {
 303                         if (node == null)
 304                                 return null;
 305
 306                         node.Callee = VisitExpression (node.Callee);
 307                         node.Arguments = VisitExpressionList (node.Arguments);
 308
 309                         return node;
 310                 }
 311
 312                 public virtual MethodContract VisitMethodContract (MethodContract node)
 313                 {
 314                         if (node == null)
 315                                 return null;
 316
 317                         node.Requires = VisitRequiresList (node.Requires);
 318                         node.Ensures = VisitEnsuresList (node.Ensures);
 319
 320                         return node;
 321                 }
 322
 323                 public virtual List<Ensures> VisitEnsuresList (List<Ensures> node)
 324                 {
 325                         if (node == null)
 326                                 return null;
 327
 328                         for (int i = 0; i < node.Count; i++)
 329                                 node [i] = (Ensures) Visit (node [i]);
 330
 331                         return node;
 332                 }
 333
 334                 public virtual List<Requires> VisitRequiresList (List<Requires> node)
 335                 {
 336                         if (node == null)
 337                                 return null;
 338
 339                         for (int i = 0; i < node.Count; i++)
 340                                 node [i] = (Requires) Visit (node [i]);
 341
 342                         return node;
 343                 }
 344
 345                 public virtual Parameter VisitParameter (Parameter node)
 346                 {
 347                         if (node == null)
 348                                 return null;
 349
 350                         node.Type = VisitTypeNode (node.Type);
 351
 352                         //todo: there may be something else
 353
 354                         return node;
 355                 }
 356
 357                 public virtual Requires VisitRequires (Requires node)
 358                 {
 359                         if (node == null)
 360                                 return null;
 361
 362                         node.Assertion = VisitExpression (node.Assertion);
 363                         node.UserMessage = VisitExpression (node.UserMessage);
 364
 365                         return node;
 366                 }
 367
 368                 public virtual Return VisitReturn (Return node)
 369                 {
 370                         if (node == null)
 371                                 return null;
 372
 373                         node.Expression = VisitExpression (node.Expression);
 374
 375                         return node;
 376                 }
 377
 378                 public virtual Expression VisitTargetExpression (Expression node)
 379                 {
 380                         return VisitExpression (node);
 381                 }
 382
 383                 public virtual Expression VisitThis (This node)
 384                 {
 385                         if (node == null)
 386                                 return null;
 387
 388                         node.Type = VisitTypeNode (node.Type);
 389
 390                         return node;
 391                 }
 392
 393                 public virtual TypeNode VisitTypeNode (TypeNode node)
 394                 {
 395                         if (node == null)
 396                                 return null;
 397
 398                         var clazz = node as Class;
 399                         if (clazz != null)
 400                                 clazz.BaseType = VisitTypeNode (clazz.BaseType);
 401
 402                         VisitPropertiesList (node.Properties);
 403                         VisitMethodsList (node.Methods);
 404                         VisitTypeNodeList (node.NestedTypes);
 405
 406                         return node;
 407                 }
 408
 409                 public virtual List<Property> VisitPropertiesList (List<Property> node)
 410                 {
 411                         if (node == null)
 412                                 return null;
 413
 414                         for (int i = 0; i < node.Count; i++) {
 415                                 Property property = node [i];
 416                                 if (property != null)
 417                                         node [i] = (Property) Visit (node [i]);
 418                         }
 419
 420                         return node;
 421                 }
 422
 423                 public virtual List<Method> VisitMethodsList (List<Method> node)
 424                 {
 425                         if (node == null)
 426                                 return null;
 427
 428                         for (int i = 0; i < node.Count; i++) {
 429                                 Method method = node [i];
 430                                 if (method != null)
 431                                         node [i] = (Method) Visit (node [i]);
 432                         }
 433
 434                         return node;
 435                 }
 436
 437                 public virtual List<TypeNode> VisitTypeNodeList (List<TypeNode> node)
 438                 {
 439                         if (node == null)
 440                                 return null;
 441
 442                         for (int i = 0; i < node.Count; i++) {
 443                                 TypeNode method = node [i];
 444                                 if (method != null)
 445                                         node [i] = (TypeNode) Visit (node [i]);
 446                         }
 447
 448                         return node;
 449                 }
 450
 451                 public virtual Expression VisitUnaryExpression (UnaryExpression node)
 452                 {
 453                         if (node == null)
 454                                 return null;
 455
 456                         node.Operand = VisitExpression (node.Operand);
 457
 458                         return node;
 459                 }
 460
 461                 public virtual Node VisitUnknownNodeType (Node node)
 462                 {
 463                         return node;
 464                 }
 465                 #endregion
 466         }
 467 }