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