/** @see jaskell.compiler.JaskellVisitor#visit(Conditional) */
public Object visit(Conditional conditional) {
Type iff = (Type) conditional.getIfFalse().visit(this);
Type ift = (Type) conditional.getIfTrue().visit(this);
Type tcond = (Type) conditional.getCondition().visit(this);
tcond = tu.unify(tcond, Primitives.BOOL, typeVariablesMap);
if (!(tcond.equals(Primitives.BOOL)))
throw new TypeError("Conditional expression is not of type Bool : " + tcond);
/* unify false and true parts */
Type uni = tu.unify(iff, ift, typeVariablesMap);
conditional.setType(uni);
return uni;
}
/** @see jaskell.compiler.JaskellVisitor#visit(Application) */
public Object visit(Application a) {
try {
/* get type of function */
Expression fun = a.getFunction();
/* get type deduced from arguments */
LinkedList l = new LinkedList();
Iterator it = a.getArgs().iterator();
while (it.hasNext()) {
Expression e = (Expression) it.next();
l.add((Type) e.visit(this));
}
Type vt = TypeFactory.freshBinding();
Type ft = Types.fun(l, vt);
log.finer("TypeChecker => In application " + a + ", type is " + ft);
/* apply substitution on both types */
ft = subst.substitute(ft);
/* try to unify function type and constructed types */
Type t = (Type) fun.visit(this);
log.finer("In application, function " + fun + " :: " + t);
t = subst.substitute(t);
log.finer("In application, trying to unify function type " + t + " with body " + ft);
/*
* TODO : problem with unification of constrained types
*/
TypeApplication uni = (TypeApplication) tu.unify(t, ft, typeVariablesMap);
/* sets type of functional expression - this allows
* polymorphic functions to receive several types
* in the same code */
// fun.setType(uni);
/* apply arguments type to compute return type */
log.finer("Done unify application :" + uni);
it = PrimitiveType.functionIterator(uni);
Iterator it2 = l.iterator();
TypeApplication ut = uni;
while (it2.hasNext()) {
/* type of argument */
Type at = (Type) it2.next();
ut = (TypeApplication) it.next();
/* try unification */
tu.unify(((TypeApplication) ut.getDomain()).getRange(), at, new HashMap(typeVariablesMap));
}
ft = subst.substitute(ft);
fun.setType(ft);
log.finer("Setting type of functional element [" + fun + "] to :" + ft);
a.setType(ut.getRange());
return ut.getRange();
} catch (TypeError te) {
if (te.getLineCol() == null) te.setLineCol(a.getTag("source"));
throw te;
}
}
/** @see jaskell.compiler.JaskellVisitor#visit(ConstructorPattern) */
public Object visit(ConstructorPattern a) {
String cname = a.getConstructor().getName();
/* retrieve parameter types of constructor */
ConstructorDefinition ctor = (ConstructorDefinition) a.getConstructor().lookup(cname);
if (ctor == null) throw new TypeError("Undefined constructor pattern " + a);
/* type of data constructed by constructor */
TypeInstantiator ti = new TypeInstantiator(ctor.getDataType());
Type rtype = ti.instance();
Map map = ti.getMap();
TypeSubstitution ts = new TypeSubstitution(map);
Iterator ittypes = ctor.getParameters().iterator();
/* retrieve type of patterns */
Iterator it = a.getSubPatterns();
while (it.hasNext()) {
try {
Pattern p = (Pattern) it.next();
Type actual = TypeFactory.freshBinding();
Type formal = ts.substitute((Type) ittypes.next());
/* unify both types */
p.setType(tu.unify(formal, actual, typeVariablesMap));
} catch (NoSuchElementException nex) {
throw new TypeError("Wrong number of arguments to pattern " + a);
}
}
a.setType(rtype);
return a.getType();
}
/**
* Remember that we are trying to cast something of type {@code supertype} to {@code subtype}.
*
* <p>Since at runtime we can only check the class (type constructor), the rest of the subtype
* should be known statically, from supertype. This method reconstructs all static information
* that can be obtained from supertype.
*
* <p>Example 1: supertype = Collection<String> subtype = List<...> result = List<String>, all
* arguments are inferred
*
* <p>Example 2: supertype = Any subtype = List<...> result = List<*>, some arguments were not
* inferred, replaced with '*'
*/
public static TypeReconstructionResult findStaticallyKnownSubtype(
@NotNull KotlinType supertype, @NotNull TypeConstructor subtypeConstructor) {
assert !supertype.isMarkedNullable() : "This method only makes sense for non-nullable types";
// Assume we are casting an expression of type Collection<Foo> to List<Bar>
// First, let's make List<T>, where T is a type variable
ClassifierDescriptor descriptor = subtypeConstructor.getDeclarationDescriptor();
assert descriptor != null : "Can't create default type for " + subtypeConstructor;
KotlinType subtypeWithVariables = descriptor.getDefaultType();
// Now, let's find a supertype of List<T> that is a Collection of something,
// in this case it will be Collection<T>
KotlinType supertypeWithVariables =
TypeCheckingProcedure.findCorrespondingSupertype(subtypeWithVariables, supertype);
final List<TypeParameterDescriptor> variables =
subtypeWithVariables.getConstructor().getParameters();
Map<TypeConstructor, TypeProjection> substitution;
if (supertypeWithVariables != null) {
// Now, let's try to unify Collection<T> and Collection<Foo> solution is a map from T to Foo
TypeUnifier.UnificationResult solution =
TypeUnifier.unify(
new TypeProjectionImpl(supertype),
new TypeProjectionImpl(supertypeWithVariables),
new Predicate<TypeConstructor>() {
@Override
public boolean apply(TypeConstructor typeConstructor) {
ClassifierDescriptor descriptor = typeConstructor.getDeclarationDescriptor();
return descriptor instanceof TypeParameterDescriptor
&& variables.contains(descriptor);
}
});
substitution = Maps.newHashMap(solution.getSubstitution());
} else {
// If there's no corresponding supertype, no variables are determined
// This may be OK, e.g. in case 'Any as List<*>'
substitution = Maps.newHashMapWithExpectedSize(variables.size());
}
// If some of the parameters are not determined by unification, it means that these parameters
// are lost,
// let's put stars instead, so that we can only cast to something like List<*>, e.g. (a: Any) as
// List<*>
boolean allArgumentsInferred = true;
for (TypeParameterDescriptor variable : variables) {
TypeProjection value = substitution.get(variable.getTypeConstructor());
if (value == null) {
substitution.put(variable.getTypeConstructor(), TypeUtils.makeStarProjection(variable));
allArgumentsInferred = false;
}
}
// At this point we have values for all type parameters of List
// Let's make a type by substituting them: List<T> -> List<Foo>
KotlinType substituted =
TypeSubstitutor.create(substitution).substitute(subtypeWithVariables, Variance.INVARIANT);
return new TypeReconstructionResult(substituted, allArgumentsInferred);
}
private void doTest(String known, String withVariables, @NotNull Map<String, String> expected) {
TypeUnifier.UnificationResult map =
TypeUnifier.unify(
makeType(known),
makeType(withVariables),
new Predicate<TypeConstructor>() {
@Override
public boolean apply(TypeConstructor tc) {
return variables.contains(tc);
}
});
assertEquals(expected, toStrings(map));
}
/** @see jaskell.compiler.JaskellVisitor#visit(Alternative) */
public Object visit(Alternative a) {
try {
Type tex = (Type) a.getExpression().visit(this);
log.finer("In alternative, type of expression " + a.getExpression() + " is " + tex);
/* set type of bound variable */
LocalBinding lb = a.getBinding();
if (lb != null) lb.setType(tex);
/* visit type of alternatives */
Iterator it = a.getChoices();
Type ptype = tex;
Type btype = null;
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
/* checkt type of pattern */
Type pt = (Type) ((Pattern) entry.getKey()).visit(this);
if (ptype == null) ptype = pt;
else ptype = tu.unify(pt, ptype, typeVariablesMap);
log.finer("In alternative, unifying pattern type " + pt + " to " + ptype);
Expression expr = (Expression) entry.getValue();
/* check type of body */
Type bt = (Type) expr.visit(this);
// /* apply substitution with type variables from pattern */
// TypeSubstitution ts = new TypeSubstitution(typeVariablesMap);
// expr.visit(ts);
if (btype == null) btype = bt;
else btype = tu.unify(bt, btype, typeVariablesMap);
log.finer("In alternative, unifying body type " + bt + " to " + btype);
}
/* visit default choice */
Type deft = (Type) a.getWildcard().visit(this);
a.setType(btype);
return btype;
} catch (TypeError te) {
if (te.getLineCol() == null) te.setLineCol(a.getTag("source"));
throw te;
}
}
/** @see jaskell.compiler.JaskellVisitor#visit(Abstraction) */
public Object visit(Abstraction a) {
try {
Type t = a.getType();
if (t != null) return subst.substitute(t);
log.finest("Visiting abstraction : " + a);
Expression body = a.getBody();
/* duplicate bindings map to assign types to variables */
pushContext(a.getBindings());
/* create fresh type variables as type for each bound
* variable */
Iterator it = namesMap.values().iterator();
LinkedList tl = new LinkedList();
while (it.hasNext()) {
LocalBinding name = (LocalBinding) it.next();
Type vt = TypeFactory.freshBinding();
name.setType(vt);
tl.add(vt);
}
Type tv = TypeFactory.freshBinding();
/* create type with all variables for function */
Type ft = Types.fun(tl, tv);
log.finer("In abstraction, setting type to " + ft);
a.setType(ft);
/* analyze body */
Type bt = (Type) body.visit(this);
/* unify return type of function with type of body */
Type ret = tu.unify(PrimitiveType.getReturnType(ft), bt, typeVariablesMap);
TyvarSubstitution tys = new TyvarSubstitution(typeVariablesMap);
tys.visit(a);
log.finer("Done abstraction, setting type from " + ft + " to " + a.getType());
popContext();
return a.getType();
} catch (TypeError te) {
if (te.getLineCol() == null) te.setLineCol(a.getTag("source"));
throw te;
}
}
