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

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