wytp.types.subtyping

Class CoerciveSubtypeOperator

java.lang.Object

wytp.types.subtyping.CoerciveSubtypeOperator

All Implemented Interfaces:

SubtypeOperator

public class CoerciveSubtypeOperator
extends Object
implements SubtypeOperator

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	CoerciveSubtypeOperator.Atom<T extends WyalFile.Type.Atom>
protected static class	CoerciveSubtypeOperator.Term<T extends WyalFile.Type>

Nested classes/interfaces inherited from interface wytp.types.SubtypeOperator

SubtypeOperator.Result

Field Summary

Fields

Modifier and Type	Field and Description
protected wybs.lang.NameResolver	resolver

Constructor Summary

Constructors

Constructor and Description
CoerciveSubtypeOperator(wybs.lang.NameResolver resolver)

Method Summary

Modifier and Type	Method and Description
protected wybs.util.AbstractCompilationUnit.Name[]	append(wybs.util.AbstractCompilationUnit.Name[] lhs, wybs.util.AbstractCompilationUnit.Name rhs)
SubtypeOperator.Result	isSubtype(WyalFile.Type parent, WyalFile.Type child) Determine whether the rhs type is a subtype of the lhs (denoted lhs :> rhs).
protected boolean	isVoid(ArrayList<CoerciveSubtypeOperator.Atom<?>> truths, wytp.types.subtyping.CoerciveSubtypeOperator.Worklist worklist, wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions) Determine whether or not the intersection of a given list of types (the worklist) reduces to void or not.
protected boolean	isVoidArray(CoerciveSubtypeOperator.Atom<WyalFile.Type.Array> lhs, CoerciveSubtypeOperator.Atom<WyalFile.Type.Array> rhs, wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions) Determine whether the intersection of two array types is void or not.
protected boolean	isVoidAtom(CoerciveSubtypeOperator.Atom<?> a, CoerciveSubtypeOperator.Atom<?> b, wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions) Determine whether the intersection of two arbitrary atoms results in void or not.
boolean	isVoidFunction(CoerciveSubtypeOperator.Atom<WyalFile.Type.Function> lhs, CoerciveSubtypeOperator.Atom<WyalFile.Type.Function> rhs, wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions) Determine whether the intersection of two function types is void or not.
boolean	isVoidParameters(boolean lhsSign, boolean lhsMax, wybs.util.AbstractCompilationUnit.Tuple<WyalFile.Type> lhs, boolean rhsSign, boolean rhsMax, wybs.util.AbstractCompilationUnit.Tuple<WyalFile.Type> rhs, wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions)
protected boolean	isVoidRecord(CoerciveSubtypeOperator.Atom<WyalFile.Type.Record> lhs, CoerciveSubtypeOperator.Atom<WyalFile.Type.Record> rhs, wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions) Determine whether the intersection of two record types is void or not.
protected boolean	isVoidReference(CoerciveSubtypeOperator.Atom<WyalFile.Type.Reference> lhs, CoerciveSubtypeOperator.Atom<WyalFile.Type.Reference> rhs, wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions) Determine whether the intersection of two reference types is void or not.
protected boolean	isVoidTerm(CoerciveSubtypeOperator.Term<?> lhs, CoerciveSubtypeOperator.Term<?> rhs, wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions)

Methods inherited from class java.lang.Object

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

Field Detail

resolver

protected wybs.lang.NameResolver resolver

Constructor Detail

CoerciveSubtypeOperator

public CoerciveSubtypeOperator(wybs.lang.NameResolver resolver)

Method Detail

isSubtype

public SubtypeOperator.Result isSubtype(WyalFile.Type parent,
                                        WyalFile.Type child)
                                 throws wybs.lang.NameResolver.ResolutionError

Description copied from interface: SubtypeOperator

Determine whether the rhs type is a subtype of the lhs (denoted lhs :> rhs). In the presence of type invariants, this operation is undecidable. Therefore, a three-valued logic is employed. Either it was concluded that the subtype relation definitely holds, or that it definitely does not hold that it is unknown whether it holds or not.

For example, int|null :> int definitely holds. Likewise, int :> int|null definitely does not hold. However, whether or not nat :> pos holds depends on the type invariants given for nat and pos which this operator cannot reason about. Observe that, in some cases, we do get effective reasoning about types with invariants. For example, null|nat :> nat will be determined to definitely hold, despite the fact that nat has a type invariant.

Depending on the exact language of types involved, this can be a surprisingly complex operation. For example, in the presence of union, intersection and negation types, the subtype algorithm is surprisingly intricate.

Specified by:

isSubtype in interface SubtypeOperator

Parameters:

parent - The candidate "supertype". That is, lhs's raw type may be a supertype of rhs's raw type.

child - The candidate "subtype". That is, rhs's raw type may be a subtype of lhs's raw type.

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError - Occurs when a nominal type is encountered whose name cannot be resolved properly. For example, it resolves to more than one possible matching declaration, or it cannot be resolved to a corresponding type declaration.

isVoidTerm

protected boolean isVoidTerm(CoerciveSubtypeOperator.Term<?> lhs,
                             CoerciveSubtypeOperator.Term<?> rhs,
                             wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions)
                      throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError

isVoid

protected boolean isVoid(ArrayList<CoerciveSubtypeOperator.Atom<?>> truths,
                         wytp.types.subtyping.CoerciveSubtypeOperator.Worklist worklist,
                         wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions)
                  throws wybs.lang.NameResolver.ResolutionError

Determine whether or not the intersection of a given list of types (the worklist) reduces to void or not. This is performed in the context of a number of ground "atoms" which are known to hold. In essence, this algorithm exhaustively expands all items on the worklist to form atoms. The expanded atoms are then checked for consistency. is type is equivalent to void. This is a relatively complex operation which builds up a list of clauses known to hold.

Parameters:

truths - The set of truths which have been established.

worklist - The set of types currently being expanded

assumptions - The set of assumed subtype relationships

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError

append

protected wybs.util.AbstractCompilationUnit.Name[] append(wybs.util.AbstractCompilationUnit.Name[] lhs,
                                                          wybs.util.AbstractCompilationUnit.Name rhs)

isVoidAtom

protected boolean isVoidAtom(CoerciveSubtypeOperator.Atom<?> a,
                             CoerciveSubtypeOperator.Atom<?> b,
                             wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions)
                      throws wybs.lang.NameResolver.ResolutionError

Determine whether the intersection of two arbitrary atoms results in void or not. Each atom is either a "positive" or "negative" term. The latter corresponds to negated terms, such as !int or !{int f}.

Parameters:

a -

b -

assumptions - The set of assumed subtype relationships

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError

isVoidArray

protected boolean isVoidArray(CoerciveSubtypeOperator.Atom<WyalFile.Type.Array> lhs,
                              CoerciveSubtypeOperator.Atom<WyalFile.Type.Array> rhs,
                              wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions)
                       throws wybs.lang.NameResolver.ResolutionError

Determine whether the intersection of two array types is void or not. For example, int[] intersecting with bool[] gives void. In contrast, intersecting (int|null)[] with int[] does not give void. Likewise, int[] intersecting with !(int[]) gives void, whilst intersecting int[] with !(bool[]) does not give void.

Parameters:

lhsSign - The sign of the first type being intersected. If true, we have a positive atom. Otherwise, we have a negative atom.

lhs. - The first type being intersected, referred to as the "left-hand side".

rhsSign - The sign of the second type being intersected. If true, we have a positive atom. Otherwise, we have a negative atom.

rhs - The second type being intersected, referred to as the "right-hand side".

assumptions - The set of assumed subtype relationships

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError

isVoidRecord

protected boolean isVoidRecord(CoerciveSubtypeOperator.Atom<WyalFile.Type.Record> lhs,
                               CoerciveSubtypeOperator.Atom<WyalFile.Type.Record> rhs,
                               wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions)
                        throws wybs.lang.NameResolver.ResolutionError

Determine whether the intersection of two record types is void or not. For example, {int f} intersecting with {int g} gives void. In contrast, intersecting {int|null f} with {int f} does not give void. Likewise, {int f} intersecting with !{int f} gives void, whilst intersecting {int f} with !{int g} does not give void.

Parameters:

lhsSign - The sign of the first type being intersected. If true, we have a positive atom. Otherwise, we have a negative atom.

lhs. - The first type being intersected, referred to as the "left-hand side".

rhsSign - The sign of the second type being intersected. If true, we have a positive atom. Otherwise, we have a negative atom.

rhs - The second type being intersected, referred to as the "right-hand side".

assumptions - The set of assumed subtype relationships

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError

isVoidReference

protected boolean isVoidReference(CoerciveSubtypeOperator.Atom<WyalFile.Type.Reference> lhs,
                                  CoerciveSubtypeOperator.Atom<WyalFile.Type.Reference> rhs,
                                  wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions)
                           throws wybs.lang.NameResolver.ResolutionError

Determine whether the intersection of two reference types is void or not. Reference types are "invariant", meaning that element types must match exactly for an intersection to arise. For example, &int intersecting with &bool gives void. In contrast, intersecting &int with &int does not give void. Hoever, &int intersecting with &(int|bool) gives void.

Parameters:

lhsSign - The sign of the first type being intersected. If true, we have a positive atom. Otherwise, we have a negative atom.

lhs. - The first type being intersected, referred to as the "left-hand side".

rhsSign - The sign of the second type being intersected. If true, we have a positive atom. Otherwise, we have a negative atom.

rhs - The second type being intersected, referred to as the "right-hand side".

assumptions - The set of assumed subtype relationships

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError

isVoidFunction

public boolean isVoidFunction(CoerciveSubtypeOperator.Atom<WyalFile.Type.Function> lhs,
                              CoerciveSubtypeOperator.Atom<WyalFile.Type.Function> rhs,
                              wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions)
                       throws wybs.lang.NameResolver.ResolutionError

Determine whether the intersection of two function types is void or not. For example, function(int)->(int) intersecting with function(bool)->(int) gives void. In contrast, intersecting function(int|null)->(int) with function(int)->(int) does not give void. Likewise, function(int)->(int) intersecting with !function(int)->(int) gives void, whilst intersecting function(int)->(int) with !function(bool)->(int) does not give void.

Parameters:

lhsSign - The sign of the first type being intersected. If true, we have a positive atom. Otherwise, we have a negative atom.

lhs. - The first type being intersected, referred to as the "left-hand side".

rhsSign - The sign of the second type being intersected. If true, we have a positive atom. Otherwise, we have a negative atom.

rhs - The second type being intersected, referred to as the "right-hand side".

assumptions - The set of assumed subtype relationships private boolean

Throws:

wybs.lang.NameResolver.ResolutionError

isVoidParameters

public boolean isVoidParameters(boolean lhsSign,
                                boolean lhsMax,
                                wybs.util.AbstractCompilationUnit.Tuple<WyalFile.Type> lhs,
                                boolean rhsSign,
                                boolean rhsMax,
                                wybs.util.AbstractCompilationUnit.Tuple<WyalFile.Type> rhs,
                                wytp.types.subtyping.CoerciveSubtypeOperator.Assumptions assumptions)
                         throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError