wytp.types.util

Class AbstractTypeExtractor<T extends WyalFile.Type>

java.lang.Object

wytp.types.util.AbstractTypeExtractor<T>

Type Parameters:

T -

All Implemented Interfaces:

TypeExtractor<T,Object>

Direct Known Subclasses:

ReadableArrayExtractor, ReadableRecordExtractor, ReadableReferenceExtractor

public abstract class AbstractTypeExtractor<T extends WyalFile.Type>
extends Object
implements TypeExtractor<T,Object>

A generic foundation for "convential" type extractors. That is, those which extract type information from types (rather than, for example, information about type invariants, etc). The approach consists of two phases:

1. (Conversion). First we convert the given type into Disjunctive Normal Form (DNF). That is a type with a specific structure made up from one or more "conjuncts" which are disjuncted together. Each conjunct contains one or more signed atoms which are intersected. For example, "int&(null|bool)" is converted into "(int&null)|(int&bool)".
2. (Construction). Second, we attempt to construct the DNF type into an instance of the target type. This requires that all types in a given conjunct match the given target type (or are negations thereof). One exception, however, is when a given conjunct gives a contradiction (i.e. reduces to void). Such conjuncts can be safely ignored. For example, consider the type "!null & (null|{int f})". This expands to the conjuncts "!null & null" and "(!null)&{int f}". Since the former reduces to "void", we are left with "(!null)&{int f}" which generates the extraction "{int f}".

During construction the concrete subclass is called to try and construct an instance of the target type from a given atom. This gives the subclass the ability to determine what the target type is. Furthermore, the subclass must provide appropriate methods for combining instances of the target type though union , intersection and subtraction operators.

For further reading on the operation of this algorithm, the following is suggested:

• Sound and Complete Flow Typing with Unions, Intersections and Negations. David J. Pearce. In Proceedings of the Conference on Verification, Model Checking, and Abstract Interpretation (VMCAI), volume 7737 of Lecture Notes in Computer Science, pages 335--354, 2013.

Author:

David J. Pearce

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	AbstractTypeExtractor.Conjunct
protected static class	AbstractTypeExtractor.Disjunct
protected static class	AbstractTypeExtractor.Signed A signed type is simply a type which is either positive or negatively signed.

Field Summary

Fields

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

Constructor Summary

Constructors

Constructor and Description
AbstractTypeExtractor(wybs.lang.NameResolver resolver, TypeSystem typeSystem)

Method Summary

Modifier and Type	Method and Description
protected T	construct(AbstractTypeExtractor.Conjunct type)
protected T	construct(AbstractTypeExtractor.Disjunct type) Construct a given target type from a given type in DisjunctiveNormalForm.
protected abstract T	construct(WyalFile.Type.Atom type)
T	extract(WyalFile.Type type, Object supplementary) Attempt to extract a certain kind of type from an arbitrary type.
protected abstract T	intersect(T lhs, T rhs)
protected WyalFile.Type	intersectionHelper(WyalFile.Type lhs, WyalFile.Type rhs) Provides a simplistic form of type intersect which, in some cases, does slightly better than simply creating a new intersection.
protected boolean	isVoid(AbstractTypeExtractor.Conjunct type) Determine whether a given conjunct is equivalent to void or not.
protected abstract T	subtract(T lhs, T rhs)
protected AbstractTypeExtractor.Disjunct	toDisjunctiveNormalForm(WyalFile.Type.Array type)
protected AbstractTypeExtractor.Disjunct	toDisjunctiveNormalForm(WyalFile.Type.FunctionOrMethodOrProperty type)
protected AbstractTypeExtractor.Disjunct	toDisjunctiveNormalForm(WyalFile.Type.Intersection type)
protected AbstractTypeExtractor.Disjunct	toDisjunctiveNormalForm(WyalFile.Type.Negation type)
protected AbstractTypeExtractor.Disjunct	toDisjunctiveNormalForm(WyalFile.Type.Nominal nominal)
protected AbstractTypeExtractor.Disjunct	toDisjunctiveNormalForm(WyalFile.Type.Primitive type)
protected AbstractTypeExtractor.Disjunct	toDisjunctiveNormalForm(WyalFile.Type.Record type)
protected AbstractTypeExtractor.Disjunct	toDisjunctiveNormalForm(WyalFile.Type.Reference type)
protected AbstractTypeExtractor.Disjunct	toDisjunctiveNormalForm(WyalFile.Type.Union type)
protected AbstractTypeExtractor.Disjunct	toDisjunctiveNormalForm(WyalFile.Type type) Convert an arbitrary type to Disjunctive Normal Form (DNF).
protected abstract T	union(T lhs, T rhs)
protected WyalFile.Type	unionHelper(WyalFile.Type lhs, WyalFile.Type rhs) Provides a simplistic form of type union which, in some cases, does slightly better than simply creating a new union.

Methods inherited from class java.lang.Object

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

Field Detail

resolver

protected final wybs.lang.NameResolver resolver

typeSystem

protected final TypeSystem typeSystem

Constructor Detail

AbstractTypeExtractor

public AbstractTypeExtractor(wybs.lang.NameResolver resolver,
                             TypeSystem typeSystem)

Method Detail

extract

public T extract(WyalFile.Type type,
                 Object supplementary)
          throws wybs.lang.NameResolver.ResolutionError

Description copied from interface: TypeExtractor

Attempt to extract a certain kind of type from an arbitrary type. This is necessary in the presence of powerful type connectives such as union, intersection and negation. For example, given the type {int x}|{int x} we can extract the type {int x}.

Specified by:

extract in interface TypeExtractor<T extends WyalFile.Type,Object>

Parameters:

type - The type for which information is to be extracted

supplementary - Supplementary information which may be used by the extractor.

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError

toDisjunctiveNormalForm

protected AbstractTypeExtractor.Disjunct toDisjunctiveNormalForm(WyalFile.Type type)
                                                          throws wybs.lang.NameResolver.ResolutionError

Convert an arbitrary type to Disjunctive Normal Form (DNF). That is a type with a specific structure made up from one or more "conjuncts" which are unioned together. Each conjunct contains one or more signed atoms which are intersected. For example, int&(null|bool) is converted into (int&null)|(int&bool).

Parameters:

type -

atoms -

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError

toDisjunctiveNormalForm

protected AbstractTypeExtractor.Disjunct toDisjunctiveNormalForm(WyalFile.Type.Primitive type)
                                                          throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError

toDisjunctiveNormalForm

protected AbstractTypeExtractor.Disjunct toDisjunctiveNormalForm(WyalFile.Type.Record type)
                                                          throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError

toDisjunctiveNormalForm

protected AbstractTypeExtractor.Disjunct toDisjunctiveNormalForm(WyalFile.Type.Reference type)
                                                          throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError

toDisjunctiveNormalForm

protected AbstractTypeExtractor.Disjunct toDisjunctiveNormalForm(WyalFile.Type.Array type)
                                                          throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError

toDisjunctiveNormalForm

protected AbstractTypeExtractor.Disjunct toDisjunctiveNormalForm(WyalFile.Type.FunctionOrMethodOrProperty type)
                                                          throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError

toDisjunctiveNormalForm

protected AbstractTypeExtractor.Disjunct toDisjunctiveNormalForm(WyalFile.Type.Negation type)
                                                          throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError

toDisjunctiveNormalForm

protected AbstractTypeExtractor.Disjunct toDisjunctiveNormalForm(WyalFile.Type.Union type)
                                                          throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError

toDisjunctiveNormalForm

protected AbstractTypeExtractor.Disjunct toDisjunctiveNormalForm(WyalFile.Type.Intersection type)
                                                          throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError

toDisjunctiveNormalForm

protected AbstractTypeExtractor.Disjunct toDisjunctiveNormalForm(WyalFile.Type.Nominal nominal)
                                                          throws wybs.lang.NameResolver.ResolutionError

Throws:

wybs.lang.NameResolver.ResolutionError

construct

protected T construct(AbstractTypeExtractor.Disjunct type)
               throws wybs.lang.NameResolver.ResolutionError

Construct a given target type from a given type in DisjunctiveNormalForm.

Parameters:

type -

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError

isVoid

protected boolean isVoid(AbstractTypeExtractor.Conjunct type)
                  throws wybs.lang.NameResolver.ResolutionError

Determine whether a given conjunct is equivalent to void or not. For example, int & !int is equivalent to void. Likewise, {int f} & !{any f} is equivalent to void.

Parameters:

type -

Returns:

Throws:

wybs.lang.NameResolver.ResolutionError

construct

protected T construct(AbstractTypeExtractor.Conjunct type)

construct

protected abstract T construct(WyalFile.Type.Atom type)

union

protected abstract T union(T lhs,
                           T rhs)

intersect

protected abstract T intersect(T lhs,
                               T rhs)

subtract

protected abstract T subtract(T lhs,
                              T rhs)

unionHelper

protected WyalFile.Type unionHelper(WyalFile.Type lhs,
                                    WyalFile.Type rhs)

Provides a simplistic form of type union which, in some cases, does slightly better than simply creating a new union. For example, unioning int with int will return int rather than int|int.

Parameters:

lhs -

rhs -

Returns:

intersectionHelper

protected WyalFile.Type intersectionHelper(WyalFile.Type lhs,
                                           WyalFile.Type rhs)

Provides a simplistic form of type intersect which, in some cases, does slightly better than simply creating a new intersection. For example, intersecting int with int will return int rather than int&int.

Parameters:

lhs -

rhs -

Returns: