Package net.hydromatic.morel.compile

Class TypeResolver

java.lang.Object

net.hydromatic.morel.compile.TypeResolver

public class TypeResolver
extends Object

Resolves the type of an expression.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	TypeResolver.BindTypeEnv	A type environment that consists of a type environment plus one binding.
private static class	TypeResolver.EmptySubst	Empty substitution.
(package private) static enum	TypeResolver.EmptyTypeEnv	Empty type environment.
(package private) static class	TypeResolver.FieldExpander	Visitor that expands progressive types if they are used in field references.
private static class	TypeResolver.Foo	Workspace for converting types to keys.
private static class	TypeResolver.PlusSubst	Substitution that adds one (type, variable) assignment to a parent substitution.
static class	TypeResolver.Resolved	Result of validating a declaration.
private static class	TypeResolver.Subst	Substitution.
private static class	TypeResolver.TermVariable	Pair consisting of a term and a variable.
(package private) static interface	TypeResolver.TypeEnv	Type environment.
private class	TypeResolver.TypeEnvHolder	Contains a TypeResolver.TypeEnv and adds to it by calling TypeResolver.TypeEnv.bind(String, Function).
static class	TypeResolver.TypeException	Error while deducing type.

Field Summary

Fields

Modifier and Type	Field	Description
private final Map<Unifier.Variable,Unifier.Action>	actionMap
(package private) static final String	FN_TY_CON
(package private) static final String	LIST_TY_CON
private final Map<AstNode,Unifier.Term>	map
private final PairList<Unifier.Variable,PrimitiveType>	preferredTypes
(package private) static final String	PROGRESSIVE_LABEL	A field of this name indicates that a record type is progressive.
(package private) static final String	RECORD_TY_CON
private final List<TypeResolver.TermVariable>	terms
(package private) static final String	TUPLE_TY_CON
private final TypeSystem	typeSystem
private final Unifier	unifier

Constructor Summary

Constructors

Modifier	Constructor	Description
private	TypeResolver(TypeSystem typeSystem)

Method Summary

Modifier and Type	Method	Description
private static TypeResolver.TypeEnv	bindAll(TypeResolver.TypeEnv env, Map<Ast.IdPat,Unifier.Term> termMap)
private static void	checkNoUnresolvedFieldRefs(Ast.Decl decl, TypeMap typeMap)	Checks that there are no field references "x.y" or "#y x" where "x" has an unresolved type.
private void	deduceDatatypeBindType(Ast.DatatypeBind datatypeBind, SortedMap<String,Type.Key> tyCons)
private Ast.Decl	deduceDataTypeDeclType(TypeResolver.TypeEnv env, Ast.DatatypeDecl datatypeDecl, Map<Ast.IdPat,Unifier.Term> termMap)
private Ast.Decl	deduceDeclType(TypeResolver.TypeEnv env, Ast.Decl node, Map<Ast.IdPat,Unifier.Term> termMap)
private List<Ast.Match>	deduceMatchListType(TypeResolver.TypeEnv env, List<Ast.Match> matchList, NavigableSet<String> labelNames, Unifier.Variable argVariable, Unifier.Variable resultVariable)
private Ast.Match	deduceMatchType(TypeResolver.TypeEnv env, Ast.Match match, Map<Ast.IdPat,Unifier.Term> termMap, Unifier.Variable argVariable, Unifier.Variable resultVariable)
private Ast.Pat	deducePatType(TypeResolver.TypeEnv env, Ast.Pat pat, Map<Ast.IdPat,Unifier.Term> termMap, NavigableSet<String> labelNames, Unifier.Variable v)	Derives a type term for a pattern, collecting the names of pattern variables.
private Ast.RecordSelector	deduceRecordSelectorType(TypeResolver.TypeEnv env, Unifier.Variable vResult, Unifier.Variable vArg, Ast.RecordSelector recordSelector)
private Pair<TypeResolver.TypeEnv,Unifier.Variable>	deduceStepType(TypeResolver.TypeEnv env, Ast.FromStep step, Unifier.Variable v, TypeResolver.TypeEnv env2, Map<Ast.Id,Unifier.Variable> fieldVars, List<Ast.FromStep> fromSteps)
static TypeResolver.Resolved	deduceType(Environment env, Ast.Decl decl, TypeSystem typeSystem)	Deduces the datatype of a declaration.
private Ast.Exp	deduceType(TypeResolver.TypeEnv env, Ast.Exp node, Unifier.Variable v)
private TypeResolver.Resolved	deduceType_(Environment env, Ast.Decl decl)
private AstNode	deduceValBindType(TypeResolver.TypeEnv env, Ast.ValBind valBind, Map<Ast.IdPat,Unifier.Term> termMap, Unifier.Variable v, Unifier.Variable vPat)
private Ast.Decl	deduceValDeclType(TypeResolver.TypeEnv env, Ast.ValDecl valDecl, Map<Ast.IdPat,Unifier.Term> termMap)
private void	equiv(Unifier.Term term, Unifier.Term term2)
private void	equiv(Unifier.Term term, Unifier.Variable atom)
(package private) static List<String>	fieldList(Unifier.Sequence sequence)
private Unifier.Term	fieldRecord(Map<Ast.Id,Unifier.Variable> fieldVars)
private static void	forEachUnresolvedField(Ast.Decl decl, TypeMap typeMap, Consumer<Ast.Apply> consumer)
private static Ast.Exp	idTuple(List<String> vars)	Converts a list of variable names to a variable or tuple.
private Ast.Exp	infix(TypeResolver.TypeEnv env, Ast.InfixCall call, Unifier.Variable v)	Registers an infix operator.
private Ast.Exp	infix(TypeResolver.TypeEnv env, Ast.InfixCall call, Unifier.Variable v, Type type)	Registers an infix operator whose type is a given type.
private Ast.Pat	patTuple(TypeResolver.TypeEnv env, List<Ast.Pat> patList)	Converts a list of patterns to a singleton pattern or tuple pattern.
private Ast.Exp	prefix(TypeResolver.TypeEnv env, Ast.PrefixCall call, Unifier.Variable v)	Registers a prefix operator.
private Unifier.Term	record(NavigableMap<String,? extends Unifier.Term> labelTypes)
private <E extends AstNode> E	reg(E node, Unifier.Variable variable, Unifier.Term term)
private Unifier.Term	toTerm(PrimitiveType type)
private Unifier.Term	toTerm(Type type, TypeResolver.Subst subst)
private List<Unifier.Term>	toTerms(Iterable<? extends Type> types, TypeResolver.Subst subst)
static Type	toType(Ast.Type type, TypeSystem typeSystem)	Converts a type AST to a type.
static Type.Key	toTypeKey(Ast.Type type)	Converts a type AST to a type key.
private Ast.ValBind	toValBind(TypeResolver.TypeEnv env, Ast.FunBind funBind)
private Ast.ValDecl	toValDecl(TypeResolver.TypeEnv env, Ast.FunDecl funDecl)	Converts a function declaration to a value declaration.
private Unifier.Term	tuple(List<Unifier.Term> types)
private void	validateGroup(Ast.Group group)	Validates a Group.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

typeSystem

private final TypeSystem typeSystem

unifier

private final Unifier unifier

terms

private final List<TypeResolver.TermVariable> terms

map

private final Map<AstNode,Unifier.Term> map

actionMap

private final Map<Unifier.Variable,Unifier.Action> actionMap

preferredTypes

private final PairList<Unifier.Variable,PrimitiveType> preferredTypes

TUPLE_TY_CON

static final String TUPLE_TY_CON

See Also:

• Constant Field Values

LIST_TY_CON

static final String LIST_TY_CON

See Also:

• Constant Field Values

RECORD_TY_CON

static final String RECORD_TY_CON

See Also:

• Constant Field Values

FN_TY_CON

static final String FN_TY_CON

See Also:

• Constant Field Values

PROGRESSIVE_LABEL

static final String PROGRESSIVE_LABEL

A field of this name indicates that a record type is progressive.

See Also:

• Constant Field Values

Constructor Details

TypeResolver

private TypeResolver(TypeSystem typeSystem)

Method Details

deduceType

public static TypeResolver.Resolved deduceType(Environment env,
 Ast.Decl decl,
 TypeSystem typeSystem)

Deduces the datatype of a declaration.

toType

public static Type toType(Ast.Type type,
 TypeSystem typeSystem)

Converts a type AST to a type.

toTypeKey

public static Type.Key toTypeKey(Ast.Type type)

Converts a type AST to a type key.

deduceType_

private TypeResolver.Resolved deduceType_(Environment env,
 Ast.Decl decl)

checkNoUnresolvedFieldRefs

private static void checkNoUnresolvedFieldRefs(Ast.Decl decl,
 TypeMap typeMap)

Checks that there are no field references "x.y" or "#y x" where "x" has an unresolved type. Throws if there are unresolved field references.

forEachUnresolvedField

private static void forEachUnresolvedField(Ast.Decl decl,
 TypeMap typeMap,
 Consumer<Ast.Apply> consumer)

reg

private <E extends AstNode> E reg(E node,
 Unifier.Variable variable,
 Unifier.Term term)

deduceType

private Ast.Exp deduceType(TypeResolver.TypeEnv env,
 Ast.Exp node,
 Unifier.Variable v)

deduceStepType

private Pair<TypeResolver.TypeEnv,Unifier.Variable> deduceStepType(TypeResolver.TypeEnv env,
 Ast.FromStep step,
 Unifier.Variable v,
 TypeResolver.TypeEnv env2,
 Map<Ast.Id,Unifier.Variable> fieldVars,
 List<Ast.FromStep> fromSteps)

validateGroup

private void validateGroup(Ast.Group group)

Validates a Group. Throws if there are duplicate names among the keys and aggregates.

fieldRecord

private Unifier.Term fieldRecord(Map<Ast.Id,Unifier.Variable> fieldVars)

record

private Unifier.Term record(NavigableMap<String,? extends Unifier.Term> labelTypes)

tuple

private Unifier.Term tuple(List<Unifier.Term> types)

deduceRecordSelectorType

private Ast.RecordSelector deduceRecordSelectorType(TypeResolver.TypeEnv env,
 Unifier.Variable vResult,
 Unifier.Variable vArg,
 Ast.RecordSelector recordSelector)

fieldList

static List<String> fieldList(Unifier.Sequence sequence)

deduceMatchType

private Ast.Match deduceMatchType(TypeResolver.TypeEnv env,
 Ast.Match match,
 Map<Ast.IdPat,Unifier.Term> termMap,
 Unifier.Variable argVariable,
 Unifier.Variable resultVariable)

deduceMatchListType

private List<Ast.Match> deduceMatchListType(TypeResolver.TypeEnv env,
 List<Ast.Match> matchList,
 NavigableSet<String> labelNames,
 Unifier.Variable argVariable,
 Unifier.Variable resultVariable)

deduceValBindType

private AstNode deduceValBindType(TypeResolver.TypeEnv env,
 Ast.ValBind valBind,
 Map<Ast.IdPat,Unifier.Term> termMap,
 Unifier.Variable v,
 Unifier.Variable vPat)

bindAll

private static TypeResolver.TypeEnv bindAll(TypeResolver.TypeEnv env,
 Map<Ast.IdPat,Unifier.Term> termMap)

deduceDeclType

private Ast.Decl deduceDeclType(TypeResolver.TypeEnv env,
 Ast.Decl node,
 Map<Ast.IdPat,Unifier.Term> termMap)

deduceDataTypeDeclType

private Ast.Decl deduceDataTypeDeclType(TypeResolver.TypeEnv env,
 Ast.DatatypeDecl datatypeDecl,
 Map<Ast.IdPat,Unifier.Term> termMap)

deduceValDeclType

private Ast.Decl deduceValDeclType(TypeResolver.TypeEnv env,
 Ast.ValDecl valDecl,
 Map<Ast.IdPat,Unifier.Term> termMap)

deduceDatatypeBindType

private void deduceDatatypeBindType(Ast.DatatypeBind datatypeBind,
 SortedMap<String,Type.Key> tyCons)

toValDecl

private Ast.ValDecl toValDecl(TypeResolver.TypeEnv env,
 Ast.FunDecl funDecl)

Converts a function declaration to a value declaration. In other words, fun is syntactic sugar, and this is the de-sugaring machine.

For example, fun inc x = x + 1 becomes val rec inc = fn x => x + 1.

If there are multiple arguments, there is one fn for each argument: fun sum x y = x + y becomes val rec sum = fn x => fn y => x + y.

If there are multiple clauses, we generate case: fun gcd a 0 = a | gcd a b = gcd b (a mod b) becomes val rec gcd = fn x => fn y => case (x, y) of (a, 0) => a | (a, b) = gcd b (a mod b).

toValBind

private Ast.ValBind toValBind(TypeResolver.TypeEnv env,
 Ast.FunBind funBind)

idTuple

private static Ast.Exp idTuple(List<String> vars)

Converts a list of variable names to a variable or tuple.

For example, ["x"] becomes "x" (an Ast.Id), and ["x", "y"] becomes "(x, y)" (a Ast.Tuple of Ids).

patTuple

private Ast.Pat patTuple(TypeResolver.TypeEnv env,
 List<Ast.Pat> patList)

Converts a list of patterns to a singleton pattern or tuple pattern.

deducePatType

private Ast.Pat deducePatType(TypeResolver.TypeEnv env,
 Ast.Pat pat,
 Map<Ast.IdPat,Unifier.Term> termMap,
 NavigableSet<String> labelNames,
 Unifier.Variable v)

Derives a type term for a pattern, collecting the names of pattern variables.

Parameters:

env - Compile-time environment

pat - Pattern AST

termMap - Map from names to bound terms, populated by this method

labelNames - List of names of labels in this pattern and sibling patterns in a | match, or null if not a record pattern

v - Type variable that this method should equate the type term that it derives for this pattern

infix

private Ast.Exp infix(TypeResolver.TypeEnv env,
 Ast.InfixCall call,
 Unifier.Variable v,
 Type type)

Registers an infix operator whose type is a given type.

infix

private Ast.Exp infix(TypeResolver.TypeEnv env,
 Ast.InfixCall call,
 Unifier.Variable v)

Registers an infix operator.

prefix

private Ast.Exp prefix(TypeResolver.TypeEnv env,
 Ast.PrefixCall call,
 Unifier.Variable v)

Registers a prefix operator.

equiv

private void equiv(Unifier.Term term,
 Unifier.Variable atom)

equiv

private void equiv(Unifier.Term term,
 Unifier.Term term2)

toTerms

private List<Unifier.Term> toTerms(Iterable<? extends Type> types,
 TypeResolver.Subst subst)

toTerm

private Unifier.Term toTerm(PrimitiveType type)

toTerm

private Unifier.Term toTerm(Type type,
 TypeResolver.Subst subst)