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

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