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

   1 package org.simantics.scl.compiler.elaboration.expressions;
   2
   3 import java.util.ArrayList;
   4
   5 import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
   6 import org.simantics.scl.compiler.common.precedence.Precedence;
   7 import org.simantics.scl.compiler.compilation.CompilationContext;
   8 import org.simantics.scl.compiler.constants.NoRepConstant;
   9 import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;
  10 import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
  11 import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
  12 import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
  13 import org.simantics.scl.compiler.elaboration.errors.NotPatternException;
  14 import org.simantics.scl.compiler.elaboration.expressions.lhstype.LhsType;
  15 import org.simantics.scl.compiler.elaboration.expressions.lhstype.PatternMatchingLhs;
  16 import org.simantics.scl.compiler.elaboration.expressions.printing.ExpressionToStringVisitor;
  17 import org.simantics.scl.compiler.elaboration.query.QAtom;
  18 import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
  19 import org.simantics.scl.compiler.internal.codegen.references.IVal;
  20 import org.simantics.scl.compiler.internal.codegen.writer.CodeWriter;
  21 import org.simantics.scl.compiler.internal.elaboration.decomposed.DecomposedExpression;
  22 import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;
  23 import org.simantics.scl.compiler.internal.interpreted.IExpression;
  24 import org.simantics.scl.compiler.internal.parsing.Symbol;
  25 import org.simantics.scl.compiler.top.ExpressionInterpretationContext;
  26 import org.simantics.scl.compiler.types.TForAll;
  27 import org.simantics.scl.compiler.types.TFun;
  28 import org.simantics.scl.compiler.types.TPred;
  29 import org.simantics.scl.compiler.types.TVar;
  30 import org.simantics.scl.compiler.types.Type;
  31 import org.simantics.scl.compiler.types.Types;
  32 import org.simantics.scl.compiler.types.exceptions.MatchException;
  33 import org.simantics.scl.compiler.types.kinds.Kinds;
  34 import org.simantics.scl.compiler.types.util.Typed;
  35
  36 import gnu.trove.map.hash.TObjectIntHashMap;
  37 import gnu.trove.set.hash.THashSet;
  38 import gnu.trove.set.hash.TIntHashSet;
  39
  40 public abstract class Expression extends Symbol implements Typed {
  41     public static final Expression[] EMPTY_ARRAY = new Expression[0];
  42
  43     transient
  44     private Type type;
  45
  46     public Expression() {
  47     }
  48
  49     public Expression(long loc) {
  50         this.location = loc;
  51     }
  52
  53     @Override
  54     public Type getType() {
  55         if(type == null) {
  56             try {
  57                 updateType();
  58             } catch (MatchException e) {
  59                 throw new InternalCompilerError(e);
  60             }
  61             if(type == null)
  62                 throw new InternalCompilerError(getClass().getSimpleName() +
  63                         ".updateType couldn't compute its type.");
  64         }
  65         return type;
  66     }
  67
  68     public void setType(Type type) {
  69         if(type == null)
  70             throw new NullPointerException();
  71         this.type = type;
  72     }
  73
  74         /**
  75          * Infers the type of the expression without any context. Adds type
  76      * applications and lambdas if needed.
  77          */
  78     public Expression inferType(TypingContext context) {
  79         return checkBasicType(context, Types.metaVar(Kinds.STAR));
  80     }
  81
  82     public Expression checkBasicType(TypingContext context, Type requiredType) {
  83         return context.subsume(inferType(context), requiredType);
  84     }
  85
  86     protected Expression applyPUnit(TypingContext context) {
  87         Type type = Types.canonical(getType());
  88         if(type instanceof TFun) {
  89             TFun fun = (TFun)type;
  90             if(fun.getCanonicalDomain() == Types.PUNIT) {
  91                 EApply result = new EApply(location, this, new ELiteral(NoRepConstant.PUNIT));
  92                 result.effect = fun.getCanonicalEffect();
  93                 context.declareEffect(this.location, result.effect);
  94                 return result;
  95             }
  96         }
  97         return this;
  98     }
  99
 100     public Expression checkIgnoredType(TypingContext context) {
 101         Expression expression = inferType(context);
 102         if(Types.canonical(expression.getType()) != Types.UNIT)
 103             expression = new ESimpleLet(location, null, expression, new ELiteral(NoRepConstant.PUNIT));
 104         return expression;
 105     }
 106
 107         /**
 108          * Checks the type of the expression against the given type. Adds type
 109          * applications and lambdas if needed.
 110          */
 111         public final Expression checkType(TypingContext context, Type requiredType) {
 112             //System.out.println("checkType: " + this + " :: " + requiredType);
 113             if(!context.isInPattern()) {
 114                 requiredType = Types.canonical(requiredType);
 115             if(requiredType instanceof TForAll) {
 116                 TForAll forAll = (TForAll)requiredType;
 117                 TVar var = forAll.var;
 118                 TVar newVar = Types.var(var.getKind());
 119                 requiredType = Types.canonical(forAll.type).replace(var, newVar);
 120                 return new ELambdaType(new TVar[] {newVar}, checkType(context, requiredType));
 121             }
 122             while(requiredType instanceof TFun) {
 123                 TFun fun = (TFun)requiredType;
 124                 if(fun.domain instanceof TPred) { // No need to canonicalize
 125                     ArrayList<Variable> constraints = new ArrayList<Variable>(2);
 126                     while(true) {
 127                         constraints.add(new Variable("constraint", fun.domain));
 128                         requiredType = Types.canonical(fun.range);
 129                         if(!(requiredType instanceof TFun))
 130                             break;
 131                         fun = (TFun)requiredType;
 132                         if(!(fun.domain instanceof TPred))
 133                             break;
 134                     }
 135                     context.pushConstraintFrame(constraints.toArray(new Variable[constraints.size()]));
 136                     Expression expression = checkType(context, requiredType);
 137                     context.popConstraintFrame();
 138                     for(int i=constraints.size()-1;i>=0;--i)
 139                         expression = new ESimpleLambda(constraints.get(i), expression);
 140                     return expression;
 141                 }
 142                 else if(fun.domain == Types.PUNIT) {
 143                     context.pushEffectUpperBound(location, fun.effect);
 144                     Expression expr = checkType(context, fun.range);
 145                     context.popEffectUpperBound();
 146
 147                     // Wrap
 148                     Variable var = new Variable("punit", Types.PUNIT);
 149                     return new ESimpleLambda(location, var, fun.effect, expr);
 150                 }
 151                 else
 152                     break;
 153             }
 154             }
 155             return checkBasicType(context, requiredType);
 156         }
 157
 158         public abstract void collectRefs(TObjectIntHashMap<Object> allRefs, TIntHashSet refs);
 159         public abstract void collectVars(TObjectIntHashMap<Variable> allVars, TIntHashSet vars);
 160         public abstract void forVariables(VariableProcedure procedure);
 161
 162         public Expression decomposeMatching() {
 163         return this;
 164     }
 165
 166         public String toString() {
 167             StringBuilder b = new StringBuilder();
 168             ExpressionToStringVisitor visitor = new ExpressionToStringVisitor(b);
 169             accept(visitor);
 170             return b.toString();
 171     }
 172
 173         protected abstract void updateType() throws MatchException;
 174
 175         public static class TypeValidationException extends Exception {
 176         private static final long serialVersionUID = 3181298127162041248L;
 177
 178         long loc;
 179
 180         public TypeValidationException(long loc) {
 181             this.loc = loc;
 182         }
 183
 184         public long getLoc() {
 185             return loc;
 186         }
 187
 188         public TypeValidationException(long loc, Throwable cause) {
 189             super(cause);
 190             this.loc = loc;
 191         }
 192     }
 193
 194     public static void assertEquals(long loc, Type a, Type b) throws TypeValidationException {
 195         if(!Types.equals(a, b))
 196             throw new TypeValidationException(loc);
 197     }
 198
 199         public abstract IVal toVal(CompilationContext context, CodeWriter w);
 200
 201         public Expression closure(TVar ... vars) {
 202             if(vars.length == 0)
 203             return this;
 204         return new ELambdaType(vars, this);
 205         }
 206
 207     public abstract void collectFreeVariables(THashSet<Variable> vars);
 208
 209     public Expression simplify(SimplificationContext context) {
 210         System.out.println("#############################");
 211         System.out.println(this);
 212         throw new InternalCompilerError(location, getClass().getSimpleName() + " does not support simplify method.");
 213     }
 214
 215     public abstract Expression resolve(TranslationContext context);
 216
 217     /**
 218      * Returns head of the pattern.
 219      */
 220     public EVar getPatternHead() throws NotPatternException {
 221         throw new NotPatternException(this);
 222     }
 223
 224     public LhsType getLhsType() throws NotPatternException {
 225         throw new NotPatternException(this);
 226     }
 227
 228     protected void collectVariableNames(PatternMatchingLhs lhsType) throws NotPatternException {
 229         throw new NotPatternException(this);
 230     }
 231
 232     public void getParameters(TranslationContext translationContext,
 233             ArrayList<Expression> parameters) {
 234         throw new InternalCompilerError("Class " + getClass().getSimpleName() + " does not support getParameters.");
 235     }
 236
 237     public Expression resolveAsPattern(TranslationContext context) {
 238         context.getErrorLog().log(location, "Pattern was expected here.");
 239         return new EError();
 240     }
 241
 242     public void removeFreeVariables(THashSet<Variable> vars) {
 243         throw new InternalCompilerError(getClass().getSimpleName() + " is not a pattern.");
 244     }
 245
 246     public Expression checkTypeAsPattern(TypingContext context, Type requiredType) {
 247         if(context.isInPattern())
 248             throw new InternalCompilerError("Already in a pattern.");
 249         context.setInPattern(true);
 250         Expression expression = checkType(context, requiredType);
 251         context.setInPattern(false);
 252         return expression;
 253     }
 254
 255     /**
 256      * Used during simplification and in toIExpression
 257      */
 258     public THashSet<Variable> getFreeVariables() {
 259         THashSet<Variable> result = new THashSet<Variable>();
 260         collectFreeVariables(result);
 261         return result;
 262     }
 263
 264     public static Expression[] concat(Expression[] a, Expression[] b) {
 265         if(a.length == 0)
 266             return b;
 267         if(b.length == 0)
 268             return a;
 269         Expression[] result = new Expression[a.length + b.length];
 270         for(int i=0;i<a.length;++i)
 271             result[i] = a[i];
 272         for(int i=0;i<b.length;++i)
 273             result[i+a.length] = b[i];
 274         return result;
 275     }
 276
 277     public Expression replace(ReplaceContext context) {
 278         throw new InternalCompilerError(getClass().getSimpleName() + " does not support replace.");
 279     }
 280
 281     public static Expression[] replace(ReplaceContext context, Expression[] expressions) {
 282         Expression[] result = new Expression[expressions.length];
 283         for(int i=0;i<expressions.length;++i)
 284             result[i] = expressions[i].replace(context);
 285         return result;
 286     }
 287
 288     public Expression copy() {
 289         return replace(new ReplaceContext(null));
 290     }
 291
 292     public Expression copy(TypingContext typingContext) {
 293         return replace(new ReplaceContext(typingContext));
 294     }
 295
 296     public abstract void setLocationDeep(long loc);
 297
 298     public Expression replaceInPattern(ReplaceContext context) {
 299         context.inPattern = true;
 300         Expression result = replace(context);
 301         context.inPattern = false;
 302         return result;
 303     }
 304
 305     public int getFunctionDefinitionPatternArity() throws NotPatternException {
 306         throw new NotPatternException(this);
 307     }
 308
 309     public IVal lambdaToVal(CompilationContext context, CodeWriter w) {
 310         DecomposedExpression decomposed = DecomposedExpression.decompose(context.errorLog, this);
 311         CodeWriter newW = w.createFunction(decomposed.typeParameters, decomposed.effect, decomposed.returnType, decomposed.parameterTypes);
 312         IVal[] parameters = newW.getParameters();
 313         IVal functionVal = newW.getFunction().getTarget();
 314         for(int i=0;i<parameters.length;++i)
 315             decomposed.parameters[i].setVal(parameters[i]);
 316         newW.return_(decomposed.body.toVal(context, newW));
 317         return functionVal;
 318     }
 319
 320     public IExpression toIExpression(ExpressionInterpretationContext context) {
 321         throw new UnsupportedOperationException();
 322     }
 323
 324     public static IExpression[] toIExpressions(ExpressionInterpretationContext target, Expression[] expressions) {
 325         IExpression[] result = new IExpression[expressions.length];
 326         for(int i=0;i<expressions.length;++i)
 327             result[i] = expressions[i].toIExpression(target);
 328         return result;
 329     }
 330
 331     public Expression applyType(Type type) {
 332         return new EApplyType(location, this, type);
 333     }
 334
 335     public abstract Expression decorate(ExpressionDecorator decorator);
 336
 337         public boolean isEffectful() {
 338                 return true;
 339         }
 340
 341     public boolean isFunctionPattern() {
 342         return false;
 343     }
 344
 345     public boolean isConstructorApplication() {
 346         return false;
 347     }
 348
 349     public abstract void collectEffects(THashSet<Type> effects);
 350
 351     public Type getEffect() {
 352         THashSet<Type> effects = new THashSet<Type>();
 353         collectEffects(effects);
 354         return Types.union(effects.toArray(new Type[effects.size()]));
 355     }
 356
 357     public abstract void accept(ExpressionVisitor visitor);
 358
 359     public void collectRelationRefs(
 360             final TObjectIntHashMap<SCLRelation> allRefs, final TIntHashSet refs) {
 361         accept(new StandardExpressionVisitor() {
 362             @Override
 363             public void visit(QAtom query) {
 364                 int id = allRefs.get(query.relation);
 365                 if(id >= 0)
 366                     refs.add(id);
 367             }
 368         });
 369     }
 370
 371     public boolean isFunctionDefinitionLhs() {
 372         return false;
 373     }
 374
 375     public Precedence getPrecedence() {
 376         return Precedence.DEFAULT;
 377     }
 378
 379     public boolean isPattern(int arity) {
 380         return false;
 381     }
 382
 383     public abstract Expression accept(ExpressionTransformer transformer);
 384
 385     // TODO implement for all expressions
 386     public boolean equalsExpression(Expression expression) {
 387         return false;
 388     }
 389
 390     /**
 391      * This method returns a lower bound for the function arity of the value this expression defines.
 392      * The lower bound is calculated purely looking the syntax of the expression, not the
 393      * types of the constants and variables the expression refers to.
 394      */
 395     public int getSyntacticFunctionArity() {
 396         return 0;
 397     }
 398 }