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