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