bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/internal/elaboration/decomposed/DecomposedExpression.java

   1 package org.simantics.scl.compiler.internal.elaboration.decomposed;\r
   2 \r
   3 import java.util.ArrayList;\r
   4 \r
   5 import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;\r
   6 import org.simantics.scl.compiler.elaboration.expressions.ELambdaType;\r
   7 import org.simantics.scl.compiler.elaboration.expressions.ESimpleLambda;\r
   8 import org.simantics.scl.compiler.elaboration.expressions.Expression;\r
   9 import org.simantics.scl.compiler.elaboration.expressions.Variable;\r
  10 import org.simantics.scl.compiler.top.SCLCompilerConfiguration;\r
  11 import org.simantics.scl.compiler.types.TVar;\r
  12 import org.simantics.scl.compiler.types.Type;\r
  13 import org.simantics.scl.compiler.types.Types;\r
  14 \r
  15 public class DecomposedExpression {\r
  16     public final TVar[] typeParameters;\r
  17     public final Variable[] parameters;\r
  18     public final Type[] parameterTypes;\r
  19     public final Type effect;\r
  20     public final Type returnType;\r
  21     public final Expression body;\r
  22     \r
  23     public DecomposedExpression(TVar[] typeParameters, Variable[] parameters,\r
  24             Type[] parameterTypes, Type effect, Type returnType, Expression body) {\r
  25         super();\r
  26         if(SCLCompilerConfiguration.DEBUG)\r
  27             if(effect == null)\r
  28                 throw new InternalCompilerError();\r
  29         this.typeParameters = typeParameters;\r
  30         this.parameters = parameters;\r
  31         this.parameterTypes = parameterTypes;\r
  32         this.effect = effect;\r
  33         this.returnType = returnType;\r
  34         this.body = body;\r
  35     }\r
  36 \r
  37     public static DecomposedExpression decompose(Expression expression) {\r
  38         ArrayList<TVar> typeParameterList = new ArrayList<TVar>();\r
  39         ArrayList<Variable> parameterList = new ArrayList<Variable>();\r
  40         Type effect = Types.NO_EFFECTS;\r
  41         while(true) {\r
  42             if(expression instanceof ESimpleLambda) {\r
  43                 ESimpleLambda lambda = (ESimpleLambda)expression;\r
  44                 parameterList.add(lambda.parameter);\r
  45                 expression = lambda.value;\r
  46                 if(Types.canonical(effect) != Types.NO_EFFECTS)\r
  47                     throw new InternalCompilerError();\r
  48                 effect = Types.simplifyFinalEffect(lambda.getLocalEffect());\r
  49             } \r
  50             else if(expression instanceof ELambdaType) {\r
  51                 ELambdaType lambda = (ELambdaType)expression;\r
  52                 expression = lambda.value;\r
  53                 for(TVar parameter : lambda.parameters)\r
  54                     typeParameterList.add(parameter);\r
  55             }\r
  56             else \r
  57                 break;\r
  58         }      \r
  59         \r
  60         TVar[] typeParameters = typeParameterList.isEmpty() ? TVar.EMPTY_ARRAY : \r
  61             typeParameterList.toArray(new TVar[typeParameterList.size()]);\r
  62         Variable[] parameters = parameterList.toArray(new Variable[parameterList.size()]);\r
  63         Type[] parameterTypes = Types.getTypes(parameters);\r
  64         Type returnType = expression.getType();\r
  65         \r
  66         return new DecomposedExpression(\r
  67                 typeParameters, parameters, \r
  68                 parameterTypes, effect, returnType, \r
  69                 expression);\r
  70     }\r
  71 }\r