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

- Packages that use TypeAssumptions
  Package | Description
  --- | ---
  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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Field and Description
    --- | ---
    `private TypeAssumptions` | Class.`typeAssumptions`

    Methods in de.dhbwstuttgart.syntaxtree that return TypeAssumptions
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `ConstraintsSet` | ConstructorCall.`overloading(TypeAssumptions assumptions)`

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

    Methods in de.dhbwstuttgart.syntaxtree.operator with parameters of type TypeAssumptions
    Modifier and Type | Method and Description
    --- | ---
    `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
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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 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
    Modifier and Type | Method and Description
    --- | ---
    `TypeAssumptions` | GenericTypeVar.`createAssumptions()`

    Methods in de.dhbwstuttgart.syntaxtree.type with parameters of type TypeAssumptions
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `TypeAssumptions` | FunNInterface.`getPublicFieldAssumptions()`

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

    Methods in de.dhbwstuttgart.typeinference.assumptions that return TypeAssumptions
    Modifier and Type | Method and Description
    --- | ---
    `TypeAssumptions` | TypeAssumptions.`add(TypeAssumptions assumptions)`
    `TypeAssumptions` | TypeAssumptions.`clone()`

    Methods in de.dhbwstuttgart.typeinference.assumptions with parameters of type TypeAssumptions
    Modifier and Type | Method and Description
    --- | ---
    `TypeAssumptions` | TypeAssumptions.`add(TypeAssumptions assumptions)`

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

    Methods in de.dhbwstuttgart.typeinference.unify with parameters of type TypeAssumptions
    Modifier and Type | Method and Description
    --- | ---
    `void` | FC_TTO.`generateFullyNamedTypes(TypeAssumptions ass)`