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