--- /dev/null
+package org.simantics.scl.compiler.internal.parsing.types;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+import org.simantics.scl.compiler.elaboration.contexts.TypeTranslationContext;
+import org.simantics.scl.compiler.elaboration.modules.TypeClass;
+import org.simantics.scl.compiler.environment.AmbiguousNameException;
+import org.simantics.scl.compiler.environment.Environments;
+import org.simantics.scl.compiler.internal.parsing.Symbol;
+import org.simantics.scl.compiler.internal.types.TypeElaborationContext;
+import org.simantics.scl.compiler.types.TCon;
+import org.simantics.scl.compiler.types.TPred;
+import org.simantics.scl.compiler.types.Type;
+import org.simantics.scl.compiler.types.Types;
+import org.simantics.scl.compiler.types.exceptions.KindUnificationException;
+import org.simantics.scl.compiler.types.kinds.Kind;
+import org.simantics.scl.compiler.types.kinds.Kinds;
+
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.TIntHashSet;
+
+
+/**
+ * This class is a common base class for type-related nodes in an SCL abstract syntax tree.
+ * sub-nodes of type nodes in the AST are restricted to the subclasses of this abstract base class.
+ */
+public abstract class TypeAst extends Symbol {
+ public static final TypeAst[] EMPTY_ARRAY = new TypeAst[0];
+
+ @Override
+ public String toString() {
+ StringBuilder b = new StringBuilder();
+ toString(b);
+ return b.toString();
+ }
+
+ /**
+ * Write a text representation of this node to a string builder.
+ * All sub-classes must override this abstract method instead of
+ * directly overriding the {@link #toString()} method.
+ */
+ public abstract void toString(StringBuilder b);
+
+ /**
+ * Write a text representation of this node, with parenthesis if demanded by the precedence.
+ * Literals that never need to be parenthesized can override this method directly.
+ */
+ public void toString(StringBuilder b, int outerPrecedence) {
+ if(getPrecedence() >= outerPrecedence) {
+ b.append('(');
+ toString(b);
+ b.append(')');
+ }
+ else
+ toString(b);
+ }
+
+ /**
+ * Translate this node into a Type instance usinga TypeTranslationContext, with expected Kind.
+ */
+ public abstract Type toType(TypeTranslationContext context, Kind expectedKind);
+
+ /**
+ * Elaborate this node into a Type using a TypeElaborationContext.
+ */
+ public abstract Type toType(TypeElaborationContext context);
+
+ /**
+ * Elaborate an array of type nodes into an array of Type instances.
+ */
+ public static Type[] toTypes(TypeElaborationContext context, TypeAst[] typeAsts) {
+ Type[] result = new Type[typeAsts.length];
+ for(int i=0;i<typeAsts.length;++i)
+ result[i] = typeAsts[i].toType(context);
+ return result;
+ }
+
+ /**
+ * Translate an array of type nodes into an array of Type instances, using Kinds.STAR is the expected kind.
+ */
+ public static Type[] toTypes(TypeTranslationContext context, TypeAst[] typeAsts) {
+ Type[] result = new Type[typeAsts.length];
+ for(int i=0;i<typeAsts.length;++i)
+ result[i] = typeAsts[i].toType(context, Kinds.STAR);
+ return result;
+ }
+
+ /**
+ * Get a TPred instance from this node as a type function application (a type class restriction).
+ */
+ public TPred toTFuncApply(TypeTranslationContext context) {
+ ArrayList<Type> parameters = new ArrayList<Type>();
+ ArrayList<Kind> parameterKinds = new ArrayList<Kind>();
+ TypeAst cur = this;
+ loop: while(true) {
+ if(cur instanceof TApplyAst) {
+ TApplyAst apply = (TApplyAst)cur;
+ for(int i=apply.parameters.length-1;i>=0;--i) {
+ TypeAst parameter = apply.parameters[i];
+ Kind kind = Kinds.metaVar();
+ parameters.add(parameter.toType(context, kind));
+ parameterKinds.add(kind);
+ }
+ cur = apply.function;
+ }
+ else if(cur instanceof TVarAst) {
+ TVarAst con = (TVarAst)cur;
+ Collections.reverse(parameters);
+ Collections.reverse(parameterKinds);
+ TCon typeClass;
+ try {
+ typeClass = Environments.getTypeClassName(context.getEnvironment(), con.name);
+ } catch (AmbiguousNameException e1) {
+ context.getErrorLog().log(con.location, e1.getMessage());
+ break;
+ }
+ if(typeClass == null) {
+ context.getErrorLog().log(con.location, "Unresolved type class " + con.name + ".");
+ break;
+ }
+ TypeClass classDesc = context.getEnvironment().getTypeClass(typeClass);
+ if(classDesc.parameters.length != parameters.size()) {
+ context.getErrorLog().log(location, "Wrong number of parameters. " + classDesc.parameters.length + " parameters were expected.");
+ break;
+ }
+ for(int i=0;i<parameterKinds.size();++i)
+ try {
+ Kinds.unify(parameterKinds.get(i), classDesc.parameters[i].getKind());
+ } catch(KindUnificationException e) {
+ context.getErrorLog().log(location, "Parameter kinds do not match. The kind of the parameter " +
+ (i+1) + " should be " + classDesc.parameters[i].getKind() + ".");
+ break loop;
+ }
+ return Types.pred(
+ typeClass,
+ parameters.toArray(new Type[parameters.size()]));
+ }
+ else {
+ context.getErrorLog().log(location, "Invalid constraint.");
+ break;
+ }
+ }
+ // Returns something dummy
+ return Types.pred(Types.ORD, Types.metaVar(Kinds.STAR));
+ }
+
+ /**
+ * Elaborate this node to a type function application. Not supported for all type definition nodes.
+ * @throw UnsupportedOperationException The node does not support elaboration.
+ */
+ public TPred toTFuncApply(TypeElaborationContext context) {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Get node precedence. TVarAst, TEffectAst, TListAst and TTupleAst nodes have precedence 0, TApplyAst has 1,
+ * and TPredAst, TForAllAst and TFunctionAst 2.
+ *
+ * The precedence value is used for generating parentheses in deparsed expressions.
+ */
+ public abstract int getPrecedence();
+
+ /**
+ * Translate this node to an effect Type. Not all type definition constructs are allowed for effects.
+ * @throw UnsupportedOperationException An illegal type definition constuct for effects has been used.
+ */
+ public Type toEffect(TypeTranslationContext context) {
+ throw new UnsupportedOperationException(getClass().getSimpleName() + " does not support toEffect.");
+ }
+
+ /**
+ * Elaborate this node to an effect Type. Not all type definition constructs are allowed for effects.
+ * @throw UnsupportedOperationException An illegal type definition constuct for effects has been used.
+ */
+ public Type toEffect(TypeElaborationContext context) {
+ throw new UnsupportedOperationException(getClass().getSimpleName() + " does not support toEffect.");
+ }
+
+ public abstract void collectReferences(TObjectIntHashMap<String> typeNameMap, TIntHashSet set);
+}
Code Review / simantics / platform.git / blobdiff