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

   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.elaboration.utils.ExpressionDecorator;
  13 import org.simantics.scl.compiler.types.Type;
  14 import org.simantics.scl.compiler.types.exceptions.MatchException;
  15
  16 import gnu.trove.map.hash.TObjectIntHashMap;
  17 import gnu.trove.set.hash.THashSet;
  18 import gnu.trove.set.hash.TIntHashSet;
  19
  20 public class EAsPattern extends Expression {
  21
  22     Variable var;
  23     EVar eVar;
  24     Expression pattern;
  25
  26     public EAsPattern(EVar eVar, Expression pattern) {
  27         this.eVar = eVar;
  28         this.pattern = pattern;
  29     }
  30
  31     public EAsPattern(Variable var, Expression pattern) {
  32         this.var = var;
  33         this.pattern = pattern;
  34     }
  35
  36     public Variable getVariable() {
  37         return var;
  38     }
  39
  40     public Expression getPattern() {
  41         return pattern;
  42     }
  43
  44     @Override
  45     public void collectRefs(TObjectIntHashMap<Object> allRefs,
  46             TIntHashSet refs) {
  47         pattern.collectRefs(allRefs, refs);
  48     }
  49
  50     @Override
  51     public void collectVars(TObjectIntHashMap<Variable> allVars,
  52             TIntHashSet vars) {
  53         int id = allVars.get(var);
  54         if(id >= 0)
  55             vars.add(id);
  56         pattern.collectVars(allVars, vars);
  57     }
  58
  59     @Override
  60     public void collectFreeVariables(THashSet<Variable> vars) {
  61         throw new InternalCompilerError(location, "Cannot collect free variables for a pattern.");
  62     }
  63
  64     @Override
  65     public void removeFreeVariables(THashSet<Variable> vars) {
  66         vars.remove(var);
  67         pattern.removeFreeVariables(vars);
  68     }
  69
  70     @Override
  71     public Expression simplify(SimplificationContext context) {
  72         pattern = pattern.simplify(context);
  73         return this;
  74     }
  75
  76     @Override
  77     public Expression resolve(TranslationContext context) {
  78         context.getErrorLog().log(location, "As binding (@) can be used only in patterns.");
  79         return this;
  80     }
  81
  82     @Override
  83     public Expression resolveAsPattern(TranslationContext context) {
  84         var = context.newVariable(eVar.name);
  85         pattern = pattern.resolveAsPattern(context);
  86         return this;
  87     }
  88
  89     @Override
  90     protected void updateType() throws MatchException {
  91         setType(pattern.getType());
  92     }
  93
  94     @Override
  95     public IVal toVal(CompilationContext context, CodeWriter w) {
  96         throw new InternalCompilerError("EAsPattern allowed only in patterns.");
  97     }
  98
  99     @Override
 100     public Expression inferType(TypingContext context) {
 101         pattern = pattern.inferType(context);
 102         var.setType(pattern.getType());
 103         return this;
 104     }
 105
 106     @Override
 107     public Expression checkBasicType(TypingContext context, Type requiredType) {
 108         pattern = pattern.checkBasicType(context, requiredType);
 109         var.setType(pattern.getType());
 110         return this;
 111     }
 112
 113     @Override
 114     public Expression decorate(ExpressionDecorator decorator) {
 115         pattern = pattern.decorate(decorator);
 116         return decorator.decorate(this);
 117     }
 118
 119     @Override
 120     public Expression replace(ReplaceContext context) {
 121         if(!context.inPattern)
 122             throw new IllegalStateException();
 123
 124         Variable newVariable = new Variable(var.name);
 125         newVariable.setType(var.getType().replace(context.tvarMap));
 126         context.varMap.put(var, new EVariable(newVariable));
 127
 128         EAsPattern result = new EAsPattern(eVar, pattern.replace(context));
 129         result.var = newVariable;
 130
 131         return result;
 132     }
 133
 134     @Override
 135     public void collectEffects(THashSet<Type> effects) {
 136         pattern.collectEffects(effects);
 137     }
 138
 139     @Override
 140     public void setLocationDeep(long loc) {
 141         if(location == Locations.NO_LOCATION) {
 142             location = loc;
 143             pattern.setLocationDeep(loc);
 144             if(eVar != null)
 145                 eVar.setLocationDeep(loc);
 146         }
 147     }
 148
 149     @Override
 150     public void accept(ExpressionVisitor visitor) {
 151         visitor.visit(this);
 152     }
 153
 154     @Override
 155     public void forVariables(VariableProcedure procedure) {
 156         procedure.execute(eVar.location, var);
 157         pattern.forVariables(procedure);
 158     }
 159
 160     @Override
 161     public Expression accept(ExpressionTransformer transformer) {
 162         return transformer.transform(this);
 163     }
 164
 165 }