gerrit.simantics Code Review - simantics/platform.git/blob

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