package org.simantics.scl.compiler.elaboration.contexts;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.set.hash.THashSet;
-
import java.util.ArrayList;
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
-import org.simantics.scl.compiler.common.names.Name;
+import org.simantics.scl.compiler.compilation.CompilationContext;
import org.simantics.scl.compiler.constants.NoRepConstant;
+import org.simantics.scl.compiler.elaboration.expressions.EAmbiguous;
import org.simantics.scl.compiler.elaboration.expressions.EApply;
-import org.simantics.scl.compiler.elaboration.expressions.EConstant;
-import org.simantics.scl.compiler.elaboration.expressions.EError;
import org.simantics.scl.compiler.elaboration.expressions.ELiteral;
import org.simantics.scl.compiler.elaboration.expressions.EPlaceholder;
import org.simantics.scl.compiler.elaboration.expressions.EVariable;
import org.simantics.scl.compiler.elaboration.modules.SCLValue;
import org.simantics.scl.compiler.environment.Environment;
import org.simantics.scl.compiler.errors.ErrorLog;
-import org.simantics.scl.compiler.errors.Locations;
import org.simantics.scl.compiler.internal.elaboration.constraints.Constraint;
import org.simantics.scl.compiler.internal.elaboration.constraints.ConstraintEnvironment;
import org.simantics.scl.compiler.internal.elaboration.constraints.ConstraintSolver;
import org.simantics.scl.compiler.types.kinds.Kinds;
import org.simantics.scl.compiler.types.util.TypeUnparsingContext;
-public class TypingContext implements EnvironmentalContext {
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.set.hash.THashSet;
+
+public class TypingContext {
- private ErrorLog errorLog;
+ private CompilationContext compilationContext;
// Subsumption
private ArrayList<Subsumption> effectSubsumptions = new ArrayList<Subsumption>();
public THashSet<SCLValue> recursiveValues;
public ArrayList<EPlaceholder> recursiveReferences;
+ // Overloading
+ public ArrayList<EAmbiguous> overloadedExpressions = new ArrayList<EAmbiguous>();
+
//TypeUnparsingContext tuc = new TypeUnparsingContext();
Environment environment;
- THashMap<Name, SCLValue> constants = new THashMap<Name, SCLValue>();
- public TypingContext(ErrorLog errorLog, Environment environment) {
- this.errorLog = errorLog;
- this.environment = environment;
+ public TypingContext(CompilationContext compilationContext) {
+ this.compilationContext = compilationContext;
+ this.environment = compilationContext.environment;
}
/**
try {
Types.unify(a, Types.NO_EFFECTS);
} catch(UnificationException e) {
- errorLog.log(loc, "No side-effects allowed here.");
+ compilationContext.errorLog.log(loc, "No side-effects allowed here.");
return;
}
}
* Instantiates type abstractions and constraints from the value.
*/
public Expression instantiate(Expression expr) {
- Type type = Types.weakCanonical(expr.getType());
+ Type type = Types.canonical(expr.getType());
while(type instanceof TForAll) {
TForAll forAll = (TForAll)type;
TVar var = forAll.var;
* type applications, lambdas and effect subsumptions.
*/
public Expression subsume(Expression expr, Type b) {
- b = Types.weakCanonical(b);
+ b = Types.canonical(b);
/*if(b instanceof TForAll) {
TForAll forAll = (TForAll)b;
TVar var = forAll.var;
try {
subsume(sub.loc, a, b);
} catch (UnificationException e) {
- errorLog.log(sub.loc, "Type " + a + " is not a subtype of " + b + ".");
+ compilationContext.errorLog.log(sub.loc, "Type " + a + " is not a subtype of " + b + ".");
}
nontrivialSubs = true;
}
try {
Types.unify(sub.a, sub.b);
} catch (UnificationException e) {
- errorLog.log(sub.loc, "Unification of types failed.");
+ compilationContext.errorLog.log(sub.loc, "Unification of types failed.");
return false;
}
if(type instanceof TMetaVar)
return ((TMetaVar)type).getKind() == Kinds.EFFECT;
else if(type instanceof TCon)
- return environment.getTypeConstructor((TCon)type).kind == Kinds.EFFECT;
+ return environment.getTypeDescriptor((TCon)type).getKind() == Kinds.EFFECT;
else if(type instanceof TVar)
return ((TVar)type).getKind() == Kinds.EFFECT;
else if(type instanceof TUnion)
public void solveSubsumptions(long globalLoc) {
if(expandSubsumptions())
- new SubSolver(errorLog, effectSubsumptions, potentialSingletonEffects, globalLoc).solve();
+ new SubSolver(compilationContext.errorLog, effectSubsumptions, potentialSingletonEffects, globalLoc).solve();
}
public void declareEffect(long loc, Type effect) {
}
public ErrorLog getErrorLog() {
- return errorLog;
+ return compilationContext.errorLog;
}
public boolean isInPattern() {
public void typeError(long loc, Type requiredType, Type givenType) {
TypeUnparsingContext tuc = new TypeUnparsingContext();
- errorLog.log(loc, "Expected <" + requiredType.toString(tuc) + "> got <" + givenType.toString(tuc) + ">.");
+ compilationContext.errorLog.log(loc, "Expected <" + requiredType.toString(tuc) + "> got <" + givenType.toString(tuc) + ">.");
}
public Expression solveConstraints(Environment environment, Expression expression) {
expression);
for(Constraint c : red.unsolvedConstraints)
- errorLog.log(c.getDemandLocation(), "There is no instance for <"+c.constraint+">.");
+ compilationContext.errorLog.log(c.getDemandLocation(), "There is no instance for <"+c.constraint+">.");
}
else
expression = expression.decomposeMatching();
return expression;
}
-
- public SCLValue getValue(Name name) {
- if(constants.containsKey(name))
- return constants.get(name);
- SCLValue value = environment.getValue(name);
- if(value == null)
- errorLog.log(Locations.NO_LOCATION, "Couldn't find " + name + ".");
- constants.put(name, value);
- return value;
- }
-
- public Expression getConstant(Name name, Type ... typeParameters) {
- SCLValue value = getValue(name);
- if(value == null)
- return new EError(Locations.NO_LOCATION);
- return new EConstant(value, typeParameters);
- }
public Environment getEnvironment() {
- return environment;
+ return compilationContext.environment;
+ }
+
+ public CompilationContext getCompilationContext() {
+ return compilationContext;
}
}