bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/EApplyType.java

   1 package org.simantics.scl.compiler.elaboration.expressions;
   2
   3 import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
   4 import org.simantics.scl.compiler.compilation.CompilationContext;
   5 import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;
   6 import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
   7 import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
   8 import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
   9 import org.simantics.scl.compiler.errors.Locations;
  10 import org.simantics.scl.compiler.internal.codegen.references.IVal;
  11 import org.simantics.scl.compiler.internal.codegen.writer.CodeWriter;
  12 import org.simantics.scl.compiler.internal.interpreted.IExpression;
  13 import org.simantics.scl.compiler.top.ExpressionInterpretationContext;
  14 import org.simantics.scl.compiler.types.Type;
  15 import org.simantics.scl.compiler.types.Types;
  16 import org.simantics.scl.compiler.types.exceptions.MatchException;
  17
  18 public class EApplyType extends Expression {
  19     public Expression expression;
  20     Type parameter;
  21
  22     public EApplyType(Expression expression, Type parameter) {
  23         this.expression = expression;
  24         this.parameter = parameter;
  25     }
  26
  27     public static Expression create(Expression expression, Type ... parameters) {
  28         for(Type parameter : parameters)
  29             expression = new EApplyType(expression, parameter);
  30         return expression;
  31     }
  32
  33     public EApplyType(long loc, Expression expression, Type parameter) {
  34         super(loc);
  35         if(parameter == null)
  36             throw new NullPointerException();
  37         this.expression = expression;
  38         this.parameter = parameter;
  39     }
  40
  41     public Expression getExpression() {
  42         return expression;
  43     }
  44
  45     public Type getParameter() {
  46         return parameter;
  47     }
  48
  49     @Override
  50     protected void updateType() throws MatchException {
  51         setType(Types.instantiate(expression.getType(), parameter));
  52     }
  53
  54     @Override
  55     public IVal toVal(CompilationContext context, CodeWriter w) {
  56         IVal val = expression.toVal(context, w);
  57         return val.createSpecialization(parameter);
  58     }
  59
  60     @Override
  61     public Expression simplify(SimplificationContext context) {
  62         expression = expression.simplify(context);
  63         if(expression instanceof EConstant) {
  64             ((EConstant)expression).addTypeParameters(parameter);
  65             return expression;
  66         }
  67         return this;
  68     }
  69
  70     @Override
  71     public Expression resolve(TranslationContext context) {
  72         expression = expression.resolve(context);
  73         return this;
  74     }
  75
  76     @Override
  77     public Expression replace(ReplaceContext context) {
  78         return new EApplyType(expression.replace(context),
  79                 parameter.replace(context.tvarMap));
  80     }
  81
  82     @Override
  83     public IExpression toIExpression(ExpressionInterpretationContext target) {
  84         return expression.toIExpression(target);
  85     }
  86
  87     @Override
  88     public Expression inferType(TypingContext context) {
  89         throw new InternalCompilerError("Should not type check " + getClass().getSimpleName() + ".");
  90     }
  91
  92     @Override
  93     public boolean isEffectful() {
  94         return expression.isEffectful();
  95     }
  96
  97     @Override
  98     public void setLocationDeep(long loc) {
  99         if(location == Locations.NO_LOCATION) {
 100             location = loc;
 101             expression.setLocationDeep(loc);
 102         }
 103     }
 104
 105     @Override
 106     public void accept(ExpressionVisitor visitor) {
 107         visitor.visit(this);
 108     }
 109
 110     @Override
 111     public Expression accept(ExpressionTransformer transformer) {
 112         return transformer.transform(this);
 113     }
 114
 115 }