bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/StandardExpressionVisitor.java

   1 package org.simantics.scl.compiler.elaboration.expressions;
   2
   3 import org.simantics.scl.compiler.elaboration.chr.CHRLiteral;
   4 import org.simantics.scl.compiler.elaboration.chr.CHRQuery;
   5 import org.simantics.scl.compiler.elaboration.chr.CHRRule;
   6 import org.simantics.scl.compiler.elaboration.chr.CHRRuleset;
   7 import org.simantics.scl.compiler.elaboration.chr.ast.CHRAstAtom;
   8 import org.simantics.scl.compiler.elaboration.chr.ast.CHRAstBinds;
   9 import org.simantics.scl.compiler.elaboration.chr.ast.CHRAstConjunction;
  10 import org.simantics.scl.compiler.elaboration.chr.ast.CHRAstEquals;
  11 import org.simantics.scl.compiler.elaboration.chr.ast.CHRAstNegation;
  12 import org.simantics.scl.compiler.elaboration.chr.ast.CHRAstQuery;
  13 import org.simantics.scl.compiler.elaboration.chr.ast.CHRAstQueryVisitor;
  14 import org.simantics.scl.compiler.elaboration.equation.EqBasic;
  15 import org.simantics.scl.compiler.elaboration.equation.EqGuard;
  16 import org.simantics.scl.compiler.elaboration.equation.Equation;
  17 import org.simantics.scl.compiler.elaboration.equation.EquationVisitor;
  18 import org.simantics.scl.compiler.elaboration.expressions.ERuleset.DatalogRule;
  19 import org.simantics.scl.compiler.elaboration.expressions.accessor.ExpressionAccessor;
  20 import org.simantics.scl.compiler.elaboration.expressions.accessor.FieldAccessorVisitor;
  21 import org.simantics.scl.compiler.elaboration.expressions.accessor.IdAccessor;
  22 import org.simantics.scl.compiler.elaboration.expressions.accessor.StringAccessor;
  23 import org.simantics.scl.compiler.elaboration.expressions.block.BindStatement;
  24 import org.simantics.scl.compiler.elaboration.expressions.block.CHRStatement;
  25 import org.simantics.scl.compiler.elaboration.expressions.block.GuardStatement;
  26 import org.simantics.scl.compiler.elaboration.expressions.block.IncludeStatement;
  27 import org.simantics.scl.compiler.elaboration.expressions.block.LetStatement;
  28 import org.simantics.scl.compiler.elaboration.expressions.block.RuleStatement;
  29 import org.simantics.scl.compiler.elaboration.expressions.block.Statement;
  30 import org.simantics.scl.compiler.elaboration.expressions.block.StatementVisitor;
  31 import org.simantics.scl.compiler.elaboration.expressions.list.ListAssignment;
  32 import org.simantics.scl.compiler.elaboration.expressions.list.ListGenerator;
  33 import org.simantics.scl.compiler.elaboration.expressions.list.ListGuard;
  34 import org.simantics.scl.compiler.elaboration.expressions.list.ListQualifierVisitor;
  35 import org.simantics.scl.compiler.elaboration.expressions.list.ListSeq;
  36 import org.simantics.scl.compiler.elaboration.expressions.list.ListThen;
  37 import org.simantics.scl.compiler.elaboration.expressions.records.FieldAssignment;
  38 import org.simantics.scl.compiler.elaboration.query.QAlternative;
  39 import org.simantics.scl.compiler.elaboration.query.QAtom;
  40 import org.simantics.scl.compiler.elaboration.query.QConjunction;
  41 import org.simantics.scl.compiler.elaboration.query.QDisjunction;
  42 import org.simantics.scl.compiler.elaboration.query.QExists;
  43 import org.simantics.scl.compiler.elaboration.query.QIf;
  44 import org.simantics.scl.compiler.elaboration.query.QMapping;
  45 import org.simantics.scl.compiler.elaboration.query.QNegation;
  46 import org.simantics.scl.compiler.elaboration.query.Query;
  47 import org.simantics.scl.compiler.elaboration.query.QueryVisitor;
  48
  49
  50 public class StandardExpressionVisitor implements
  51 ExpressionVisitor, QueryVisitor, FieldAccessorVisitor, ListQualifierVisitor,
  52 EquationVisitor, StatementVisitor, CHRAstQueryVisitor {
  53
  54     @Override
  55     public void visit(EApply expression) {
  56         expression.function.accept(this);
  57         for(Expression parameter : expression.parameters)
  58             parameter.accept(this);
  59     }
  60
  61     @Override
  62     public void visit(EApplyType expression) {
  63         expression.expression.accept(this);
  64     }
  65
  66     @Override
  67     public void visit(EAsPattern expression) {
  68         expression.pattern.accept(this);
  69     }
  70
  71     @Override
  72     public void visit(EBind expression) {
  73         expression.pattern.accept(this);
  74         expression.value.accept(this);
  75         expression.in.accept(this);
  76     }
  77
  78     @Override
  79     public void visit(EConstant expression) {
  80     }
  81
  82     @Override
  83     public void visit(EEnforce expression) {
  84         expression.query.accept(this);
  85     }
  86
  87     @Override
  88     public void visit(EError expression) {
  89     }
  90
  91     @Override
  92     public void visit(EExternalConstant expression) {
  93     }
  94
  95     @Override
  96     public void visit(EFieldAccess expression) {
  97         expression.parent.accept(this);
  98         expression.accessor.accept(this);
  99     }
 100
 101     @Override
 102     public void visit(EGetConstraint expression) {
 103         if(expression.evidence != null)
 104             expression.evidence.accept(this);
 105     }
 106
 107     @Override
 108     public void visit(EIf expression) {
 109         expression.condition.accept(this);
 110         expression.then_.accept(this);
 111         if(expression.else_ != null)
 112             expression.else_.accept(this);
 113     }
 114
 115     @Override
 116     public void visit(EIntegerLiteral expression) {
 117         if(expression.constraint != null)
 118             expression.constraint.accept(this);
 119     }
 120
 121     @Override
 122     public void visit(ELambda expression) {
 123         for(Case case_ : expression.cases)
 124             visit(case_);
 125     }
 126
 127     @Override
 128     public void visit(EViewPattern expression) {
 129         expression.expression.accept(this);
 130         expression.pattern.accept(this);
 131     }
 132
 133     public void visit(Case case_) {
 134         for(Expression pattern : case_.patterns)
 135             pattern.accept(this);
 136         case_.value.accept(this);
 137     }
 138
 139     @Override
 140     public void visit(ELambdaType expression) {
 141         expression.value.accept(this);
 142     }
 143
 144     @Override
 145     public void visit(ELet expression) {
 146         for(Assignment assignment : expression.assignments)
 147             visit(assignment);
 148     }
 149
 150     public void visit(Assignment assignment) {
 151         assignment.pattern.accept(this);
 152         assignment.value.accept(this);
 153     }
 154
 155     @Override
 156     public void visit(EListComprehension expression) {
 157         expression.head.accept(this);
 158         expression.qualifier.accept(this);
 159     }
 160
 161     @Override
 162     public void visit(EListLiteral expression) {
 163         for(Expression component : expression.components)
 164             component.accept(this);
 165     }
 166
 167     @Override
 168     public void visit(ELiteral expression) {
 169     }
 170
 171     @Override
 172     public void visit(EMatch expression) {
 173         for(Expression s : expression.scrutinee)
 174             s.accept(this);
 175         for(Case case_ : expression.cases)
 176             visit(case_);
 177     }
 178
 179     @Override
 180     public void visit(EPlaceholder expression) {
 181         expression.expression.accept(this);
 182     }
 183
 184     @Override
 185     public void visit(ERealLiteral expression) {
 186         if(expression.constraint != null)
 187             expression.constraint.accept(this);
 188     }
 189
 190     @Override
 191     public void visit(ERuleset expression) {
 192         for(DatalogRule rule : expression.rules)
 193             visit(rule);
 194         expression.in.accept(this);
 195     }
 196
 197     public void visit(DatalogRule rule) {
 198         for(Expression parameter : rule.headParameters)
 199             parameter.accept(this);
 200         rule.body.accept(this);
 201     }
 202
 203     @Override
 204     public void visit(ESelect expression) {
 205         expression.query.accept(this);
 206         expression.expression.accept(this);
 207     }
 208
 209     @Override
 210     public void visit(ECHRSelect expression) {
 211         visit(expression.query);
 212         expression.expression.accept(this);
 213     }
 214
 215     @Override
 216     public void visit(ESimpleLambda expression) {
 217         expression.value.accept(this);
 218     }
 219
 220     @Override
 221     public void visit(ESimpleLet expression) {
 222         expression.value.accept(this);
 223         expression.in.accept(this);
 224     }
 225
 226     @Override
 227     public void visit(ETransformation expression) {
 228         expression.seed.accept(this);
 229     }
 230
 231     @Override
 232     public void visit(ETypeAnnotation expression) {
 233         expression.value.accept(this);
 234     }
 235
 236     @Override
 237     public void visit(EVar expression) {
 238     }
 239
 240     @Override
 241     public void visit(EVariable expression) {
 242     }
 243
 244     @Override
 245     public void visit(EWhen expression) {
 246         expression.query.accept(this);
 247         expression.action.accept(this);
 248     }
 249
 250     @Override
 251     public void visit(GuardedExpressionGroup expression) {
 252         for(GuardedExpression gexp : expression.expressions) {
 253             for(Expression guard : gexp.guards)
 254                 guard.accept(this);
 255             gexp.value.accept(this);
 256         }
 257     }
 258
 259     @Override
 260     public void visit(QAlternative query) {
 261         for(Query q : query.queries)
 262             q.accept(this);
 263     }
 264
 265     @Override
 266     public void visit(QAtom query) {
 267         for(Expression parameter : query.parameters)
 268             parameter.accept(this);
 269     }
 270
 271     @Override
 272     public void visit(QMapping query) {
 273         for(Expression parameter : query.parameters)
 274             parameter.accept(this);
 275     }
 276
 277     @Override
 278     public void visit(QConjunction query) {
 279         for(Query q : query.queries)
 280             q.accept(this);
 281     }
 282
 283     @Override
 284     public void visit(QDisjunction query) {
 285         for(Query q : query.queries)
 286             q.accept(this);
 287     }
 288
 289     @Override
 290     public void visit(QExists query) {
 291         query.query.accept(this);
 292     }
 293
 294     @Override
 295     public void visit(QNegation query) {
 296         query.query.accept(this);
 297     }
 298
 299     @Override
 300     public void visit(ExpressionAccessor accessor) {
 301         accessor.fieldName.accept(this);
 302     }
 303
 304     @Override
 305     public void visit(IdAccessor accessor) {
 306     }
 307
 308     @Override
 309     public void visit(StringAccessor accessor) {
 310     }
 311
 312     @Override
 313     public void visit(ListAssignment qualifier) {
 314         qualifier.pattern.accept(this);
 315         qualifier.value.accept(this);
 316     }
 317
 318     @Override
 319     public void visit(ListGenerator qualifier) {
 320         qualifier.pattern.accept(this);
 321         qualifier.value.accept(this);
 322     }
 323
 324     @Override
 325     public void visit(ListGuard qualifier) {
 326         qualifier.condition.accept(this);
 327     }
 328
 329     @Override
 330     public void visit(ListSeq qualifier) {
 331         qualifier.a.accept(this);
 332         qualifier.b.accept(this);
 333     }
 334
 335     @Override
 336     public void visit(ListThen qualifier) {
 337         qualifier.left.accept(this);
 338         qualifier.transformer.accept(this);
 339         if(qualifier.by != null)
 340             qualifier.by.accept(this);
 341     }
 342
 343     @Override
 344     public void visit(QIf query) {
 345         query.condition.accept(this);
 346         query.thenQuery.accept(this);
 347         query.elseQuery.accept(this);
 348     }
 349
 350     @Override
 351     public void visit(ECoveringBranchPoint expression) {
 352         expression.expression.accept(this);
 353     }
 354
 355     @Override
 356     public void visit(EqBasic equation) {
 357         equation.left.accept(this);
 358         equation.right.accept(this);
 359     }
 360
 361     @Override
 362     public void visit(EqGuard equation) {
 363         equation.guard.accept(this);
 364     }
 365
 366     @Override
 367     public void visit(EEquations expression) {
 368         for(Equation equation : expression.equations)
 369             equation.accept(this);
 370     }
 371
 372     public void visit(CHRQuery query) {
 373         for(CHRLiteral literal : query.literals)
 374             for(Expression parameter : literal.parameters)
 375                 parameter.accept(this);
 376     }
 377
 378     public void visit(CHRRuleset ruleset) {
 379         for(CHRRule rule : ruleset.rules) {
 380             visit(rule.head);
 381             visit(rule.body);
 382         }
 383     }
 384
 385     @Override
 386     public void visit(ECHRRuleset expression) {
 387         visit(expression.ruleset);
 388         expression.in.accept(this);
 389     }
 390
 391     @Override
 392     public void visit(ECHRRulesetConstructor expression) {
 393         visit(expression.ruleset);
 394     }
 395
 396     @Override
 397     public void visit(EBinary expression) {
 398         expression.left.accept(this);
 399         for(EBinaryRightSide right : expression.rights)
 400             right.right.accept(this);
 401     }
 402
 403     @Override
 404     public void visit(EBlock expression) {
 405         for(Statement stat : expression.statements)
 406             stat.accept(this);
 407     }
 408
 409     @Override
 410     public void visit(EPreLet expression) {
 411         for(LetStatement stat : expression.assignments) {
 412             stat.pattern.accept(this);
 413             stat.value.accept(this);
 414         }
 415         expression.in.accept(this);
 416     }
 417
 418     @Override
 419     public void visit(ERange expression) {
 420         expression.from.accept(this);
 421         expression.to.accept(this);
 422     }
 423
 424     @Override
 425     public void visit(ERecord expression) {
 426         for(FieldAssignment assignment : expression.fields)
 427             assignment.value.accept(this);
 428
 429     }
 430
 431     @Override
 432     public void visit(EStringLiteral expression) {
 433         for(Expression exp : expression.expressions)
 434             exp.accept(this);
 435     }
 436
 437     @Override
 438     public void visit(BindStatement statement) {
 439         statement.pattern.accept(this);
 440         statement.value.accept(this);
 441     }
 442
 443     @Override
 444     public void visit(GuardStatement statement) {
 445         statement.value.accept(this);
 446     }
 447
 448     @Override
 449     public void visit(LetStatement statement) {
 450         statement.value.accept(this);
 451     }
 452
 453     @Override
 454     public void visit(RuleStatement statement) {
 455         statement.head.accept(this);
 456         statement.body.accept(this);
 457     }
 458
 459     @Override
 460     public void visit(IncludeStatement statement) {
 461         statement.value.accept(this);
 462     }
 463
 464     @Override
 465     public void visit(CHRStatement statement) {
 466         statement.body.accept(this);
 467         statement.head.accept(this);
 468     }
 469
 470     @Override
 471     public void visit(CHRAstAtom query) {
 472         query.expression.accept(this);
 473     }
 474
 475     @Override
 476     public void visit(CHRAstBinds query) {
 477         query.left.accept(this);
 478         query.right.accept(this);
 479     }
 480
 481     @Override
 482     public void visit(CHRAstConjunction query) {
 483         for(CHRAstQuery conjunct : query.conjuncts)
 484             conjunct.accept(this);
 485     }
 486
 487     @Override
 488     public void visit(CHRAstEquals query) {
 489         query.left.accept(this);
 490         query.right.accept(this);
 491     }
 492
 493     @Override
 494     public void visit(CHRAstNegation query) {
 495         query.subquery.accept(this);
 496     }
 497 }