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