bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/types/TPred.java

   1 package org.simantics.scl.compiler.types;
   2
   3 import java.util.ArrayList;
   4
   5 import org.simantics.scl.compiler.environment.Environment;
   6 import org.simantics.scl.compiler.internal.types.HashCodeUtils;
   7 import org.simantics.scl.compiler.internal.types.TypeHashCodeContext;
   8 import org.simantics.scl.compiler.internal.types.ast.TApplyAst;
   9 import org.simantics.scl.compiler.internal.types.ast.TypeAst;
  10 import org.simantics.scl.compiler.types.exceptions.KindUnificationException;
  11 import org.simantics.scl.compiler.types.kinds.Kind;
  12 import org.simantics.scl.compiler.types.kinds.Kinds;
  13 import org.simantics.scl.compiler.types.util.Polarity;
  14 import org.simantics.scl.compiler.types.util.TypeUnparsingContext;
  15
  16 import gnu.trove.map.hash.THashMap;
  17 import gnu.trove.set.hash.THashSet;
  18
  19
  20
  21 public class TPred extends Type {
  22
  23     public static final TPred[] EMPTY_ARRAY = new TPred[0];
  24
  25     public final TCon typeClass;
  26     public final Type[] parameters;
  27
  28     TPred(TCon typeClass, Type ... parameters) {
  29         if(NULL_CHECKS) {
  30             if(typeClass == null || parameters == null)
  31                 throw new NullPointerException();
  32             for(Type parameter : parameters)
  33                 if(parameter == null)
  34                     throw new NullPointerException();
  35         }
  36         this.typeClass = typeClass;
  37         this.parameters = parameters;
  38     }
  39
  40     @Override
  41     public TPred replace(TVar var, Type replacement) {
  42         for(int i=0;i<parameters.length;++i) {
  43             Type parameter = parameters[i];
  44             Type newParameter = parameter.replace(var, replacement);
  45             if(parameter != newParameter) {
  46                 Type[] newParameters = new Type[parameters.length];
  47                 for(int j=0;j<i;++j)
  48                     newParameters[j] = parameters[j];
  49                 newParameters[i] = newParameter;
  50                 for(int j=i+1;j<parameters.length;++j)
  51                     newParameters[j] = parameters[j].replace(var, replacement);
  52                 return new TPred(typeClass, newParameters);
  53             }
  54         }
  55         return this;
  56     }
  57
  58     @Override
  59     public TypeAst toTypeAst(TypeUnparsingContext context) {
  60         TypeAst ast = typeClass.toTypeAst(context);
  61         for(Type parameter : parameters)
  62             ast = new TApplyAst(ast, parameter.toTypeAst(context));
  63         return ast;
  64     }
  65
  66     @Override
  67     public void updateHashCode(TypeHashCodeContext context) {
  68         typeClass.updateHashCode(context);
  69         for(Type parameter : parameters)
  70             parameter.updateHashCode(context);
  71     }
  72
  73     @Override
  74     public void collectFreeVars(ArrayList<TVar> vars) {
  75         for(Type parameter : parameters)
  76             parameter.collectFreeVars(vars);
  77     }
  78
  79     @Override
  80     public void collectMetaVars(ArrayList<TMetaVar> vars) {
  81         for(Type parameter : parameters)
  82             parameter.collectMetaVars(vars);
  83     }
  84
  85     @Override
  86     public void collectMetaVars(THashSet<TMetaVar> vars) {
  87         for(Type parameter : parameters)
  88             parameter.collectMetaVars(vars);
  89     }
  90
  91     @Override
  92     public boolean contains(TMetaVar other) {
  93         for(Type parameter : parameters)
  94             if(parameter.contains(other))
  95                 return true;
  96         return false;
  97     }
  98
  99     @Override
 100     public Type convertMetaVarsToVars() {
 101         for(int i=0;i<parameters.length;++i) {
 102             Type parameter = parameters[i];
 103             Type temp = parameter.convertMetaVarsToVars();
 104             if(temp != parameter) {
 105                 Type[] newParameters = new Type[parameters.length];
 106                 for(int j=0;j<i;++j)
 107                     newParameters[j] = parameters[j];
 108                 newParameters[i] = temp;
 109                 for(int j=i+1;j<parameters.length;++j)
 110                     newParameters[j] = parameters[j].convertMetaVarsToVars();
 111                 return new TPred(typeClass, parameters);
 112             }
 113         }
 114         return this;
 115     }
 116
 117     @Override
 118     public boolean isGround() {
 119         for(Type parameter : parameters)
 120             if(!parameter.isGround())
 121                 return false;
 122         return true;
 123     }
 124
 125
 126         public Kind inferKind(Environment context) throws KindUnificationException {
 127         return Kinds.STAR;
 128     }
 129
 130     @Override
 131     public boolean containsMetaVars() {
 132         for(Type parameter : parameters)
 133             if(parameter.containsMetaVars())
 134                 return true;
 135         return false;
 136     }
 137
 138     @Override
 139     public void toName(TypeUnparsingContext context, StringBuilder b) {
 140         typeClass.toName(context, b);
 141         for(Type parameter : parameters) {
 142             b.append('_');
 143             parameter.toName(context, b);
 144         }
 145     }
 146
 147     @Override
 148     public int getClassId() {
 149         return PRED_ID;
 150     }
 151
 152     @Override
 153     public void addPolarity(Polarity polarity) {
 154         for(Type parameter : parameters)
 155             parameter.addPolarity(Polarity.BIPOLAR);
 156     }
 157
 158     @Override
 159     public void collectEffectMetaVars(ArrayList<TMetaVar> vars) {
 160         for(Type parameter : parameters)
 161             parameter.collectEffectMetaVars(vars);
 162     }
 163
 164     @Override
 165     public Type head() {
 166         throw new UnsupportedOperationException();
 167     }
 168
 169     @Override
 170     public Type copySkeleton(THashMap<TMetaVar, TMetaVar> metaVarMap) {
 171         Type[] newParameters = new Type[parameters.length];
 172         for(int i=0;i<parameters.length;++i)
 173             newParameters[i] = parameters[i].copySkeleton(metaVarMap);
 174         return new TPred(typeClass, parameters);
 175     }
 176
 177     @Override
 178     public int hashCode(int hash) {
 179         hash = HashCodeUtils.updateWithPreprocessedValue(hash, PRED_HASH);
 180         hash = typeClass.hashCode(hash);
 181         for(Type parameter : parameters)
 182             hash = parameter.hashCode(hash);
 183         return hash;
 184     }
 185
 186     @Override
 187     public int hashCode(int hash, TVar[] boundVars) {
 188         hash = HashCodeUtils.updateWithPreprocessedValue(hash, PRED_HASH);
 189         hash = typeClass.hashCode(hash, boundVars);
 190         for(Type parameter : parameters)
 191             hash = parameter.hashCode(hash, boundVars);
 192         return hash;
 193     }
 194
 195     @Override
 196     public boolean equalsCanonical(Type other) {
 197         if(this == other)
 198             return true;
 199         if(!other.getClass().equals(TPred.class))
 200             return false;
 201         TPred pred = (TPred)other;
 202         if(typeClass != pred.typeClass || parameters.length != pred.parameters.length)
 203             return false;
 204         for(int i=0;i<parameters.length;++i)
 205             if(!Types.canonical(parameters[i]).equalsCanonical(Types.canonical(pred.parameters[i])))
 206                 return false;
 207         return true;
 208     }
 209
 210     @Override
 211     public Kind getKind(Environment context) {
 212         return Kinds.STAR;
 213     }
 214 }