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