Package de.monticore.types3.util

Class SymTypeNormalizeVisitor

java.lang.Object

de.monticore.types3.util.SymTypeDeepCloneVisitor

de.monticore.types3.util.SymTypeNormalizeVisitor

All Implemented Interfaces:

ISymTypeVisitor

public class SymTypeNormalizeVisitor
extends SymTypeDeepCloneVisitor

tries to normalize SymTypeExpressions, including, but not limited to, unions and intersections e.g., (A|A|B) -> A, if A extends B Usage: calculate(symType)

normalization of regular expressions are not supported

note, this visitor does not box/unbox, boxing/unboxing should be done before this visitor if required

Field Summary

Fields inherited from class de.monticore.types3.util.SymTypeDeepCloneVisitor

transformedSymTypes

Constructor Summary

Constructors

Constructor	Description
SymTypeNormalizeVisitor()

Method Summary

Modifier and Type	Method	Description
protected void	errorIfEmpty(Collection<? extends SymTypeExpression> types)
protected SymTypeExpression	intersect(Collection<SymTypeExpression> uniqueTypes)	Intersects types and removes any redundant information (for normalized types without unions or intersections)
protected SymTypeExpression	intersectArrayTypes(Collection<SymTypeArray> arrays)
protected SymTypeExpression	intersectFunctionTypes(Collection<SymTypeOfFunction> functions)	calculates the intersection of function types.
protected Set<SymTypeOfIntersection>	intersectionOfUnions2UnionOfIntersections(Set<SymTypeExpression> intersectedTypes)	takes an intersection, which may contain unions and creates a union which contains intersections A&B&(C|D) -> (A&B&C)|(A&B&D) Note that this only calculates the given intersection, not the intersection contained within the given intersection.
protected SymTypeExpression	intersectObjectTypes(Collection<? extends SymTypeExpression> objects)	Objects, Generics
protected SymTypeExpression	intersectRegExTypes(Collection<SymTypeOfRegEx> regExs)
protected SymTypeExpression	intersectSimpleTypes(Collection<SymTypeExpression> simpleTypes)	primitives, SIUnits
protected SymTypeExpression	intersectTupleTypes(Collection<SymTypeOfTuple> tuples)
protected SymTypeExpression	normalizeIntersectionWithoutUnions(SymTypeOfIntersection intersection)	normalizes an intersection the contained expressions are expected to be normalized and not unions s.
protected SymTypeExpression	normalizeUnionWithNormalizedTypes(SymTypeOfUnion union)
protected Set<SymTypeExpression>	splitIntersections(Set<SymTypeExpression> types)	splits up intersections e.g., {(A&(B&C)),D} -> {A,B,C,D} used for normalization
protected List<SymTypeOfTuple>	splitTupleByIntersection(SymTypeOfTuple tuple)	Split tuples by intersections.
protected List<SymTypeOfTuple>	splitTupleByIntersection(SymTypeOfTuple tuple, int idx)
protected List<SymTypeOfTuple>	splitTupleByUnion(SymTypeOfTuple tuple)	Split tuples by unions.
protected List<SymTypeOfTuple>	splitTupleByUnion(SymTypeOfTuple tuple, int idx)
protected Set<SymTypeExpression>	splitUnions(Set<SymTypeExpression> types)	splits up unions e.g., {(A|(B|C)),D} -> {A,B,C,D} used for normalization
void	visit(SymTypeArray array)
void	visit(SymTypeOfFunction function)
void	visit(SymTypeOfIntersection intersection)
void	visit(SymTypeOfNumericWithSIUnit numericWithSIUnit)
void	visit(SymTypeOfSIUnit siUnit)
void	visit(SymTypeOfTuple tuple)
void	visit(SymTypeOfUnion union)

Methods inherited from class de.monticore.types3.util.SymTypeDeepCloneVisitor

applyToCollection, applyToCollection, calculate, getTransformedSymType, getTransformedSymTypes, popTransformedSubSymType, pushTransformedSymType, reset, visit, visit, visit, visit, visit, visit, visit, visit, visit, visit

Methods inherited from class java.lang.Object

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

Constructor Details

SymTypeNormalizeVisitor

public SymTypeNormalizeVisitor()

Method Details

visit

public void visit(SymTypeOfUnion union)

Specified by:

visit in interface ISymTypeVisitor

Overrides:

visit in class SymTypeDeepCloneVisitor

normalizeUnionWithNormalizedTypes

protected SymTypeExpression normalizeUnionWithNormalizedTypes(SymTypeOfUnion union)

visit

public void visit(SymTypeOfIntersection intersection)

Specified by:

visit in interface ISymTypeVisitor

Overrides:

visit in class SymTypeDeepCloneVisitor

normalizeIntersectionWithoutUnions

protected SymTypeExpression normalizeIntersectionWithoutUnions(SymTypeOfIntersection intersection)

normalizes an intersection the contained expressions are expected to be normalized and not unions s. visit(SymTypeOfIntersection)

intersect

protected SymTypeExpression intersect(Collection<SymTypeExpression> uniqueTypes)

Intersects types and removes any redundant information (for normalized types without unions or intersections)

intersectSimpleTypes

protected SymTypeExpression intersectSimpleTypes(Collection<SymTypeExpression> simpleTypes)

primitives, SIUnits

intersectTupleTypes

protected SymTypeExpression intersectTupleTypes(Collection<SymTypeOfTuple> tuples)

intersectFunctionTypes

protected SymTypeExpression intersectFunctionTypes(Collection<SymTypeOfFunction> functions)

calculates the intersection of function types.

IMPORTANT: This does filter out cases that can occur for overloaded functions, e.g., intersect(A -> B, (A, A) -> B) = bottom This is relevant if no type inference is used, and within type inference itself; With this version, resolved intersections MUST be split before normalization. An alternativ would be to allow the aforementioned kind of intersection, But that would lead to allowing values that are multiple function references at once. This is highly unintuitive and not supported by (most?) major languages.

TODO FDr: Figure out if for the non-type-inference version the intersection has to be calculated differently (to allow for overloads), or if another representation for overloads would be better suited (which in turn would probably be turned into an intersection for the non-inference version anyway).

intersectRegExTypes

protected SymTypeExpression intersectRegExTypes(Collection<SymTypeOfRegEx> regExs)

intersectArrayTypes

protected SymTypeExpression intersectArrayTypes(Collection<SymTypeArray> arrays)

intersectObjectTypes

protected SymTypeExpression intersectObjectTypes(Collection<? extends SymTypeExpression> objects)

Objects, Generics

visit

public void visit(SymTypeArray array)

Specified by:

visit in interface ISymTypeVisitor

Overrides:

visit in class SymTypeDeepCloneVisitor

visit

public void visit(SymTypeOfTuple tuple)

Specified by:

visit in interface ISymTypeVisitor

Overrides:

visit in class SymTypeDeepCloneVisitor

visit

public void visit(SymTypeOfFunction function)

Specified by:

visit in interface ISymTypeVisitor

Overrides:

visit in class SymTypeDeepCloneVisitor

visit

public void visit(SymTypeOfNumericWithSIUnit numericWithSIUnit)

Specified by:

visit in interface ISymTypeVisitor

Overrides:

visit in class SymTypeDeepCloneVisitor

visit

public void visit(SymTypeOfSIUnit siUnit)

Specified by:

visit in interface ISymTypeVisitor

Overrides:

visit in class SymTypeDeepCloneVisitor

splitUnions

protected Set<SymTypeExpression> splitUnions(Set<SymTypeExpression> types)

splits up unions e.g., {(A|(B|C)),D} -> {A,B,C,D} used for normalization

splitIntersections

protected Set<SymTypeExpression> splitIntersections(Set<SymTypeExpression> types)

splits up intersections e.g., {(A&(B&C)),D} -> {A,B,C,D} used for normalization

intersectionOfUnions2UnionOfIntersections

protected Set<SymTypeOfIntersection> intersectionOfUnions2UnionOfIntersections(Set<SymTypeExpression> intersectedTypes)

takes an intersection, which may contain unions and creates a union which contains intersections A&B&(C|D) -> (A&B&C)|(A&B&D) Note that this only calculates the given intersection, not the intersection contained within the given intersection. An additional characteristic to mention is that NO empty intersections / unions are created if there have been none to begin with

splitTupleByUnion

protected List<SymTypeOfTuple> splitTupleByUnion(SymTypeOfTuple tuple)

Split tuples by unions. (A|B,C&D) -> (A,C&D), (B, C&D) does not create deep copies.

splitTupleByUnion

protected List<SymTypeOfTuple> splitTupleByUnion(SymTypeOfTuple tuple,
 int idx)

splitTupleByIntersection

protected List<SymTypeOfTuple> splitTupleByIntersection(SymTypeOfTuple tuple)

Split tuples by intersections. (A|B,C&D) -> (A|B,C), (A|B, D) does not create deep copies.

splitTupleByIntersection

protected List<SymTypeOfTuple> splitTupleByIntersection(SymTypeOfTuple tuple,
 int idx)

errorIfEmpty

protected void errorIfEmpty(Collection<? extends SymTypeExpression> types)