## Uses of Class
de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions

Packages that use TypeAssumptions
de.dhbwstuttgart.core
de.dhbwstuttgart.syntaxtree
de.dhbwstuttgart.syntaxtree.misc
de.dhbwstuttgart.syntaxtree.operator
de.dhbwstuttgart.syntaxtree.statement
de.dhbwstuttgart.syntaxtree.type
de.dhbwstuttgart.typeinference
de.dhbwstuttgart.typeinference.assumptions
de.dhbwstuttgart.typeinference.unify

### Uses of TypeAssumptions in de.dhbwstuttgart.core

Methods in de.dhbwstuttgart.core that return TypeAssumptions
`private TypeAssumptions` MyCompiler.`makeFunNAssumptions()` Erstellt die FunN-Assumptions Fun0-FunN (momentan fÃ¼r N = 6)

### Uses of TypeAssumptions in de.dhbwstuttgart.syntaxtree

Fields in de.dhbwstuttgart.syntaxtree declared as TypeAssumptions
`private TypeAssumptions` Class.`typeAssumptions`

Methods in de.dhbwstuttgart.syntaxtree that return TypeAssumptions
`TypeAssumptions` Constructor.`createTypeAssumptions(Class classmember)`
`TypeAssumptions` Constant.`createTypeAssumptions(Class classmember)`
`TypeAssumptions` FieldDeclaration.`createTypeAssumptions(Class classmember)`
`TypeAssumptions` Method.`createTypeAssumptions(Class classmember)` Liefert die MethodAssumption zu dieser Methode
`abstract TypeAssumptions` Field.`createTypeAssumptions(Class classmember)` Diese Methode generiert die Assumptions fÃ¼r dieses Feld der Klasse classmember
`private TypeAssumptions` Class.`getPrivateFieldAssumptions()` Ermittelt alle privaten Felder und Methoden der Klasse und Erstellt eine Assumption fÃ¼r diese.
`TypeAssumptions` Class.`getPublicFieldAssumptions()` Ermittelt die Sichtbaren Felder und Methoden der Klasse.
`TypeAssumptions` SourceFile.`getPublicFieldAssumptions()`
`private TypeAssumptions` SourceFile.`makeBasicAssumptions()` Erzeugt die Anfangsinformationen Ã¯Â¿Â½ber bereits bekannte Klassen.
`private TypeAssumptions` SourceFile.`makeBasicAssumptionsFromJRE(Menge<UsedId> imports, boolean withSubtypes)` Erstellt die Assumptions der standardmÃ¤Ãig importierten Packages (java.lang.) sowie der von imports Ã¼bergebenen Klassen zusammen.

Methods in de.dhbwstuttgart.syntaxtree with parameters of type TypeAssumptions
`private Pair` SourceFile.`createPairFromClassAndSuperclass(Class baseClass, Type superclass, Menge classParaOrg, Menge superclassParaOrg, TypeAssumptions ass)` Erstellt ein Typ-Paar, welches im 1.
`private Class` SourceFile.`getSuperClassOfJREClass(java.lang.Class<?> x, TypeAssumptions ass)`
`FC_TTO` SourceFile.`makeFC(TypeAssumptions ass)` Erstellt die Finite Closure
`ConstraintsSet` Constructor.`TYPE(TypeAssumptions ass)`
`ConstraintsSet` FieldDeclaration.`TYPE(TypeAssumptions publicAssumptions)`
`ConstraintsSet` Method.`TYPE(TypeAssumptions ass)`
`abstract ConstraintsSet` Field.`TYPE(TypeAssumptions publicAssumptions)`
`ConstraintsSet` Class.`typeReconstruction(FC_TTO supportData, TypeAssumptions globalAssumptions)` Ausgangspunkt fÃ¯Â¿Â½r den Typrekonstruktionsalgorithmus.
`Menge<TypeinferenceResultSet>` SourceFile.`typeReconstruction(TypeAssumptions globalAssumptions)` Tyrekonstruktionsalgorithmus: ruft fÃ¯Â¿Â½r jede Klasse den Algorithmus TRProg auf.

### Uses of TypeAssumptions in de.dhbwstuttgart.syntaxtree.misc

Methods in de.dhbwstuttgart.syntaxtree.misc with parameters of type TypeAssumptions
`ConstraintsSet` ConstructorCall.`overloading(TypeAssumptions assumptions)`

### Uses of TypeAssumptions in de.dhbwstuttgart.syntaxtree.operator

Methods in de.dhbwstuttgart.syntaxtree.operator with parameters of type TypeAssumptions
`java.util.HashMap<ConstraintType,ConstraintType>` AddOp.`getReturnTypes(TypeAssumptions ass)`
`java.util.HashMap<ConstraintType,ConstraintType>` LogOp.`getReturnTypes(TypeAssumptions ass)`
`java.util.HashMap<ConstraintType,ConstraintType>` RelOp.`getReturnTypes(TypeAssumptions ass)`
`abstract java.util.HashMap<ConstraintType,ConstraintType>` Operator.`getReturnTypes(TypeAssumptions ass)` Liefert eine HashMap der Form: HashMap<ResultType, InputType>
`java.util.HashMap<ConstraintType,ConstraintType>` MulOp.`getReturnTypes(TypeAssumptions ass)`

### Uses of TypeAssumptions in de.dhbwstuttgart.syntaxtree.statement

Methods in de.dhbwstuttgart.syntaxtree.statement with parameters of type TypeAssumptions
`UndConstraint` MethodCall.`constraintsFromMethodAssumption(MethodAssumption methodAssumption, TypeAssumptions assumptions)` Spezifikation: overloading determines for all possible overloadings and overridings of a method the constraints, where constraints itself forms the constraints from the receiver type, the argument types, the return type and a given type assumption for the method.
`ConstraintsSet` MethodCall.`overloading(TypeAssumptions assumptions)` Erstellt die Constraints fÃ¼r den eigentlichen Methodenaufruf.
`ConstraintsSet` NegativeExpr.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` Assign.`TYPEExpr(TypeAssumptions assumptions)`
`abstract ConstraintsSet` Expr.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` IntLiteral.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` PositivExpr.`TYPEExpr(TypeAssumptions assumptions)`

`ConstraintsSet`

LambdaExpression.`TYPEExpr(TypeAssumptions assumptions)`
Spezifikation: TYPEExpr( Ass, Lambda( (x1 , . . . , xN ), expr|stmt ) ) = let AssArgs = { xi : ai | ai fresh type variables } (exprt : rty, ConS) = TYPEExpr( Ass Ã¢ÂÂª AssArgs, expr ) | (stmtt : rty, ConS) = TYPEStmt( Ass u AssArgs, stmt ) in (Lambda( (x1 : a1 , . . . , xN : aN ), exprt : rty|stmtt : rty ) : a, ConS Ã¢ÂÂª { (FunN<rty, a1 , . . . , aN > a) }), where a is a fresh type variable

`ConstraintsSet` LocalOrFieldVar.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` DoubleLiteral.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` StringLiteral.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` CastExpr.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` This.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` MethodCall.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` Binary.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` InstVar.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` UnaryExpr.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` NewArray.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` NewClass.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` Null.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` BoolLiteral.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` CharLiteral.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` SuperCall.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` InstanceOf.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` ThisCall.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` LongLiteral.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` FloatLiteral.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` NotExpr.`TYPEExpr(TypeAssumptions assumptions)`
`ConstraintsSet` Assign.`TYPEStmt(TypeAssumptions assumptions)` Spezifikation: TYPEStmt( Ass, stmt ) = let (stmt : rty, ConS) = TYPEExpr( Ass, stmt ) in (stmt : Void, ConS)
`ConstraintsSet` Expr.`TYPEStmt(TypeAssumptions assumptions)`
`ConstraintsSet` LambdaExpression.`TYPEStmt(TypeAssumptions ass)`
`abstract ConstraintsSet` Statement.`TYPEStmt(TypeAssumptions assumptions)`
`ConstraintsSet` Return.`TYPEStmt(TypeAssumptions assumptions)`
`ConstraintsSet` This.`TYPEStmt(TypeAssumptions assumptions)`
`ConstraintsSet` MethodCall.`TYPEStmt(TypeAssumptions assumptions)` Spezifikation: TYPEStmt( Ass, stmt ) = let (stmt : rty, ConS) = TYPEExpr( Ass, stmt ) in (stmt : Void, ConS)
`ConstraintsSet` UnaryExpr.`TYPEStmt(TypeAssumptions assumptions)`
`ConstraintsSet` Block.`TYPEStmt(TypeAssumptions assumptions)`
`ConstraintsSet` ForStmt.`TYPEStmt(TypeAssumptions assumptions)`
`ConstraintsSet` NewClass.`TYPEStmt(TypeAssumptions assumptions)` Spezifikation: TYPEStmt( Ass, stmt ) = let (stmt : rty, ConS) = TYPEExpr( Ass, stmt ) in (stmt : Void, ConS)
`ConstraintsSet` SuperCall.`TYPEStmt(TypeAssumptions assumptions)` This kann auch als Konstruktoraufruf in einem Konstruktor-Block vorkommen.
`ConstraintsSet` IfStmt.`TYPEStmt(TypeAssumptions assumptions)`
`ConstraintsSet` WhileStmt.`TYPEStmt(TypeAssumptions assumptions)`
`ConstraintsSet` ThisCall.`TYPEStmt(TypeAssumptions assumptions)` This kann auch als Konstruktoraufruf in einem Konstruktor-Block vorkommen.
`ConstraintsSet` EmptyStmt.`TYPEStmt(TypeAssumptions assumptions)`
`ConstraintsSet` LocalVarDecl.`TYPEStmt(TypeAssumptions assumptions)`

### Uses of TypeAssumptions in de.dhbwstuttgart.syntaxtree.type

Methods in de.dhbwstuttgart.syntaxtree.type that return TypeAssumptions
`TypeAssumptions` GenericTypeVar.`createAssumptions()`

Methods in de.dhbwstuttgart.syntaxtree.type with parameters of type TypeAssumptions
`Type` Void.`checkTYPE(TypeAssumptions ass, SyntaxTreeNode method)`
`Type` Type.`checkTYPE(TypeAssumptions ass, SyntaxTreeNode method)`
`Type` RefType.`checkTYPE(TypeAssumptions ass, SyntaxTreeNode method)`
`ConstraintsSet` GenericTypeVar.`TYPE(TypeAssumptions ass)` Die Type Methode auf generische Variablen angewandt sorgt fÃ¼r deren Eintragung in die TypeAssumptions.
`ConstraintsSet` BoundedGenericTypeVar.`TYPE(TypeAssumptions ass)`
`ConstraintType` WildcardType.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` GenericTypeVar.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` ExtendsWildcardType.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` Void.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` TypePlaceholder.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` SuperWildcardType.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` Type.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)` PrÃ¼ft ob der Typ in den Assumptions ass vorhanden ist.
`ConstraintType` BaseType.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` RefType.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`

### Uses of TypeAssumptions in de.dhbwstuttgart.typeinference

Methods in de.dhbwstuttgart.typeinference that return TypeAssumptions
`TypeAssumptions` FunNInterface.`getPublicFieldAssumptions()`

### Uses of TypeAssumptions in de.dhbwstuttgart.typeinference.assumptions

Methods in de.dhbwstuttgart.typeinference.assumptions that return TypeAssumptions
`TypeAssumptions` TypeAssumptions.`add(TypeAssumptions assumptions)`
`TypeAssumptions` TypeAssumptions.`clone()`

Methods in de.dhbwstuttgart.typeinference.assumptions with parameters of type TypeAssumptions
`TypeAssumptions` TypeAssumptions.`add(TypeAssumptions assumptions)`

### Uses of TypeAssumptions in de.dhbwstuttgart.typeinference.unify

Methods in de.dhbwstuttgart.typeinference.unify with parameters of type TypeAssumptions
`void` FC_TTO.`generateFullyNamedTypes(TypeAssumptions ass)`