Comments

.gitignore

@@ -0,0 +1,19 @@
+## Core latex/pdflatex auxiliary files:
+*.aux
+*.lof
+*.log
+*.lot
+*.fls
+*.out
+*.toc
+*.fmt
+*.fot
+*.cb
+*.cb2
+.*.lb
+*.bbl
+*.bcf
+*.blg
+*-blx.aux
+*-blx.bib
+*.run.xml

constraints.tex

@@ -9,23 +9,32 @@
 
 %\subsection{Well-Formedness}
 
-Constraint generation step is the same as in \cite{TIforFGJ} except for field access and method invocation.
-Here \fjtype{} generates capture constraints instead of normal subtype constraints.
 
-Subtype constraints are created according to the type rules defined in section \ref{sec:tifj}.
-The \typeExpr{} function creates constraints for a given expression.
+% But it can be easily adapted to Featherweight Java or Java.
+% We add T <. a for every return of an expression anyway. If anything returns a Generic like X it is not directly used in a method call like X <c T
 
-$\begin{array}{c}
-\typeExpr(\texttt{t}_1, \ntv{b}) = C_l \quad \quad \typeExpr(\texttt{t}_2, \ntv{c}) = C_l \quad \quad \ntv{b}, \ntv{c} \ \text{fresh}
-\\
-\hline
-\typeExpr(\texttt{t}_1 \texttt{?:} \texttt{t}_2, \tv{a}) = C_l \cup C_r \cup \set{\ntv{b} \lessdot \tv{a}, \ntv{c} \lessdot \tv{a}}
-\end{array}
-$
+The constraint generation works on the \TamedFJ{} language.
+This step is mostly same as in \cite{TIforFGJ} except for field access and method invocation.
+We will focus on those parts.
+Here the new capture constraints and wildcard type placeholders are introduced.
+
+Generally subtype constraints for an expression mirror the subtype relations in the premise of the respective type rule introduced in section \ref{sec:tifj}
+Unknown types at the time of the constraint generation step are replaced with type placeholders.
+\begin{verbatim}
+m(l, v){
+  let x = x in x.add(v)
+}
+\end{verbatim}
 
 The constraint generation step cannot determine if a capture conversion is needed for a field access or a method call.
 Those statements produce $\lessdotCC$ constraints which signal the \unify{} algorithm that they qualify for a capture conversion.
 
+
+The parameter types given to a generic method also affect their return type.
+During constraint generation the algorithm does not know the parameter types yet.
+We generate $\lessdotCC$ constraints and let \unify{} do the capture conversion.
+$\lessdotCC$ constraints are kept until they reach the form $\type{G} \lessdotCC \type{G}$ and a capture conversion is possible.
+
 At points where a well-formed type is needed we use a normal type placeholder.
 Inside a method call expression sub expressions (receiver, parameter) wildcard placeholders are used.
 Here captured variables can flow freely.
@@ -62,14 +71,12 @@ For the example above a correct solution would be $\sigma(\tv{a}) = \wctype{\rwi
   \begin{align*}
     % Type
     \type{T}, \type{U} &::= \tv{a} \mid \wtv{a} \mid \mv{X} \mid {\wcNtype{\Delta}{N}} && \text{types and type placeholders}\\
-    \type{N} &::= \exptype{C}{\il{T}} && \text{class type (with type variables)} \\
+    \type{N} &::= \exptype{C}{\ol{T}} && \text{class type (with type variables)} \\
     % Constraints
-    \simpleCons &::= \type{T} \lessdot \type{U} && \text{subtype constraint}\\
-    \orCons{} &::= \set{\set{\overline{\simpleCons_1}}, \ldots, \set{\overline{\simpleCons_n}}} && \text{or-constraint}\\
-    \constraint &::= \simpleCons \mid \orCons && \text{constraint}\\
+    \constraint &::= \type{T} \lessdot \type{U} \mid \type{T} \lessdotCC \type{U} && \text{Constraint}\\
     \consSet &::= \set{\constraints} && \text{constraint set}\\
     % Method assumptions:
-    \methodAssumption &::= \exptype{C}{\ol{X} \triangleleft \ol{N}}.\texttt{m} : \exptype{}{\ol{Y}
+    \methodAssumption &::= \texttt{m} : \exptype{}{\ol{Y}
                         \triangleleft \ol{P}}\ \ol{\type{T}} \to \type{T}  &&
                                                                 \text{method
                                                                 type assumption}\\
@@ -79,28 +86,24 @@ For the example above a correct solution would be $\sigma(\tv{a}) = \wctype{\rwi
                 & \text{method type environment} \\
     \typeAssumptionsSymbol &::= ({\mtypeEnvironment} ; \overline{\localVarAssumption}) 
   \end{align*}
-  \caption{Syntax of constraints and type assumptions.}
+  \caption{Syntax of constraints and type assumptions}
   \label{fig:syntax-constraints}
 \end{figure}
 
 \begin{figure}[tp]
   \begin{gather*}
     \begin{array}{@{}l@{}l}
-      \fjtype & ({\mtypeEnvironment}, \mathtt{class } \ \exptype{C}{\ol{X} \triangleleft \ol{N}} \ \mathtt{ extends } \ \mathtt{N \{ \overline{T} \ \overline{f}; \, K \, \overline{M} \}}) =\\
+      \fjtype & ({\mtypeEnvironment}, \mathtt{class } \ \exptype{C}{\ol{X} \triangleleft \ol{N}} \ \mathtt{ extends } \ \mathtt{N \{ \overline{T} \ \overline{f}; \, \overline{M} \}}) =\\
               & \begin{array}{ll@{}l}
-\textbf{let} & \forall \texttt{m} \in \ol{M}: \tv{a}_\texttt{m}, \ol{\tv{a}_m} \ \text{fresh} \\
-             & \ol{\methodAssumption} = \begin{array}[t]{l}
-                \set{ \mv{m'} : (\exptype{C}{\ol{X} \triangleleft \ol{N}} \to \ol{\tv{a}} \to \tv{a}) \mid
-                  \mv{m'} \in \ol{M} \setminus \set{\mv{m}}, \, \tv{a}\, \ol{\tv{a}}\ \text{fresh} } \\
-\ \cup \, \set{\mv{m} : (\exptype{C}{\ol{X} \triangleleft \ol{N}} \to \ol{\tv{a}_m} \to \tv{a}_\mv{m})}
-\end{array}
- \\
-              & C_m = \typeExpr(\mtypeEnvironment \cup \set{\mv{this} :
-                \exptype{C}{\ol{X}} , \, \ol{x} : \ol{\tv{a}_m} }, \texttt{e}, \tv{a}_\texttt{m}) \\
-\textbf{in} 
-              & { ( \mtypeEnvironment \cup \ol{\methodAssumption}, \,
-                \bigcup_{\texttt{m} \in \ol{M}} C_m )
-                } 
+\textbf{let} & \ol{\methodAssumption} =
+                \set{ \mv{m} : (\exptype{C}{\ol{X}}, \ol{\tv{a}} \to \tv{a}) \mid
+                  \set{ \mv{m}(\ol{x}) = \expr{e} } \in \ol{M}, \, \tv{a}, \ol{\tv{a}}\ \text{fresh} } \\
+              \textbf{in} 
+                  & \begin{array}[t]{l}
+                \set{ \typeExpr(\mtypeEnvironment \cup \ol{\methodAssumption} \cup \set{\mv{this} :
+              \exptype{C}{\ol{X}} , \, \ol{x} : \ol{\tv{a}} }, \texttt{e}, \tv{a})
+               \\ \quad \quad \quad \quad \mid \set{ \mv{m}(\ol{x}) = \expr{e} }  \in \ol{M},\, \mv{m} : (\exptype{C}{\ol{X}}, \ol{\tv{a}} \to \tv{a}) \in \ol{\methodAssumption}}
+                  \end{array}
                 \end{array}
     \end{array}
   \end{gather*}
@@ -108,39 +111,6 @@ For the example above a correct solution would be $\sigma(\tv{a}) = \wctype{\rwi
   \label{fig:constraints-for-classes}
 \end{figure}
 
-% \textbf{Method Assumptions}
-
-% %$\Pi$ is a set of method assumptions used by the $\fjtype{}$ algorithm.
-
-% % \begin{verbatim}
-% % class Example<X> {
-% %   <Y> Y m(Example<Y> p){ ... }
-% % }
-% % \end{verbatim}
-
-% In Featherweight Java a method type is bound to a specific class.
-% The class \texttt{Example} shown above contains one method \texttt{m}:
-
-% \begin{displaymath}
-% \textit{mtype}({\texttt{m}, \exptype{Example}{\type{X}}}) = \generics{\type{Y}} \ \exptype{Example}{\type{Y}} \to \type{Y}
-% \end{displaymath}
-
-% $\Pi$ is a set of method assumptions used by the $\fjtype{}$ algorithm.
-% It's a map of method types to method names.
-% Every method name has a set of possible types,
-% because there could be more than one method with the same name in a program consisting out of multiple classes.
-% To simplify the syntax of method assumptions, we add the inheriting class type to the parameter list:
-
-% \begin{displaymath}
-% \Pi = \set{ \texttt{m} : \generics{\type{X}, \type{Y}} \ (\exptype{Example}{\type{X}}, \exptype{Example}{\type{Y}}) \to \type{Y}}
-% \end{displaymath}
-
-% \begin{verbatim}
-% class Example<X> { }
-
-% <X, Y> Y m(Example<X> this, Example<Y> p){ ... }
-% \end{verbatim}
-
 \begin{displaymath}
   \begin{array}{@{}l@{}l}
     \typeExpr{} &({\mtypeEnvironment} , \texttt{e}.\texttt{f}, \tv{a}) = \\
@@ -164,33 +134,39 @@ For the example above a correct solution would be $\sigma(\tv{a}) = \wctype{\rwi
   \end{array}
 \end{displaymath}
 
-The set of method assumptions returned by the \textit{mtypes} function is used to generate the constraints for a method call expression:
-
-There are two kinds of method calls.
-The ones to already typed methods and calls to untyped methods.
+\begin{displaymath}
+  \begin{array}{@{}l@{}l}
+    \typeExpr{} &({\mtypeEnvironment} , \texttt{let}\ \expr{x} = \expr{e}_1 \ \texttt{in} \ \expr{e}_2, \tv{a}) = \\
+                & \begin{array}{ll}
+                    \textbf{let} 
+                    & \tv{e}_1, \tv{e}_2, \tv{x} \ \text{fresh} \\
+                    & \consSet_1 = \typeExpr({\mtypeEnvironment}, \expr{e}_1, \tv{e}_1)\\
+                    & \consSet_2 = \typeExpr({\mtypeEnvironment} \cup \set{\expr{x} : \tv{x}}, \expr{e}_2, \tv{e}_2)\\
+                    & \constraint =
+                      \set{
+                      \tv{e}_1 \lessdot \tv{x}, \tv{e}_2 \lessdot \tv{a}
+                      }\\
+                    {\mathbf{in}} & {
+                      \consSet_1 \cup \consSet_2 \cup \set{\constraint}}
+                  \end{array} 
+  \end{array}
+\end{displaymath}
 
 \begin{displaymath}
   \begin{array}{@{}l@{}l}
-      \typeExpr{}' & ({\mtypeEnvironment} , \texttt{e}.\mathtt{m}(\overline{\texttt{e}}), \tv{a}) = \\
+      \typeExpr{} & ({\mtypeEnvironment} , \expr{v}.\mathtt{m}(\overline{\expr{v}}), \tv{a}) = \\
       & \begin{array}{ll}
       \textbf{let}
       & \tv{r}, \ol{\tv{r}} \text{ fresh} \\
-      & \consSet_R = \typeExpr(({\mtypeEnvironment} ;
-        \overline{\localVarAssumption}), \texttt{e}, \tv{r})\\
-      & \overline{\consSet} = \typeExpr({\mtypeEnvironment}, \ol{e}, \ol{\tv{r}})  \\
-      & \begin{array}{@{}l@{}l}
-        \constraint = \orCons\set{ & 
-                  \begin{array}[t]{l}
-                    [\overline{\wtv{a}}/\ol{X}] [\overline{\wtv{b}}/\ol{Y}] \{ \tv{r} \lessdotCC \exptype{C}{\ol{X}},
-                    \overline{\tv{r}} \lessdotCC \ol{T}, \type{T} \lessdot \tv{a}, 
-                    \ol{Y} \lessdot \ol{N} \}
-                  \end{array}\\
-            & \ |\ 
-            (\texttt{m} : \generics{\ol{Y} \triangleleft \ol{N}}\overline{\type{T}} \to \type{T}) \in 
-                {\mtypeEnvironment} %, \, |\ol{T}| = |\ol{e}|
-            , \, \overline{\wtv{a}} \text{ fresh}}
-        \end{array}\\
-      \mathbf{in} & (\consSet_R \cup \overline{\consSet} \cup \constraint, \type{T})
+      & \constraint = [\overline{\wtv{b}}/\ol{Y}]\set{
+                    \ol{S} \lessdotCC \ol{T}, \type{T} \lessdot \tv{a}, 
+                    \ol{Y} \lessdot \ol{N} }\\
+      \mathbf{in} & (\consSet_R \cup \overline{\consSet} \cup \constraint, \type{T}) \\
+      & \mathbf{where}\ \begin{array}[t]{l}
+        \expr{v}, \ol{v} : \ol{S} \in \localVarAssumption \\
+        \texttt{m} : \generics{\ol{Y} \triangleleft \ol{N}}\overline{\type{T}} \to \type{T} \in {\mtypeEnvironment}
+      \end{array}
+                    
       \end{array}
       \end{array}
   \end{displaymath}
@@ -199,95 +175,93 @@ The ones to already typed methods and calls to untyped methods.
 \textbf{Example:}
 \begin{verbatim}
 class Class1{
-  <X> X m(List<X> lx, List<? extends X> lt){ ... }
-  List<? extends String> wGet(){ ... }
-  List<String> get() { ... }
+  <A> A head(List<X> l){ ... }
+  List<? extends String> get() { ... }
 }
 
 class Class2{
   example(c1){
-    return c1.m(c1.get(), c1.wGet());
+    return c1.head(c1.get());
   }
 }
 \end{verbatim}
 %This example comes with predefined type annotations.
-We assume the class \texttt{Class1} has already been processed by our type inference algorithm,
-which has lead to the given type annotations for \texttt{Class1}.
-Now we call the $\fjtype{}$ function with the class \texttt{Class2} and the method assumptions for the preceeding class:
+We assume the class \texttt{Class1} has already been processed by our type inference algorithm
+leading to the following type annotations:
+%Now we call the $\fjtype{}$ function with the class \texttt{Class2} and the method assumptions for the preceeding class:
 \begin{displaymath}
 \mtypeEnvironment =  \left\{\begin{array}{l}
-    \type{Class1}.\texttt{m}: \generics{\type{X} \triangleleft \type{Object}} \ 
-      (\exptype{List}{\type{X}}, \, \wctype{\wildcard{A}{\type{X}}{\bot}}{List}{\wildcard{A}{\type{X}}{\bot}}) \to \type{X}, \\
-     \type{Class1}.\texttt{wGet}: () \to \wctype{\wildcard{A}{\type{Object}}{\type{String}}}{List}{\wildcard{A}{\type{Object}}{\type{String}}}, \\
-     \type{Class1}.\texttt{get}: () \to \exptype{List}{\type{String}}
+    \texttt{m}: \generics{\type{A} \triangleleft \type{Object}} \ 
+      (\type{Class1},\, \exptype{List}{\type{A}}) \to \type{X}, \\
+     \texttt{get}: (\type{Class1}) \to \wctype{\wildcard{A}{\type{Object}}{\type{String}}}{List}{\rwildcard{A}}
 \end{array} \right\} 
 \end{displaymath}
 
-The result of the $\typeExpr{}$ function is the constraint set
-\begin{displaymath}
-C = \left\{ \begin{array}{l}
-\tv{c1} \lessdot \type{Class1}, \\
-\tv{p1} \lessdot \exptype{List}{\wtv{x}}, \\
-\exptype{List}{\type{String}} \lessdot \tv{p1}, \\
-\tv{p2} \lessdot \wctype{\wildcard{A}{\wtv{x}}{\bot}}{List}{\rwildcard{A}}, \\
-\wctype{\wildcard{A}{\type{String}}{\bot}}{List}{\rwildcard{A}} \lessdot \tv{p2} 
-\end{array} \right\}
-\end{displaymath}
+At first we have to convert the example method to a syntactically correct \TamedFJ{} program.
+Afterwards the the \fjtype{} algorithm is able to generate constraints.
 
+\begin{minipage}{0.45\textwidth}
+  \begin{lstlisting}[style=tamedfj]
+class Class2 {
+  example(c1) = let x = c1 in
+    let xp = x.get() in x.m(xp);
+}
+\end{lstlisting}
+      \end{minipage}%
+      \hfill
+      \begin{minipage}{0.5\textwidth}
+\begin{constraintset}
+$
+    \begin{array}{l}
+      \ntv{c1} \lessdot \ntv{x}, \ntv{x} \lessdotCC \type{Class1}, \\
+    \ntv{c1} \lessdot \ntv{x}, \ntv{x} \lessdotCC \type{Class1}, \\
+    \wctype{\wildcard{A}{\type{String}}{\bot}}{List}{\rwildcard{A}} \lessdot \tv{xp}, \\
+    \tv{xp} \lessdotCC \exptype{List}{\wtv{a}}
+    \end{array}
+$
+  \end{constraintset}
+\end{minipage}
 
-The first parameter of a method assumption is the receiver type $\type{T}_r$.
-\texttt{Class1} for this example.
-Therefore the $(\tv{c1} \lessdot \type{Class1})$ constraint.
-The type variable $\tv{c1}$ is assigned to the parameter \texttt{c1} of the \texttt{example} method.
+Following is a possible solution for the given constraint set:
 
-or a simplified version:
+\begin{minipage}{0.55\textwidth}
+  \begin{lstlisting}[style=letfj]
+class Class2 {
+  example(c1) = let x : Class1 = c1 in
+    let xp : (*@$\wctype{\wildcard{A}{\type{String}}{\bot}}{List}{\rwildcard{A}}$@*) = x.get()
+      in x.m(xp);
+}
+\end{lstlisting}
+      \end{minipage}%
+      \hfill
+      \begin{minipage}{0.4\textwidth}
+\begin{constraintset}
+$
+    \begin{array}{l}
+    \sigma(\ntv{x}) = \type{Class1} \\
+    %\tv{xp} \lessdot \exptype{List}{\wtv{x}}, \\
+    %\exptype{List}{\type{String}} \lessdot \tv{p1}, \\
+    \sigma(\tv{xp}) = \wctype{\wildcard{A}{\type{String}}{\bot}}{List}{\rwildcard{A}} \\
+    \end{array}
+$
+  \end{constraintset}
+\end{minipage}
 
-\begin{displaymath}
-C = \left\{ \begin{array}{l}
-\tv{c1} \lessdot \type{Class1}, \\
-\exptype{List}{\type{String}} 
- \lessdot \exptype{List}{\wtv{x}}, \\
-\wctype{\wildcard{A}{\type{String}}{\bot}}{List}{\rwildcard{A}}
- \lessdot \wctype{\wildcard{A}{\wtv{x}}{\bot}}{List}{\rwildcard{A}}
-\end{array} \right\}
-\end{displaymath}
+For $\wctype{\wildcard{A}{\type{String}}{\bot}}{List}{\rwildcard{A}}$ to be a correct solution for $\tv{xp}$
+the constraint $\wctype{\wildcard{A}{\type{String}}{\bot}}{List}{\rwildcard{A}} \lessdotCC \exptype{List}{\wtv{a}}$
+must be satisfied.
+This is possible, because we deal with a capture constraint.
+The $\lessdotCC$ constraint allows the left side to undergo a capture conversion
+which leads to $\exptype{List}{\rwildcard{A}} \lessdot \exptype{List}{\wtv{a}}$.
+Now a substitution of the wildcard placeholder $\wtv{a}$ with $\rwildcard{A}$ leads to a satisfied constraint set.
 
-
-$\wtv{x}$ is a type variable we use for the generic $\type{X}$. It is flagged as a free type variable.
-%TODO: Do an example where wildcards are inserted and we need capture conversion
-
-\unify{} returns the solution $(\sigma = \set{ \tv{x} \to \type{String} })$
-
-% \\[1em]
-% \noindent
-% \textbf{Example:}
-% \begin{verbatim}
-% class Class1 {
-%   <X> Pair<X, X> make(List<X> l){ ... }
-%   <Y> boolean compare(Pair<Y,Y> p) { ... }
-
-%   example(l){
-%     return compare(make(l));
-%   }
-% }
-% \end{verbatim}
-
-% The method call \texttt{make(l)} generates the constraints
-% \begin{displaymath}
-%   \tv{l} \lessdot \exptype{List}{\tv{x}}, \exptype{Pair}{\tv{x}, \tv{x}} \lessdot \tv{m}
-% \end{displaymath}
-% with $\tv{l}$ being the type placeholder for the variable \texttt{l}
-% and $\tv{m}$ is the type variable for the return type of the method call.
-% $\tv{m}$ is then used as the parameter for the \texttt{compare} method:
-% \begin{displaymath}
-%   \tv{m} \lessdot \exptype{Pair}{\tv{y}, \tv{y}}
-% \end{displaymath}
-% Note the conversion of the generic parameters \texttt{X} and \texttt{Y} to type variables $\tv{x}$ and $\tv{y}$.
-
-
-
-% Step 3 of the \unify{} algorithm has to look for every possible supertype of $\exptype{Pair}{\tv{x}, \tv{x}}$,
-% when processing the $\exptype{Pair}{\tv{x}, \tv{x}} \lessdot \tv{m}$ constraint.
+The wildcard placeholders are not used as parameter or return types of methods.
+Or as types for variables introduced by let statements.
+They are only used for generic method parameters during a method invocation.
+Type placeholders which are not flagged as wildcard placeholders ($\wtv{a}$) can never hold a free variable or a type containing free variables.
+This practice hinders free variables to leave their scope.
+The free variable $\rwildcard{A}$ generated by the capture conversion on the type $\wctype{\wildcard{A}{\type{String}}{\bot}}{List}{\rwildcard{A}}$
+cannot be used anywhere else then inside the constraints generated by the method call \texttt{x.m(xp)}.
 
 \begin{displaymath}
   \begin{array}{@{}l@{}l}

introduction.tex

@@ -14,7 +14,7 @@ Our algorithm is also capable of finding solutions involving wildcards as shown
 
 %This paper extends a type inference algorithm for Featherweight Java \cite{TIforFGJ} by adding wildcards.
 %The last step to create a type inference algorithm compatible to the Java type system.
-The algorithm presented in this paper is a slightly improved version of the one in \cite{TIforFGJ} including wildcard support.
+The algorithm presented in this paper is a improved version of the one in \cite{TIforFGJ} including wildcard support.
 %a modified version of the \unify{} algorithm presented in \cite{plue09_1}.
 The input to the type inference algorithm is a Featherweight Java program (example in figure \ref{fig:nested-list-example-typeless}) conforming to the syntax shown in figure \ref{fig:syntax}.
 The \fjtype{} algorithm calculates constraints based on this intermediate representation,
@@ -30,7 +30,8 @@ We support capture conversion and Java style method calls.
 This requires existential types in a form which is not denotable by Java syntax \cite{aModelForJavaWithWildcards}.
 \item
 We present a novel approach to deal with existential types and capture conversion during constraint unification.
-The algorithm is split in two parts. A constraint generation step and an unification step.
+\item The algorithm is split in two parts. A constraint generation step and an unification step.
+Input language and constraint generations can be extended without altering the unification part.
 \item
 We proof soundness and aim for a good compromise between completeness and time complexity.
 \end{itemize}
@@ -117,11 +118,6 @@ class Example {
       %\label{fig:intro-example-code}
 \end{figure}
 
-
-%TODO
-% The goal is to proof soundness in respect to the type rules introduced by \cite{aModelForJavaWithWildcards}
-% and \cite{WildcardsNeedWitnessProtection}.
-
 \begin{figure}%[tp]
       \begin{subfigure}[t]{0.49\linewidth}
     \begin{lstlisting}[style=fgj]
@@ -182,110 +178,6 @@ Those properties are needed to formalize capture conversion.
 Polymorphic method calls need to be wraped in a process which \textit{opens} existential types \cite{addingWildcardsToJava}.
 In Java this is done implicitly in a process called capture conversion.
 
-One problem is the divergence between denotable and expressable types in Java \cite{semanticWildcardModel}.
-A wildcard in the Java syntax has no name and is bound to its enclosing type.
-$\exptype{List}{\exptype{List}{\type{?}}}$ equates to $\exptype{List}{\wctype{\rwildcard{X}}{List}{\rwildcard{X}}}$.
-During type checking \emph{intermediate types}
-%like $\wctype{\rwildcard{X}}{List}{\exptype{List}{\rwildcard{X}}}$
-%or $\wctype{\rwildcard{X}}{Pair}{\rwildcard{X}, \rwildcard{X}}$
-can emerge, which have no equivalent in the Java syntax.
-%Our type inference algorithm uses existential types internally but spawns type solutions compatible with Java.
-
-Example: % This program is not typable with the Type Inference algorithm from Plümicke
-\begin{verbatim}
-class List<X> extends Object {...}
-class List2D<X> extends List<List<X>> {...}
-
-<X> void shuffle(List<List<X>> list) {...}
-
-List<List<?>> l = ...;
-List2D<?> l2d = ...;
-
-shuffle(l); // Error
-shuffle(l2d); // Valid
-\end{verbatim}
-Java is using local type inference to allow method invocations which are not describable with regular Java types.
-The \texttt{shuffle} method in this case is invoked with the type $\wctype{\rwildcard{X}}{List2D}{\rwildcard{X}}$
-which is a subtype of $\wctype{\rwildcard{X}}{List}{\exptype{List}{\rwildcard{X}}}$.
-After capture conversion \texttt{l2d'} has the type $\exptype{List}{\exptype{List}{\rwildcard{X}}}$
-and \texttt{shuffle} can be invoked with the type parameter $\rwildcard{X}$:
-\begin{lstlisting}[style=letfj]
-let l2d' : (*@$\wctype{\rwildcard{X}}{List}{\exptype{List}{\rwildcard{X}}}$@*) = l2d in <X>shuffle(l2d')
-\end{lstlisting}
-
-The respective constraints are:
-\begin{constraintset}
-\begin{center}
-    $
-    \begin{array}{l}
-    \wctype{\rwildcard{X}}{List2D}{\rwildcard{X}} \lessdotCC \exptype{List}{\exptype{List}{\wtv{x}}}
-    \\
-    \hline
-    \wctype{\rwildcard{X}}{List}{\exptype{List}{\rwildcard{X}}} \lessdotCC \exptype{List}{\exptype{List}{\wtv{x}}}
-    \\
-    \hline
-    \textit{Capture Conversion:}\ 
-    \exptype{List}{\exptype{List}{\rwildcard{X}}} \lessdot \exptype{List}{\exptype{List}{\wtv{x}}}
-    \\
-    \hline
-    \textit{Solution:} \wtv{x} \doteq \rwildcard{X} \implies \exptype{List}{\exptype{List}{\rwildcard{X}}} \lessdot \exptype{List}{\exptype{List}{\rwildcard{X}}}
-    \end{array}
-    $
-\end{center}
-\end{constraintset}
-
-\texttt{l} however has the type
-$\exptype{List}{\wctype{\rwildcard{X}}{List}{\rwildcard{X}}}$.
-The method call \texttt{shuffle(l)} is not correct, because there is no solution for the subtype constraint:
-
-$\exptype{List}{\wctype{\rwildcard{X}}{List}{\rwildcard{X}}} \lessdotCC \exptype{List}{\exptype{List}{\wtv{x}}}$
-
-\section{Type Inference for Capture Conversion}
-why do we need a lessdotCC constraint
-\dbox{Eine dashbox!}
-input is e.m(e);
-\begin{recap}\textbf{TI for FGJ without Wildcards:}
-- usually the type of e must be subtypes of the method parameters
-- in case of a polymorphic method: type placeholders resemble type parameters
-\end{recap}
-involving wildcards:
-- depending on the type of e a capture conversion must be applied first
-- the captured type N must be a subtype of the method parameters
-- type parameters: can be set to free variables!
-    - but must afterwards be closed again
-    - the free variables can only be used inside the let statement
-- we align the let statements in a way thate mimics Java capture conversion:
-
-
-% $\exptype{List}{String} <: \wctype{\wildcard{X}{\bot}{\type{Object}}}{List}{\rwildcard{X}}$
-% means \texttt{List<String>} is a subtype of \texttt{List<? extend Object>}.
-
-\subsection{Global Type Inference}
-% A global type inference algorithm works on an input with no type annotations at all.
-% \begin{verbatim}
-% m(l) {
-%     return l.add(l);
-% }
-% \end{verbatim}
-
-% $\tv{l} \lessdotCC \exptype{List}{\wtv{x}}, \tv{l} \lessdotCC \wtv{x}$
-
-\begin{description}
-    \item[input] \tifj{} program
-    \item[output] type solution
-    \item[postcondition] the type solution applied to the input must yield a valid \letfj{} program
-\end{description}
-
-The input to our type inference algorithm is a modified version of the \letfj{}\cite{WildcardsNeedWitnessProtection} calculus (see chapter \ref{sec:tifj}).
-First \fjtype{} generates constraints
-and afterwards \unify{} computes a solution for the given constraint set.
-Constraints consist out of subtype constraints $(\type{T} \lessdot \type{T})$ and capture constraints $(\type{T} \lessdotCC \type{T})$.
-\textit{Note:} a type $\type{T}$ can also be a type placeholders $\ntv{a}$ or a wildcard type placeholder $\wtv{a}$.
-A subtype constraint is satisfied if the left side is a subtype of the right side according to the rules in figure \ref{fig:subtyping}.
-\textit{Example:} $\exptype{List}{\ntv{a}} \lessdot \exptype{List}{\type{String}}$ is fulfilled by replacing type placeholder $\ntv{a}$ with the type $\type{String}$.
-Subtype constraints and type placeholders act the same as the ones used in \emph{Type Inference for Featherweight Generic Java} \cite{TIforFGJ}.
-The novel capture constraints and wildcard placeholders are needed for method invocations involving wildcards.
-
 %show input and a correct letFJ representation
 %TODO: first show local type inference and explain lessdotCC constraints. then show example with global TI
 \begin{figure}[h]
@@ -319,8 +211,71 @@ becomes $\exptype{List}{\rwildcard{X}}$ and the wildcard $\wildcard{X}{\type{Obj
 a type parameter to \texttt{<X>add(...)}.
 %This is a valid Java program where the type parameters for the polymorphic method \texttt{add}
 %are determined by local type inference.
-Our type inference algorithm has to add let statements if necessary, including the capture types.
 
+One problem is the divergence between denotable and expressable types in Java \cite{semanticWildcardModel}.
+A wildcard in the Java syntax has no name and is bound to its enclosing type:
+$\exptype{List}{\exptype{List}{\type{?}}}$ equates to $\exptype{List}{\wctype{\rwildcard{X}}{List}{\rwildcard{X}}}$.
+During type checking \emph{intermediate types}
+%like $\wctype{\rwildcard{X}}{List}{\exptype{List}{\rwildcard{X}}}$
+%or $\wctype{\rwildcard{X}}{Pair}{\rwildcard{X}, \rwildcard{X}}$
+can emerge, which have no equivalent in the Java syntax.
+%Our type inference algorithm uses existential types internally but spawns type solutions compatible with Java.
+
+Example: % This program is not typable with the Type Inference algorithm from Plümicke
+\begin{lstlisting}[style=java,label=shuffleExample,caption=Intermediate Types Example]
+class List<X> extends Object {...}
+class List2D<X> extends List<List<X>> {...}
+
+<X> void shuffle(List<List<X>> list) {...}
+
+List<List<?>> l = ...;
+List2D<?> l2d = ...;
+
+shuffle(l); // Error
+shuffle(l2d); // Valid
+\end{lstlisting}
+Java is using local type inference to allow method invocations which are not describable with regular Java types.
+The \texttt{shuffle} method in this case is invoked with the type $\wctype{\rwildcard{X}}{List2D}{\rwildcard{X}}$
+which is a subtype of $\wctype{\rwildcard{X}}{List}{\exptype{List}{\rwildcard{X}}}$.
+After capture conversion \texttt{l2d'} has the type $\exptype{List}{\exptype{List}{\rwildcard{X}}}$
+and \texttt{shuffle} can be invoked with the type parameter $\rwildcard{X}$:
+\begin{lstlisting}[style=letfj]
+let l2d' : (*@$\wctype{\rwildcard{X}}{List}{\exptype{List}{\rwildcard{X}}}$@*) = l2d in <X>shuffle(l2d')
+\end{lstlisting}
+
+\subsection{Global Type Inference}
+
+\begin{description}
+    \item[input] \tifj{} program
+    \item[output] type solution
+    \item[postcondition] the type solution applied to the input must yield a valid \letfj{} program
+\end{description}
+
+The input to our type inference algorithm is a modified version of the \letfj{}\cite{WildcardsNeedWitnessProtection} calculus (see chapter \ref{sec:tifj}).
+First \fjtype{} generates constraints
+and afterwards \unify{} computes a solution for the given constraint set.
+Constraints consist out of subtype constraints $(\type{T} \lessdot \type{T})$ and capture constraints $(\type{T} \lessdotCC \type{T})$.
+\textit{Note:} a type $\type{T}$ can either be a named type, a type placeholder or a wildcard type placeholder.
+A subtype constraint is satisfied if the left side is a subtype of the right side according to the rules in figure \ref{fig:subtyping}.
+\textit{Example:} $\exptype{List}{\ntv{a}} \lessdot \exptype{List}{\type{String}}$ is fulfilled by replacing type placeholder $\ntv{a}$ with the type $\type{String}$.
+Subtype constraints and type placeholders act the same as the ones used in \emph{Type Inference for Featherweight Generic Java} \cite{TIforFGJ}.
+The novel capture constraints and wildcard placeholders are needed for method invocations involving wildcards.
+
+\begin{recap}\textbf{TI for FGJ without Wildcards:}
+\TFGJ{} generates subtype constraints $(\type{T} \lessdot \type{T})$ consisting of named types and type placeholders.
+For example the method invocation \texttt{concat(l, new Object())} generates the constraints
+$\tv{l} \lessdot \exptype{List}{\tv{a}}, \type{Object} \lessdot \tv{a}$.
+Subtyping without the use of wildcards is invariant \cite{FJ}:
+Therefore the only possible solution for the type placeholder $\tv{a}$ is $\tv{a} \doteq \type{Object}$. % in Java and Featherweight Java.
+The correct type for the variable \texttt{l} is $\exptype{List}{\type{Object}}$ (or a direct subtype).
+%- usually the type of e must be subtypes of the method parameters
+%- in case of a polymorphic method: type placeholders resemble type parameters
+The type inference algorithm for Featherweight Generic Java \cite{TIforFGJ} (called \TFGJ{}) is complete and sound:
+It is able to find a type solution for a Featherweight Generic Java program, which has no type annotations at all,
+if there is any.
+It's only restriction is that no polymorphic recursion is allowed.
+\end{recap}
+%
 Lets have a look at the constraints generated by \fjtype{} for the example in listing \ref{lst:addExample}:
 \begin{constraintset}
 \begin{center}
@@ -328,19 +283,56 @@ $\begin{array}{c}
 \wctype{\wildcard{X}{\type{Object}}{\type{String}}}{List}{\rwildcard{X}} \lessdotCC \exptype{List}{\wtv{a}}, \, \type{String} \lessdotCC \wtv{a}
 \\
 \hline
-\textit{Capture Conversion:}\ \exptype{List}{\rwildcard{X}} \lessdot \exptype{List}{\wtv{a}}, \, \type{String} \lessdot \wtv{a}
+\textit{Capture Conversion:}\ \wildcard{Y}{\type{Object}}{\type{String}} \wcSep \exptype{List}{\rwildcard{Y}} \lessdot \exptype{List}{\wtv{a}}, \, \type{String} \lessdot \wtv{a}
 \\
 \hline
-\textit{Solution:}\ \wtv{a} \doteq \rwildcard{X} \implies \exptype{List}{\rwildcard{X}} \lessdot \exptype{List}{\rwildcard{X}}, \, \type{String} \lessdot \rwildcard{X}
+\textit{Solution:}\ \wtv{a} \doteq \rwildcard{Y} \implies \wildcard{Y}{\type{Object}}{\type{String}} \wcSep \exptype{List}{\rwildcard{Y}} \lessdot \exptype{List}{\rwildcard{Y}}, \, \type{String} \lessdot \rwildcard{Y}
 \end{array}
 $
 \end{center}
 \end{constraintset}
+%
+Capture Constraints $(\wctype{\rwildcard{X}}{C}{\rwildcard{X}} \lessdotCC \type{T})$ allow for a capture conversion,
+which converts a constraint of the form $(\wctype{\rwildcard{X}}{C}{\rwildcard{X}} \lessdotCC \type{T})$ to $(\exptype{C}{\rwildcard{X}} \lessdot \type{T})$
+%These constraints are used at places where a capture conversion via let statement can be added.
+
 %Why do we need the lessdotCC constraints here?
 The type of \texttt{l} can be capture converted by a let statement if needed (see listing \ref{lst:addExampleLet}).
 Therefore we assign the constraint $\wctype{\wildcard{X}{\type{Object}}{\type{String}}}{List}{\rwildcard{X}} \lessdotCC \exptype{List}{\wtv{a}}$
 which allows \unify{} to do a capture conversion to $\exptype{List}{\rwildcard{X}} \lessdot \exptype{List}{\wtv{a}}$.
-\textit{Note:} The constraint $\type{String} \lessdot \rwildcard{X}$ is satisfied because $\rwildcard{X}$ has $\type{String}$ as lower bound.
+The captured wildcard $\rwildcard{X}$ gets a fresh name and is stored in the wildcard environment of the \unify{} algorithm.
+
+
+\textit{Note:} The constraint $\type{String} \lessdot \rwildcard{Y}$ is satisfied
+because $\rwildcard{Y}$ has $\type{String}$ as lower bound.
+
+
+For the example shown in listing \ref{shuffleExample} the method call \texttt{shuffle(l2d)} creates the constraints:
+\begin{constraintset}
+\begin{center}
+    $
+    \begin{array}{l}
+    \wctype{\rwildcard{X}}{List2D}{\rwildcard{X}} \lessdotCC \exptype{List}{\exptype{List}{\wtv{x}}}
+    \\
+    \hline
+    \wctype{\rwildcard{X}}{List}{\exptype{List}{\rwildcard{X}}} \lessdotCC \exptype{List}{\exptype{List}{\wtv{x}}}
+    \\
+    \hline
+    \textit{Capture Conversion:}\ 
+    \exptype{List}{\exptype{List}{\rwildcard{X}}} \lessdot \exptype{List}{\exptype{List}{\wtv{x}}}
+    \\
+    \hline
+    \textit{Solution:} \wtv{x} \doteq \rwildcard{X} \implies \exptype{List}{\exptype{List}{\rwildcard{X}}} \lessdot \exptype{List}{\exptype{List}{\rwildcard{X}}}
+    \end{array}
+    $
+\end{center}
+\end{constraintset}
+
+The method call \texttt{shuffle(l)} is invalid however,
+because \texttt{l} has the type
+$\exptype{List}{\wctype{\rwildcard{X}}{List}{\rwildcard{X}}}$.
+There is no solution for the subtype constraint:
+$\exptype{List}{\wctype{\rwildcard{X}}{List}{\rwildcard{X}}} \lessdotCC \exptype{List}{\exptype{List}{\wtv{x}}}$
 
 % No capture conversion for methods in the same class:
 % Given two methods without type annotations like
@@ -367,28 +359,113 @@ which allows \unify{} to do a capture conversion to $\exptype{List}{\rwildcard{X
 % List<?> id(List<?> a) = a
 % \end{verbatim}
 
-The following example has the \texttt{id} method already typed and the method \texttt{m}
-extended by a recursive call \texttt{id(m())}:
-\begin{verbatim}
-<A> List<A> id(List<A> a) = a
+% The following example has the \texttt{id} method already typed and the method \texttt{m}
+% extended by a recursive call \texttt{id(m())}:
+% \begin{verbatim}
+% <A> List<A> id(List<A> a) = a
 
-m() = new List<String>() :? new List<Integer>() :? id(m());
-\end{verbatim}
-Now the constraints make use of a $\lessdotCC$ constraint:
-$\exptype{List}{\type{String}} \lessdot \ntv{r},
-\exptype{List}{\type{Integer}} \lessdot \ntv{r},
-\ntv{r} \lessdotCC \exptype{List}{\wtv{a}}$
+% m() = new List<String>() :? new List<Integer>() :? id(m());
+% \end{verbatim}
+% Now the constraints make use of a $\lessdotCC$ constraint:
+% $\exptype{List}{\type{String}} \lessdot \ntv{r},
+% \exptype{List}{\type{Integer}} \lessdot \ntv{r},
+% \ntv{r} \lessdotCC \exptype{List}{\wtv{a}}$
 
-After substituting $\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$ for $\ntv{r}$ like in the example before
-we get the constraint $\wctype{\rwildcard{X}}{List}{\rwildcard{X}} \lessdotCC \exptype{List}{\wtv{a}}$.
-Due to the $\lessdotCC$ \unify{} is allowed to perform a capture conversion yielding
-$\exptype{List}{\rwildcard{X}} \lessdot \exptype{List}{\wtv{a}}$.
-\textit{Note:} The wildcard placeholder $\wtv{a}$ is allowed to hold free variables whereas a normal placeholder like $\ntv{r}$
-is never assigned a type containing free variables.
-Therefore \unify{} sets $\wtv{a} \doteq \rwildcard{X}$, completing the constraint set and resulting in the type solution:
-\begin{verbatim}
-List<?> m() = new List<String>() :? new List<Integer>() :? id(m());
-\end{verbatim}
+% After substituting $\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$ for $\ntv{r}$ like in the example before
+% we get the constraint $\wctype{\rwildcard{X}}{List}{\rwildcard{X}} \lessdotCC \exptype{List}{\wtv{a}}$.
+% Due to the $\lessdotCC$ \unify{} is allowed to perform a capture conversion yielding
+% $\exptype{List}{\rwildcard{X}} \lessdot \exptype{List}{\wtv{a}}$.
+% \textit{Note:} The wildcard placeholder $\wtv{a}$ is allowed to hold free variables whereas a normal placeholder like $\ntv{r}$
+% is never assigned a type containing free variables.
+% Therefore \unify{} sets $\wtv{a} \doteq \rwildcard{X}$, completing the constraint set and resulting in the type solution:
+% \begin{verbatim}
+% List<?> m() = new List<String>() :? new List<Integer>() :? id(m());
+% \end{verbatim}
+
+\subsection{\TamedFJ{} and \letfj{}}
+%LetFJ -> Output language!
+%TamedFJ -> ANF transformed input langauge
+%Input language only described here. It is standard Featherweight Java
+% we use the transformation to proof soundness. this could also be moved to the end. 
+% the constraint generation step assumes every method argument to be encapsulated in a let statement. This is the way Java is doing capture conversion
+
+The input to our algorithm is a typeless version of Featherweight Java.
+Methods are declared without parameter or return types.
+We still keep type annotations for fields and generic class parameters.
+This is a design choice by us,
+as we consider them as data declarations which are given by the programmer.
+% They are inferred in for example \cite{plue14_3b}
+Note the \texttt{new} expression not requiring generic parameters,
+which are also inferred by our algorithm.
+The method call naturally has no generic parameters aswell.
+We add the elvis operator ($\elvis{}$) to the syntax mainly to showcase applications involving wildcard types.
+The syntax is described in figure \ref{fig:inputSyntax}.
+
+
+\begin{figure}
+$
+\begin{array}{lrcl}
+\hline
+\text{Parameterized classes} & \mv N & ::= & \exptype{C}{\ol{T}} \\
+\text{Types} & \type{S}, \type{T}, \type{U} & ::= & \type{X} \mid \wcNtype{\Delta}{N} \\
+\text{Lower bounds} & \type{K}, \type{L} & ::= & \type{T} \mid \bot \\
+\text{Type variable contexts} &  \Delta & ::= & \overline{\wildcard{X}{T}{L}} \\
+\text{Class declarations} &  D & ::= & \texttt{class}\ \exptype{C}{\ol{X \triangleleft T}} \triangleleft \type{N} \set{\overline{\type{T}\ f}; \ol{M}} \\
+\text{Method declarations} &  \texttt{M} & ::= & \texttt{m}(\overline{x}) \{ \texttt{return}\ t; \} \\
+\text{Terms} & t & ::= & x \\
+& & \ \ | & \texttt{new} \ \type{C}(\overline{t})\\
+& & \ \ | & t.f\\
+& & \ \ | & t.\texttt{m}(\overline{t})\\
+& & \ \ | & t \elvis{} t\\
+\text{Variable contexts} & \Gamma & ::= & \overline{x:\type{T}}\\
+\hline
+\end{array}
+$
+\caption{Input Syntax}\label{fig:inputSyntax}
+\end{figure}
+
+The output is a valid Featherweight Java program.
+We use the syntax of the version introduced in \cite{WildcardsNeedWitnessProtection}
+calling it \letfj{} for that it is a Featherweight Java variant including \texttt{let} statements.
+Our output syntax is shown in figure \ref{fig:outputSyntax}
+which is actually a subset of \letfj{}, because we omit \texttt{null} types.
+
+\begin{figure}
+$
+\begin{array}{lrcl}
+\hline
+\text{Parameterized classes} & \mv N & ::= & \exptype{C}{\ol{T}} \\
+\text{Types} & \type{S}, \type{T}, \type{U} & ::= & \type{X} \mid \wcNtype{\Delta}{N} \\
+\text{Lower bounds} & \type{K}, \type{L} & ::= & \type{T} \mid \bot \\
+\text{Type variable contexts} &  \Delta & ::= & \overline{\wildcard{X}{T}{L}} \\
+\text{Class declarations} &  D & ::= & \texttt{class}\ \exptype{C}{\ol{X \triangleleft T}} \triangleleft \type{N} \set{\overline{\type{T}\ f}; \ol{M}} \\
+\text{Method declarations} &  \texttt{M} & ::= & \generics{\overline{\type{X} \triangleleft \type{N}}}\type{T}\ \texttt{m}(\overline{\type{T}\ \expr{x}}) = \expr{e} \\
+\text{Terms} & \expr{e} & ::= & \expr{x} \\
+& & \ \ | & \texttt{new} \ \exptype{C}{\ol{T}}(\overline{\expr{e}})\\
+& & \ \ | & \expr{e}.f\\
+& & \ \ | & \expr{e}.\texttt{m}\generics{\ol{T}}(\overline{\expr{e}})\\
+& & \ \ | & \texttt{let}\ \expr{x} : \wcNtype{\Delta}{N} = \expr{e} \ \texttt{in} \ \expr{e}\\
+& & \ \ | & \expr{e} \elvis{} \expr{e}\\
+\text{Variable contexts} & \Gamma & ::= & \overline{\expr{x}:\type{T}}\\
+\hline
+\end{array}
+$
+\caption{Output Syntax}\label{fig:outputSyntax}
+\end{figure}
+
+
+The output of our type inference algorithm is a valid \letfj{} program.
+Before generating constraints the input is transformed to \TamedFJ{}.
+After adding the missing type annotations the resulting program is a valid \letfj{} program.
+%This is shown in chapter \ref{sec:soundness}
+Capture conversion is only needed for wildcard types,
+but we don't know which expressions will spawn wildcard types because there are no type annotations yet.
+We preemptively enclose every expression in a let statement before using it as a method argument.
+
+We need the let statements to deal with possible Wildcard types.
+
+
+The syntax used in our examples is the standard Featherweight Java syntax.
 
 
 \subsection{Challenges}\label{challenges}
@@ -422,7 +499,7 @@ it is safe to pass \texttt{"String"} for the first parameter of the function.
 <A> List<A> add(List<A> l, A v) {}
 
 List<? super String> list = ...;
-add("String", list);
+add(list, "String");
 \end{verbatim}
 \end{example}
 
@@ -459,141 +536,201 @@ concat(list, list);
 % An additional constraint $\wctype{\rwildcard{X}}{List}{\rwildcard{X}} \lessdot \exptype{List}{\wtv{a}}$
 % is solved by removing the wildcard $\rwildcard{X}$ if possible.
 
+\item \textbf{No principal method type:}
+We tried to skip capture conversion and the capture constraints entirely.
+But \letfj{}'s type system does not imply a principal typing for methods \cite{principalTypes}.
+The problem is that a principal type of a method should have the most general parameter types and the most specific return type.
+\begin{lstlisting}[caption=Return type depends on argument types,label=principalTypeExample]
+class SpecialPair<X, Y extends X> extends Pair<X,Y>{}
+
+
+<X,Y> Pair<X,Y> id(Pair<X,Y> in){
+  return in;
+}
+
+<X, Y extends X> void receive(Pair<X,Y> in){}
+
+Pair<?, ?> l;
+SpecialPair<?,?> lSpecial;
+
+id(l); // this has to work
+receive(id(lSpecial)); // and this too
+\end{lstlisting}
+
+By means of subtyping we are able to create types like
+$\wctype{\rwildcard{X}, \wildcard{Y}{\rwildcard{X}}{\bot}}{Pair}{\rwildcard{X}, \rwildcard{Y}}$
+as a direct supertype of \texttt{SpecialPair<?,?>},
+which is now compatible with the \texttt{receive} method.
+The call \texttt{receive(id(lSpecial))} is correct whereas the return type of the \texttt{id} method
+does not imply so.
+
+If we look at this in the context of global type inference and assume that there are no type annotations for \texttt{l} and \texttt{lSpecial}.
+We can neither apply capture conversion during the constraint generation step, because the parameter types are not known yet
+and we also can't assume a most generic type for the parameter types, because the the needed return type is not known either.
+Take the example in figure \ref{fig:principalTI}.
+As soon as the type of $\tv{lSpecial}$ is resolved \unify{} can determine the type of $\tv{id}$
+and then solve the constraints $\tv{id} \lessdotCC \exptype{Pair}{\wtv{e}, \wtv{f}}, \wtv{f} \lessdot \wtv{e}$.
+%TODO: explain how type variables are named after their respective variables and methods
+Capture Conversion cannot be applied before the argument type ($\tv{lSpecial}$ in this case) is known.
+Trying to give $\tv{lSpecial}$ a most general type like \texttt{Pair<?,?>} won't work either (see listing \ref{principalTypeExample}).
+
+\begin{figure}
+\begin{minipage}{0.40\textwidth}
+\begin{lstlisting}[style=tfgj]
+// l and lSpecial are untyped 
+id(l);
+receive(id(lSpecial));
+\end{lstlisting}
+\end{minipage}%
+\hfill
+\begin{minipage}{0.59\textwidth}
+\begin{constraintset}
+$
+\tv{l} \lessdotCC \exptype{Pair}{\wtv{a}, \wtv{b}}, \\
+\tv{lSpecial} \lessdotCC \exptype{Pair}{\wtv{c}, \wtv{d}}, 
+\exptype{Pair}{\wtv{c}, \wtv{d}} \lessdot \tv{id}, \\
+\tv{id} \lessdotCC \exptype{Pair}{\wtv{e}, \wtv{f}},
+\wtv{f} \lessdot \wtv{e}
+$
+\end{constraintset}
+\end{minipage}
+\caption{Principal Type problem}\label{fig:principalTI}
+\end{figure}
+% TODO: make Unify to resolve C<X> <. a as a =. X.C<X>
+
+% A method has infinte possibilities of being called and there is no most general type.
+% P<X,Y> m(C<X> c, C<Y> c2)
+% depending on 
+% A.P<A,A> <. A,B.P<A,B>
+
+% % During the method call it is not sure what kind of return type is needed from the method.
+% % The method P<A,B> make(A a, B b) 
+% % The type A,B.P<A,B> cannot be a subtype of P<X,X>
+% % But if A^X_X and B^X_X
+% % Could a constraint C<X> <. a? be expanded to a? = X^u?_l?.C<X>
+
 
 \end{itemize}
 
+%TODO: Move this part. or move the third challenge some underneath.
 The \unify{} algorithm only sees the constraints with no information about the program they originated from.
 The main challenge was to find an algorithm which computes $\sigma(\wtv{a}) = \rwildcard{X}$ for example \ref{intro-example1} but not for example \ref{intro-example2}.
 
-\subsection{Capture Conversion}
-The input to our type inference algorithm does not contain let statements.
-Those are added after computing a type solution.
-Let statements act as capture conversion and only have to be applied in method calls involving wildcard types.
+%TODO
+% The goal is to proof soundness in respect to the type rules introduced by \cite{aModelForJavaWithWildcards}
+% and \cite{WildcardsNeedWitnessProtection}.
 
-\begin{figure} 
-  \begin{minipage}{0.45\textwidth}
-\begin{lstlisting}[style=fgj]
-<X> List<X> clone(List<X> l);
-example(p){
-  return clone(p);
-}
-\end{lstlisting}
-    \end{minipage}%
-    \hfill
-    \begin{minipage}{0.5\textwidth}
-\begin{lstlisting}[style=tfgj]
-(*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*) example((*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*) p){
-  return let x : (*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*) = p in
-   clone(x) : (*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*);
-}
-\end{lstlisting}
-    \end{minipage}
-\caption{Type inference adding capture conversion}\label{fig:addingLetExample}
-  \end{figure}
+% \subsection{Capture Conversion}
+% The \texttt{let} statements in \TamedFJ{} act as capture conversion for wildcard types.
 
-Figure \ref{fig:addingLetExample} shows a let statement getting added to the typed output.
-The method \texttt{clone} cannot be called with the type $\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$.
-After a capture conversion \texttt{x} has the type $\exptype{List}{\rwildcard{X}}$ with $\rwildcard{X}$ being a free variable.
-Afterwards we have to find a supertype of $\exptype{List}{\rwildcard{X}}$, which does not contain free variables
-($\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$ in this case).
+% \begin{figure} 
+% \begin{minipage}{0.45\textwidth}
+% \begin{lstlisting}[style=tfgj]
+% <X> List<X> clone(List<X> l);
+% example(p){
+%   return clone(p);
+% }
+% \end{lstlisting}
+%     \end{minipage}%
+%     \hfill
+%     \begin{minipage}{0.5\textwidth}
+% \begin{lstlisting}[style=letfj]
+% <X> List<X> clone(List<X> l);
+% (*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*) example((*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*) p) = 
+%   let x : (*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*) = p in
+%    clone(x) : (*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*);
+% \end{lstlisting}
+%     \end{minipage}
+% \caption{Type inference adding capture conversion}\label{fig:addingLetExample}
+%   \end{figure}
 
-During the constraint generation step most types are not known yet and are represented by a type placeholder.
-During a methodcall like the one in the \texttt{example} method in figure \ref{fig:ccExample} the type of the parameter \texttt{p}
-is not known yet.
-The type \texttt{List<?>} would be one possibility as a parameter type for \texttt{p}.
-To make wildcards work for our type inference algorithm \unify{} has to apply capture conversions if necessary.
+% Figure \ref{fig:addingLetExample} shows a let statement getting added to the typed output.
+% The method \texttt{clone} cannot be called with the type $\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$.
+% After a capture conversion \texttt{x} has the type $\exptype{List}{\rwildcard{X}}$ with $\rwildcard{X}$ being a free variable.
+% Afterwards we have to find a supertype of $\exptype{List}{\rwildcard{X}}$, which does not contain free variables
+% ($\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$ in this case).
 
-The type placeholder $\tv{r}$ is the return type of the \texttt{example} method.
-One possible type solution is $\tv{p} \doteq \tv{r} \doteq \wctype{\rwildcard{X}}{List}{\rwildcard{X}}$,
-which leads to:
-\begin{verbatim}
-List<?> example(List<?> p){
-  return clone(p);
-}
-\end{verbatim}
+% During the constraint generation step most types are not known yet and are represented by a type placeholder.
+% During a methodcall like the one in the \texttt{example} method in figure \ref{fig:ccExample} the type of the parameter \texttt{p}
+% is not known yet.
+% The type \texttt{List<?>} would be one possibility as a parameter type for \texttt{p}.
+% To make wildcards work for our type inference algorithm \unify{} has to apply capture conversions if necessary.
 
-But by substituting $\tv{p} \doteq \wctype{\rwildcard{X}}{List}{\rwildcard{X}}$ in the constraint
-$\tv{p} \lessdotCC \exptype{List}{\wtv{x}}$ leads to
-$\wctype{\rwildcard{X}}{List}{\rwildcard{X}} \lessdotCC \exptype{List}{\wtv{x}}$.
+% The type placeholder $\tv{r}$ is the return type of the \texttt{example} method.
+% One possible type solution is $\tv{p} \doteq \tv{r} \doteq \wctype{\rwildcard{X}}{List}{\rwildcard{X}}$,
+% which leads to:
+% \begin{verbatim}
+% List<?> example(List<?> p){
+%   return clone(p);
+% }
+% \end{verbatim}
 
-To make this typing possible we have to introduce a capture conversion via a let statement:
-$\texttt{return}\ (\texttt{let}\ \texttt{x} : \wctype{\rwildcard{X}}{List}{\rwildcard{X}} = \texttt{p}\ \texttt{in} \
-\texttt{clone}\generics{\rwildcard{X}}(x) : \wctype{\rwildcard{X}}{List}{\rwildcard{X}})$
+% But by substituting $\tv{p} \doteq \wctype{\rwildcard{X}}{List}{\rwildcard{X}}$ in the constraint
+% $\tv{p} \lessdotCC \exptype{List}{\wtv{x}}$ leads to
+% $\wctype{\rwildcard{X}}{List}{\rwildcard{X}} \lessdotCC \exptype{List}{\wtv{x}}$.
 
-Inside the let statement the variable \texttt{x} has the type $\exptype{List}{\rwildcard{X}}$
+% To make this typing possible we have to introduce a capture conversion via a let statement:
+% $\texttt{return}\ (\texttt{let}\ \texttt{x} : \wctype{\rwildcard{X}}{List}{\rwildcard{X}} = \texttt{p}\ \texttt{in} \
+% \texttt{clone}\generics{\rwildcard{X}}(x) : \wctype{\rwildcard{X}}{List}{\rwildcard{X}})$
+
+% Inside the let statement the variable \texttt{x} has the type $\exptype{List}{\rwildcard{X}}$
 
 
-This spawns additional problems.
+% This spawns additional problems.
 
-\begin{figure} 
-\begin{minipage}{0.45\textwidth}
-\begin{verbatim}
-<X> List<X> clone(List<X> l){...}
+% \begin{figure} 
+% \begin{minipage}{0.45\textwidth}
+% \begin{verbatim}
+% <X> List<X> clone(List<X> l){...}
 
-example(p){
-  return clone(p);
-}
-\end{verbatim}
-  \end{minipage}%
-  \hfill
-  \begin{minipage}{0.35\textwidth}
-\begin{constraintset}
-    \textbf{Constraints:}\\
-    $
-  \tv{p} \lessdotCC \exptype{List}{\wtv{x}}, \\
-\tv{p} \lessdot \tv{r}, \\
-\tv{p} \lessdot \type{Object}, 
-\tv{r} \lessdot \type{Object}
-    $
-\end{constraintset}
-  \end{minipage}
+% example(p){
+%   return clone(p);
+% }
+% \end{verbatim}
+%   \end{minipage}%
+%   \hfill
+%   \begin{minipage}{0.35\textwidth}
+% \begin{constraintset}
+%     \textbf{Constraints:}\\
+%     $
+%   \tv{p} \lessdotCC \exptype{List}{\wtv{x}}, \\
+% \tv{p} \lessdot \tv{r}, \\
+% \tv{p} \lessdot \type{Object}, 
+% \tv{r} \lessdot \type{Object}
+%     $
+% \end{constraintset}
+%   \end{minipage}
 
-\caption{Type inference example}\label{fig:ccExample}
-\end{figure}
+% \caption{Type inference example}\label{fig:ccExample}
+% \end{figure}
 
-In addition with free variables this leads to unwanted behaviour.
-Take the constraint
-$\wctype{\rwildcard{X}}{List}{\rwildcard{X}} \lessdot \exptype{List}{\wtv{a}}$ for example.
-After a capture conversion from $\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$ to $\exptype{List}{\rwildcard{Y}}$ and a substitution $\wtv{a} \doteq \rwildcard{Y}$
-we get
-$\exptype{List}{\rwildcard{Y}} \lessdot \exptype{List}{\rwildcard{Y}}$.
-Which is correct if we apply capture conversion to the left side:
-$\exptype{List}{\rwildcard{X}} <: \exptype{List}{\rwildcard{X}}$
-If the input constraints did not intend for this constraint to undergo a capture conversion then \unify{} would produce an invalid
-type solution due to:
-$\wctype{\rwildcard{X}}{List}{\rwildcard{X}} \nless: \exptype{List}{\rwildcard{X}}$
-The reason for this is the \texttt{S-Exists} rule's premise
-$\text{dom}(\Delta') \cap \text{fv}(\exptype{List}{\rwildcard{X}}) = \emptyset$.
+% In addition with free variables this leads to unwanted behaviour.
+% Take the constraint
+% $\wctype{\rwildcard{X}}{List}{\rwildcard{X}} \lessdot \exptype{List}{\wtv{a}}$ for example.
+% After a capture conversion from $\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$ to $\exptype{List}{\rwildcard{Y}}$ and a substitution $\wtv{a} \doteq \rwildcard{Y}$
+% we get
+% $\exptype{List}{\rwildcard{Y}} \lessdot \exptype{List}{\rwildcard{Y}}$.
+% Which is correct if we apply capture conversion to the left side:
+% $\exptype{List}{\rwildcard{X}} <: \exptype{List}{\rwildcard{X}}$
+% If the input constraints did not intend for this constraint to undergo a capture conversion then \unify{} would produce an invalid
+% type solution due to:
+% $\wctype{\rwildcard{X}}{List}{\rwildcard{X}} \nless: \exptype{List}{\rwildcard{X}}$
+% The reason for this is the \texttt{S-Exists} rule's premise
+% $\text{dom}(\Delta') \cap \text{fv}(\exptype{List}{\rwildcard{X}}) = \emptyset$.
 
-Additionally free variables are not allowed to leave the scope of a capture conversion
-introduced by a let statement.
-%TODO we combat both of this with wildcard type placeholders (? flag)
-
-Type placeholders which are not flagged as possible free variables ($\wtv{a}$) can never hold a free variable or a type containing free variables.
-Constraint generation places these standard place holders at method return types and parameter types.
-\begin{lstlisting}[style=fgj]
-<X> List<X> clone(List<X> l);
-(*@$\red{\tv{r}}$@*) example((*@$\red{\tv{p}}$@*) p){
-  return clone(p);
-}
-\end{lstlisting}
-This prevents type solutions that contain free variables in parameter and return types.
-When calling a method which already has a type annotation we have to consider adding a capture conversion in form of a let statement.
-The constraint $\tv{p} \lessdot \exptype{List}{\wtv{x}}$ signals the \unify{} algorithm that here a capture conversion is possible.
-$\sigma(\tv{p}) = \wctype{\rwildcard{X}}{List}{\rwildcard{X}}, \sigma(\tv{r}) = \wctype{\rwildcard{X}}{List}{\rwildcard{X}}, $ is a possible solution.
-But only when adding a capture conversion:
-\begin{lstlisting}[style=fgj]
-<X> List<X> clone(List<X> l);
-(*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*) example((*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*) p){
-  return let x : (*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*) = p in clone(x) : (*@$\wctype{\rwildcard{X}}{List}{\rwildcard{X}}$@*);
-}
-\end{lstlisting}
-
-Capture constraints cannot be stored in a set.
-$\wtv{a} \lessdotCC \wtv{b}$ is not the same as $\wtv{a} \lessdotCC \wtv{b}$.
-Both constraints will end up the same after a substitution for both placeholders $\tv{a}$ and $\tv{b}$.
-But afterwards a capture conversion is applied, which can generate different types on the left sides.
-\begin{itemize}
-  \item $\text{CC}(\wctype{\rwildcard{X}}{List}{\rwildcard{X}}) \implies \exptype{List}{\rwildcard{Y}}$ 
-  \item $\text{CC}(\wctype{\rwildcard{X}}{List}{\rwildcard{X}}) \implies \exptype{List}{\rwildcard{Z}}$ 
-\end{itemize}
+% Capture constraints cannot be stored in a set.
+% $\wtv{a} \lessdotCC \wtv{b}$ is not the same as $\wtv{a} \lessdotCC \wtv{b}$.
+% Both constraints will end up the same after a substitution for both placeholders $\tv{a}$ and $\tv{b}$.
+% But afterwards a capture conversion is applied, which can generate different types on the left sides.
+% \begin{itemize}
+%   \item $\text{CC}(\wctype{\rwildcard{X}}{List}{\rwildcard{X}}) \implies \exptype{List}{\rwildcard{Y}}$ 
+%   \item $\text{CC}(\wctype{\rwildcard{X}}{List}{\rwildcard{X}}) \implies \exptype{List}{\rwildcard{Z}}$ 
+% \end{itemize}
+% 
+% Wildcards are not reflexive. A box of type $\wctype{\rwildcard{X}}{Box}{\rwildcard{X}}$
+% is able to hold a value of any type. It could be a $\exptype{Box}{String}$ or a $\exptype{Box}{Integer}$ etc.
+% Also two of those boxes do not necessarily contain the same type.
+% But there are situations where it is possible to assume that.
+% For example the type $\wctype{\rwildcard{X}}{Pair}{\exptype{Box}{\rwildcard{X}}, \exptype{Box}{\rwildcard{X}}}$
+% is a pair of two boxes, which always contain the same type.
+% Inside the scope of the \texttt{Pair} type, the wildcard $\rwildcard{X}$ stays the same.

martin.bib

@@ -428,3 +428,41 @@ numpages = {20},
 keywords = {wildcards, union types, type inference, type argument inference, subtyping, polymorphic methods, parameterized types, intersection types, generics, bounded quantification}
 }
 
+@article{FJ,
+author = {Igarashi, Atsushi and Pierce, Benjamin C. and Wadler, Philip},
+title = {Featherweight Java: a minimal core calculus for Java and GJ},
+year = {2001},
+issue_date = {May 2001},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+volume = {23},
+number = {3},
+issn = {0164-0925},
+url = {https://doi.org/10.1145/503502.503505},
+doi = {10.1145/503502.503505},
+abstract = {Several recent studies have introduced lightweight versions of Java: reduced languages in which complex features like threads and reflection are dropped to enable rigorous arguments about key properties such as type safety. We carry this process a step further, omitting almost all features of the full language (including interfaces and even assignment) to obtain a small calculus, Featherweight Java, for which rigorous proofs are not only possible but easy. Featherweight Java bears a similar relation to Java as the lambda-calculus does to languages such as ML and Haskell. It offers a similar computational "feel," providing classes, methods, fields, inheritance, and dynamic typecasts with a semantics closely following Java's. A proof of type safety for Featherweight Java thus illustrates many of the interesting features of a safety proof for the full language, while remaining pleasingly compact. The minimal syntax, typing rules, and operational semantics of Featherweight Java make it a handy tool for studying the consequences of extensions and variations. As an illustration of its utility in this regard, we extend Featherweight Java with generic classes in the style of GJ (Bracha, Odersky, Stoutamire, and Wadler) and give a detailed proof of type safety. The extended system formalizes for the first time some of the key features of GJ.},
+journal = {ACM Trans. Program. Lang. Syst.},
+month = {may},
+pages = {396–450},
+numpages = {55},
+keywords = {Compilation, Java, generic classes, language design, language semantics}
+}
+
+@inproceedings{principalTypes,
+  title={What are principal typings and what are they good for?},
+  author={Jim, Trevor},
+  booktitle={Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages},
+  pages={42--53},
+  year={1996}
+}
+
+@article{aNormalForm,
+  title={Reasoning about programs in continuation-passing style.},
+  author={Sabry, Amr and Felleisen, Matthias},
+  journal={ACM SIGPLAN Lisp Pointers},
+  number={1},
+  pages={288--298},
+  year={1992},
+  publisher={ACM New York, NY, USA}
+}
+

prolog.tex

@@ -13,12 +13,15 @@
 }
 \lstdefinestyle{fgj}{backgroundcolor=\color{lime!20}}
 \lstdefinestyle{tfgj}{backgroundcolor=\color{lightgray!20}}
-\lstdefinestyle{letfj}{backgroundcolor=\color{lightgray!20}}
+\lstdefinestyle{letfj}{backgroundcolor=\color{lime!20}}
+\lstdefinestyle{tamedfj}{backgroundcolor=\color{yellow!20}}
+\lstdefinestyle{java}{backgroundcolor=\color{lightgray!20}}
 
 \newtheorem{recap}[note]{Recap}
 
 \newcommand{\tifj}{\texttt{TamedFJ}}
 
+\newcommand{\wcSep}{\vdash}
 \newcommand\mv[1]{{\tt #1}}
 \newcommand{\ol}[1]{\overline{\tt #1}}
 \newcommand{\exptype}[2]{\mathtt{#1 \texttt{<} #2 \texttt{>} }}
@@ -105,6 +108,8 @@
 \newcommand{\letfj}{\emph{LetFJ}}
 \newcommand{\tph}{\text{tph}}
 
+\newcommand{\expr}[1]{\texttt{#1}}
+
 \def\exptypett#1#2{\texttt{#1}\textrm{{\tt <#2}}\textrm{{\tt >}}\xspace}
 \def\exp#1#2{#1(\,#2\,)\xspace}
 \newcommand{\ldo}{, \ldots , }
@@ -139,7 +144,6 @@
 \newcommand{\ruleSubstWC}[0]{\rulename{Subst-WC}}
 \newcommand{\subclass}{\mathtt{\sqsubset}\mkern-5mu :}
 
-\newcommand{\TameFJ}{\text{TameFJ}}
 \newcommand{\TamedFJ}{\textbf{TamedFJ}}
 \newcommand{\TYPE}{\textbf{TYPE}}
 

soundness.tex

@@ -329,18 +329,17 @@ If there is a solution for a constraint set $C$, then there is also a solution f
 % does this really work. We have to show that the algorithm never gets stuck as long as there is a solution
 % maybe there are substitutions with types containing free variables that make additional solutions possible. Check!
 
-\begin{lemma}\label{lemma:unifySoundness}
-The \unify{} algorithm only produces correct output.
+\begin{lemma}{\unify{} Soundness:}\label{lemma:unifySoundness}
+\unify{}'s type solutions are correct respective to the subtyping rules defined in figure \ref{fig:subtyping}.
 \begin{description}
 \item[If] $(\sigma, \Delta) = \unify{}( \Delta', \, \overline{ \type{S} \lessdot \type{T} } \cup \overline{ \type{S'} \lessdotCC \type{T'} } )$ %\cup \overline{ \type{S} \doteq \type{S'} })$
-%\item[and] $fv(\overline{ \type{S} }) = \emptyset$, $fv(\overline{ \type{T} }) = \emptyset$
-\item[Then] there exists a $\sigma'$ with:
-$\sigma \subseteq \sigma'$ and
-$\Delta, \Delta' \vdash \overline{\sigma'(\type{S}) <: \sigma'(\type{T})}$
-and $\Delta, \Delta', \overline{\Delta} \vdash \overline{\type{N} <: \sigma'(\type{T'})}$ where $\overline{\sigma(\type{S'}) = \wcNtype{\Delta}{N}}$,
-otherwise $\Delta, \Delta' \vdash \overline{\sigma'(\type{S'}) <: \sigma'(\type{T'})}$
-% and $\sigma(\type{T'}) = \sigma(\type{T'})$.
-
+\item[Then] there exists a substitution $\sigma'$ and a set of types $\overline{\wcNtype{\Delta}{N}}$ with:
+\begin{itemize}
+\item $\sigma \subseteq \sigma'$
+\item $\Delta, \Delta' \vdash \overline{\sigma'(\type{S}) <: \sigma'(\type{T})}$
+\item $\Delta, \Delta' \vdash \overline{\sigma'(\type{S'}) <: \wcNtype{\Delta}{N}}$ 
+\item $\Delta, \Delta', \overline{\Delta} \vdash \overline{\type{N} <: \sigma'(\type{T'})}$
+\end{itemize}
 \end{description}
 \end{lemma}
 
@@ -378,6 +377,7 @@ $\Delta \vdash  \sigma(C') \implies \Delta \vdash \sigma(C)$
 \begin{description}
 \item[AddDelta] $C$ is not changed
 \item[GenDelta] by definition, S-Var-Left, and S-Trans %The generated type variable is unique due to the solved form property. %and the solved form property (no $\tv{a}$ in $C$)
+\item[GenDelta'] same as GenDelta by setting $\sigma'(\wtv{b}) = \rwildcard{B}$
 \item[GenSigma] by definition and S-Refl.
 % holds for $\set{\tv{a} \doteq \type{G}}$ by definition.
 % Holds for $C$ by assumption and because $\tv{a} \notin C$ by solved form definition ($[\type{G}/\tv{a}]C = C$).
@@ -432,7 +432,8 @@ holds with any $\Delta'$ so that $(\text{fv}(\exptype{C}{\ol{S}}) \cup \text{fv}
 \item[Circle] S-Refl
 \item[Swap] by definition
 \item[Erase] S-Refl
-\item[Equals] %by definition
+\item[Equals] by definition \ref{def:equal}
+%by definition
 %TODO
 % Unify does never contain wildcard environments with unused wildcards. Therefore after N <: N' and N' <: N, both types have the same wildcard environment
 

tRules.tex

@@ -38,6 +38,10 @@ Additional language constructs can be added by implementing the respective const
 % on overriding methods, because their type is already determined.
 % Allowing overriding therefore has no implication on our type inference algorithm.
 
+The syntax forces every expression to undergo a capture conversion before it can be used as a method argument.
+Even variables have to be catched by a let statement first.
+This behaviour emulates Java's implicit capture conversion.
+
 \begin{figure}
 $
 \begin{array}{lrcl}
@@ -47,19 +51,183 @@ $
 \text{Lower bounds} & \type{K}, \type{L} & ::= & \type{T} \mid \bot \\
 \text{Type variable contexts} &  \Delta & ::= & \overline{\wildcard{X}{T}{L}} \\
 \text{Class declarations} &  D & ::= & \texttt{class}\ \exptype{C}{\ol{X \triangleleft T}} \triangleleft \type{N} \set{\overline{\type{T}\ f}; \ol{M}} \\
-\text{Method declarations} &  \texttt{M} & ::= & \texttt{m}(\overline{x}) = t \\
-\text{Terms} & t & ::= & x \\
-& & \ \ | & \texttt{new} \ \type{C}(\overline{t})\\
-& & \ \ | & t.f\\
-& & \ \ | & t.\texttt{m}(\overline{t})\\
-& & \ \ | & t \elvis{} t\\
-\text{Variable contexts} & \Gamma & ::= & \overline{x:\type{T}}\\
+\text{Method declarations} &  \texttt{M} & ::= & \texttt{m}(\overline{\expr{x}}) = t \\
+\text{Terms} & t & ::= & \expr{x} \\
+& & \ \ | &  \texttt{let}\ \overline{\expr{x}_c} = \overline{t} \ \texttt{in}\ \texttt{new} \ \type{C}(\overline{\expr{x}_c}) \\
+& & \ \ | & \texttt{let}\ \expr{x}_c = t \ \texttt{in}\ \expr{x}_c.f \\
+& & \ \ | & \texttt{let}\ \expr{x}_c = t \ \texttt{in}\ \texttt{let}\ \overline{\expr{x}_c} = \overline{t} \ \texttt{in}\ \expr{x}_c.\texttt{m}(\overline{\expr{x}_c}) \\
+& & \ \ | & t \elvis{} t \\
+\text{Variable contexts} & \Gamma & ::= & \overline{\expr{x}:\type{T}}\\
 \hline
 \end{array}
 $
-\caption{Input Syntax}\label{fig:syntax}
+\caption{\TamedFJ{} Syntax}\label{fig:syntax}
 \end{figure}
 
+% \begin{figure}
+% $
+% \begin{array}{lrcl}
+% \hline
+% \text{Parameterized classes} & \mv N & ::= & \exptype{C}{\ol{T}} \\
+% \text{Types} & \type{S}, \type{T}, \type{U} & ::= & \type{X} \mid \wcNtype{\Delta}{N} \\
+% \text{Lower bounds} & \type{K}, \type{L} & ::= & \type{T} \mid \bot \\
+% \text{Type variable contexts} &  \Delta & ::= & \overline{\wildcard{X}{T}{L}} \\
+% \text{Class declarations} &  D & ::= & \texttt{class}\ \exptype{C}{\ol{X \triangleleft T}} \triangleleft \type{N} \set{\overline{\type{T}\ f}; \ol{M}} \\
+% \text{Method declarations} &  \texttt{M} & ::= & \texttt{m}(\overline{\expr{x}}) = t \\
+% \text{Values} & v & ::= & \expr{x} \\
+% \text{Terms} & t & ::= & v \\
+% & & \ \ | & \texttt{let} \ \expr{x} = \texttt{new} \ \type{C}(\overline{v}) \ \texttt{in} \ t \\
+% & & \ \ | & \texttt{let} \ \expr{x} = v.f \ \texttt{in} \ t \\
+% & & \ \ | & \texttt{let} \ \expr{x} = v.\texttt{m}(\overline{v}) \ \texttt{in} \ t \\
+% & & \ \ | & \texttt{let} \ \expr{x} = v \elvis{} v \ \texttt{in} \ t \\
+% \text{Variable contexts} & \Gamma & ::= & \overline{\expr{x}:\type{T}}\\
+% \hline
+% \end{array}
+% $
+% \caption{Input Syntax}\label{fig:syntax}
+% \end{figure}
+
+% \begin{figure}
+% $
+% \begin{array}{lrcl}
+% \hline
+% \text{Parameterized classes} & \mv N & ::= & \exptype{C}{\ol{T}} \\
+% \text{Types} & \type{S}, \type{T}, \type{U} & ::= & \type{X} \mid \wcNtype{\Delta}{N} \\
+% \text{Lower bounds} & \type{K}, \type{L} & ::= & \type{T} \mid \bot \\
+% \text{Type variable contexts} &  \Delta & ::= & \overline{\wildcard{X}{T}{L}} \\
+% \text{Class declarations} &  D & ::= & \texttt{class}\ \exptype{C}{\ol{X \triangleleft T}} \triangleleft \type{N} \set{\overline{\type{T}\ f}; \ol{M}} \\
+% \text{Method declarations} &  \texttt{M} & ::= & \texttt{m}(\overline{\expr{x}}) = t \\
+% \text{Terms} & t & ::= & \expr{x} \\
+% & & \ \ | & \texttt{let} \ \expr{x} = t \ \texttt{in} \ t \\
+% & & \ \ | & \expr{x}.f \\
+% & & \ \ | & \expr{x}.\texttt{m}(\overline{\expr{x}}) \\
+% & & \ \ | & t \elvis{} t \\
+% \text{Variable contexts} & \Gamma & ::= & \overline{\expr{x}:\type{T}}\\
+% \hline
+% \end{array}
+% $
+% \caption{Input Syntax}\label{fig:syntax}
+% \end{figure}
+
+
+% \begin{figure}
+% $
+% \begin{array}{lrcl}
+% \hline
+% \text{Parameterized classes} & \mv N & ::= & \exptype{C}{\ol{T}} \\
+% \text{Types} & \type{S}, \type{T}, \type{U} & ::= & \type{X} \mid \wcNtype{\Delta}{N} \\
+% \text{Lower bounds} & \type{K}, \type{L} & ::= & \type{T} \mid \bot \\
+% \text{Type variable contexts} &  \Delta & ::= & \overline{\wildcard{X}{T}{L}} \\
+% \text{Class declarations} &  D & ::= & \texttt{class}\ \exptype{C}{\ol{X \triangleleft T}} \triangleleft \type{N} \set{\overline{\type{T}\ f}; \ol{M}} \\
+% \text{Method declarations} &  \texttt{M} & ::= & \texttt{m}(\overline{x}) = t \\
+% \text{Terms} & t & ::= & x \\
+% & & \ \ | & \texttt{new} \ \type{C}(\overline{t})\\
+% & & \ \ | & t.f\\
+% & & \ \ | & t.\texttt{m}(\overline{t})\\
+% & & \ \ | & t \elvis{} t\\
+% \text{Variable contexts} & \Gamma & ::= & \overline{x:\type{T}}\\
+% \hline
+% \end{array}
+% $
+% \caption{Input Syntax}\label{fig:syntax}
+% \end{figure}
+
+\subsection{ANF transformation}
+\newcommand{\anf}[1]{\ensuremath{\tau}(#1)}
+%https://en.wikipedia.org/wiki/A-normal_form)
+Featherweight Java's syntax involves no \texttt{let} statement
+and terms can be nested freely.
+This is similar to Java's syntax.
+To convert it to \TamedFJ{} additional let statements have to be added.
+This is done by a \textit{A-Normal Form} \cite{aNormalForm} transformation shown in figure \ref{fig:anfTransformation}.
+The input of this transformation is a Featherweight Java program in the syntax given \ref{fig:inputSyntax}
+and the output is a \TamedFJ{} program.
+
+\textit{Example:}\\
+\noindent
+\begin{minipage}{0.45\textwidth}
+\begin{lstlisting}[style=fgj,caption=Featherweight Java]
+m(l, v){
+    return l.add(v);
+}
+\end{lstlisting}
+    \end{minipage}%
+    \hfill
+    \begin{minipage}{0.5\textwidth}
+\begin{lstlisting}[style=tfgj,caption=\TamedFJ{} representation]
+m(l, v) = 
+    let x1 = l in
+        let x2 = v in x1.add(x2)
+\end{lstlisting}
+\end{minipage}
+
+
+% $
+% \begin{array}{|lrcl|l}
+% \hline
+% & & & \textbf{Featherweight Java Terms}\\
+% \text{Terms} & t & ::=
+% & \expr{x}
+% \\
+% & & \ \ |
+% & \texttt{new} \ \type{C}(\overline{t})
+% \\
+% & & \ \ |
+% & t.f
+% \\
+% & & \ \ | 
+% & t.\texttt{m}(\overline{t})
+% \\
+% & & \ \ | 
+% & t \elvis{} t\\
+% %
+% \hline
+% \end{array}
+% $
+
+\begin{figure}
+    \begin{center}
+$\begin{array}{lrcl}
+%\text{ANF}
+& \anf{\expr{x}} & = & \expr{x} \\
+& \anf{\texttt{new} \ \type{C}(\overline{t})} & = & \texttt{let}\ \overline{\expr{x}} = \anf{\overline{t}} \ \texttt{in}\ \texttt{new} \ \type{C}(\overline{\expr{x}}) \\
+& \anf{t.f} & = & \texttt{let}\ \expr{x} = \anf{t} \ \texttt{in}\ \expr{x}.f \\
+& \anf{t.\texttt{m}(\overline{t})} & = & \texttt{let}\ \expr{x} = \anf{t} \ \texttt{in}\ \texttt{let}\ \overline{\expr{x}} = \anf{\overline{t}} \ \texttt{in}\ \expr{x}.\texttt{m}(\overline{\expr{x}}) \\
+& \anf{t_1 \elvis{} t_2} & = & \anf{t_1} \elvis{} \anf{t_2}
+\end{array}$
+\end{center}
+\caption{ANF Transformation}\label{fig:anfTransformation}
+\end{figure}
+
+% $
+% \begin{array}{lrcl|l}
+% \hline
+% & & & \textbf{Featherweight Java} & \textbf{A-Normal form}  \\
+% \text{Terms} & t & ::=
+% & \expr{x}
+% & \expr{x}
+% \\
+% & & \ \ |
+% & \texttt{new} \ \type{C}(\overline{t})
+% & \texttt{let}\ \overline{x} = \overline{t} \ \texttt{in}\ \texttt{new} \ \type{C}(\overline{x})
+% \\
+% & & \ \ |
+% & t.f
+% & \texttt{let}\ x = t \ \texttt{in}\ x.f
+% \\
+% & & \ \ | 
+% & t.\texttt{m}(\overline{t})
+% & \texttt{let}\ x_1 = t \ \texttt{in}\ \texttt{let}\ \overline{x} = \overline{t} \ \texttt{in}\ x_1.\texttt{m}(\overline{x})
+% \\
+% & & \ \ | 
+% & t \elvis{} t
+% & t \elvis{} t\\
+% %
+% \hline
+% \end{array}
+% $
+
+
 % Each class type has a set of wildcard types $\overline{\Delta}$ attached to it.
 % The type $\wctype{\overline{\Delta}}{C}{\ol{T}}$ defines a set of wildcards $\overline{\Delta}$,
 % which can be used inside the type parameters $\ol{T}$.
@@ -196,56 +364,118 @@ $\begin{array}{l}
 $\begin{array}{l}
     \typerule{T-Field}\\
     \begin{array}{@{}c}
-        \Delta | \Gamma \vdash \texttt{e} : \type{T} \quad \quad 
-        \Delta \vdash \type{T} <: \wcNtype{\Delta'}{N} \quad \quad
+        \Delta | \Gamma \vdash \expr{v} : \type{T} \quad \quad 
+        \Delta \vdash \type{T} <: \wcNtype{}{N} \quad \quad
         \textit{fields}(\type{N}) = \ol{U\ f} \\
-\Delta, \Delta' \vdash \type{U}_i <: \type{S} \quad \quad
-\text{dom}(\Delta') \subseteq \text{fv}(\type{N}) \quad \quad
-\Delta \vdash \type{S}, \wcNtype{\Delta'}{N} \ \ok
-        \\
         \hline
     \vspace*{-0.3cm}\\
-        \Delta | \Gamma \vdash \texttt{e}.\texttt{f}_i : \type{S}
+        \Delta | \Gamma \vdash \expr{v}.\texttt{f}_i : \type{U}_i
     \end{array}
 \end{array}$
 \\[1em]
+% $\begin{array}{l}
+%     \typerule{T-Field}\\
+%     \begin{array}{@{}c}
+%         \Delta | \Gamma \vdash \texttt{e} : \type{T} \quad \quad 
+%         \Delta \vdash \type{T} <: \wcNtype{\Delta'}{N} \quad \quad
+%         \textit{fields}(\type{N}) = \ol{U\ f} \\
+% \Delta, \Delta' \vdash \type{U}_i <: \type{S} \quad \quad
+% \text{dom}(\Delta') \subseteq \text{fv}(\type{N}) \quad \quad
+% \Delta \vdash \type{S}, \wcNtype{\Delta'}{N} \ \ok
+%         \\
+%         \hline
+%     \vspace*{-0.3cm}\\
+%         \Delta | \Gamma \vdash \texttt{e}.\texttt{f}_i : \type{S}
+%     \end{array}
+% \end{array}$
+% \\[1em]
+% $\begin{array}{l}
+%     \typerule{T-New}\\
+%     \begin{array}{@{}c}
+%         \Delta, \overline{\Delta} \vdash  \exptype{C}{\ol{T}} \ \ok \quad \quad
+%         \text{fields}(\exptype{C}{\ol{T}}) = \overline{\type{U}\ f} \quad \quad
+%         \Delta | \Gamma \vdash \overline{t : \type{S}} \quad \quad
+%         \Delta \vdash  \overline{\type{S}} <: \overline{\wcNtype{\Delta}{N}} \\
+%         \Delta, \overline{\Delta} \vdash  \overline{\type{N}} <: \overline{\type{U}} \quad \quad
+%         \Delta, \overline{\Delta} \vdash \exptype{C}{\ol{T}} <: \type{T} \quad \quad
+%         \overline{\text{dom}(\Delta) \subseteq \text{fv}(\type{N})} \quad \quad
+%         \Delta \vdash \type{T},  \overline{\wcNtype{\Delta}{N}} \ \ok
+%         \\
+%         \hline
+%     \vspace*{-0.3cm}\\
+%         \triangle | \Gamma \vdash \texttt{new}\ \type{C}(\ol{t}) : \exptype{C}{\ol{T}}
+%     \end{array}
+% \end{array}$
+% \\[1em] 
 $\begin{array}{l}
     \typerule{T-New}\\
     \begin{array}{@{}c}
         \Delta, \overline{\Delta} \vdash  \exptype{C}{\ol{T}} \ \ok \quad \quad
-        \text{fields}(\exptype{C}{\ol{T}}) = \overline{\type{U}\ f} \quad \quad
-        \Delta | \Gamma \vdash \overline{t : \type{S}} \quad \quad
-        \Delta \vdash  \overline{\type{S}} <: \overline{\wcNtype{\Delta}{N}} \\
-        \Delta, \overline{\Delta} \vdash  \overline{\type{N}} <: \overline{\type{U}} \quad \quad
-        \Delta, \overline{\Delta} \vdash \exptype{C}{\ol{T}} <: \type{T} \quad \quad
-        \overline{\text{dom}(\Delta) \subseteq \text{fv}(\type{N})} \quad \quad
-        \Delta \vdash \type{T},  \overline{\wcNtype{\Delta}{N}} \ \ok
+        \Delta \vdash  \overline{\type{S}} <: \overline{\type{U}} \\
+        \Delta | \Gamma \vdash \overline{\expr{v} : \type{S}} \quad \quad
+        \text{fields}(\exptype{C}{\ol{T}}) = \overline{\type{U}\ f} 
         \\
         \hline
     \vspace*{-0.3cm}\\
-        \triangle | \Gamma \vdash \texttt{new}\ \type{C}(\ol{t}) : \exptype{C}{\ol{T}}
+        \triangle | \Gamma \vdash \texttt{new}\ \type{C}(\ol{v}) : \exptype{C}{\ol{T}}
+    \end{array}
+\end{array}$
+\hfill
+% $\begin{array}{l}
+%     \typerule{T-Call}\\
+%     \begin{array}{@{}c}
+%         \Delta, \Delta', \overline{\Delta} \vdash \ol{\type{N}} <: [\ol{S}/\ol{X}]\ol{U} \quad \quad
+%         \generics{\ol{X \triangleleft U'}} \ol{U} \to \type{U} \in \Pi(\texttt{m}) \quad \quad
+%         \Delta, \Delta', \overline{\Delta} \vdash \ol{S} <: [\ol{S}/\ol{X}]\ol{U'}
+%         \\
+%         \Delta, \Delta', \overline{\Delta} \vdash \ol{S} \ \ok \quad \quad
+%         \Delta | \Gamma \vdash  \texttt{e}, \ol{e} : \ol{T} \quad \quad
+%         \Delta \vdash \ol{T} <: \overline{\wcNtype{\Delta}{N}}
+%         \\
+%         \Delta \vdash \type{T}, \overline{\wcNtype{\Delta}{N}} \ \ok \quad \quad
+%         \Delta, \Delta', \overline{\Delta} \vdash [\ol{S}/\ol{X}]\type{U} <: \type{T} \quad \quad
+%         \text{dom}(\Delta') \subseteq \text{fv}(\type{N}) \quad \quad
+%         \overline{\text{dom}(\Delta) \subseteq \text{fv}(\type{N})}
+%         \\
+%         \hline
+%     \vspace*{-0.3cm}\\
+%         \Delta | \Gamma \vdash \texttt{e}.\texttt{m}(\ol{e}) : \type{T}
+%     \end{array}
+% \end{array}$
+% \\[1em]
+$\begin{array}{l}
+    \typerule{T-Call}\\
+    \begin{array}{@{}c}
+        \generics{\ol{X \triangleleft U'}} \ol{U} \to \type{U} \in \Pi(\texttt{m}) \quad \quad
+        \Delta \vdash \ol{S} <: [\ol{S}/\ol{X}]\ol{U'}
+        \\
+        \Delta \vdash \ol{S} \ \ok \quad \quad
+        \Delta | \Gamma \vdash  \expr{v}, \ol{v} : \ol{T} \quad \quad
+        \Delta \vdash \ol{T} <: [\ol{S}/\ol{X}]\ol{U} 
+        \\
+        \hline
+    \vspace*{-0.3cm}\\
+        \Delta | \Gamma \vdash \expr{v}.\texttt{m}(\ol{v}) : \type{T}
     \end{array}
 \end{array}$
 \\[1em]
 $\begin{array}{l}
-    \typerule{T-Call}\\
+%TODO: why is dom(\Delta) subset of fv(N) a restriction. This excludes X,Y^X.Pair<X,Y>? 
+%TODO: we do not allow X.Pair<X,X> in the t-let (could we allow it? what about L and U being WTVs?)
+    \typerule{T-Let}\\
     \begin{array}{@{}c}
-        \Delta, \Delta', \overline{\Delta} \vdash \ol{\type{N}} <: [\ol{S}/\ol{X}]\ol{U} \quad \quad
-        \generics{\ol{X \triangleleft U'}} \ol{U} \to \type{U} \in \Pi(\texttt{m}) \quad \quad
-        \Delta, \Delta', \overline{\Delta} \vdash \ol{S} <: [\ol{S}/\ol{X}]\ol{U'}
+        \Delta | \Gamma \vdash \expr{t}_1 : \type{T}_1 \quad \quad
+        %\Delta \vdash \type{T}_1 <: \wcNtype{\Delta'}{N}
+        \Delta \vdash \type{T}_1 <: \wctype{\overline{\wildcard{X}{\type{U}}{\type{L}}}}{C}{\ol{X}}
         \\
-        \Delta, \Delta', \overline{\Delta} \vdash \ol{S} \ \ok \quad \quad
-        \Delta | \Gamma \vdash  \texttt{e}, \ol{e} : \ol{T} \quad \quad
-        \Delta \vdash \ol{T} <: \overline{\wcNtype{\Delta}{N}}
-        \\
-        \Delta \vdash \type{T}, \overline{\wcNtype{\Delta}{N}} \ \ok \quad \quad
-        \Delta, \Delta', \overline{\Delta} \vdash [\ol{S}/\ol{X}]\type{U} <: \type{T} \quad \quad
-        \text{dom}(\Delta') \subseteq \text{fv}(\type{N}) \quad \quad
-        \overline{\text{dom}(\Delta) \subseteq \text{fv}(\type{N})}
+        \Delta, \Delta' | \Gamma, \expr{x} : \wctype{}{C}{\ol{X}} \vdash \expr{t}_2 : \type{T}_2 \quad \quad
+        \Delta, \Delta' \vdash  \type{T}_2 <: \type{T} \quad \quad
+        % \text{dom}(\Delta') \subseteq \text{fv}(\type{N})  \quad \quad
+        \Delta \vdash \type{T}, \wctype{\overline{\wildcard{X}{\type{U}}{\type{L}}}}{C}{\ol{X}} \ \ok
         \\
         \hline
     \vspace*{-0.3cm}\\
-        \Delta | \Gamma \vdash \texttt{e}.\texttt{m}(\ol{e}) : \type{T}
+        \Delta | \Gamma \vdash \texttt{let}\ \expr{x} = \expr{t}_1 \ \texttt{in} \ \expr{t}_2 : \type{T}
     \end{array}
 \end{array}$
 \\[1em]
@@ -288,8 +518,7 @@ $\begin{array}{l}
 $\begin{array}{l}
     \typerule{T-Class}\\
     \begin{array}{@{}c}
-        \mathtt{\Pi}' = \mathtt{\Pi} \cup \set{ \texttt{m} : (\type{T'_m}, \ol{T_\texttt{m}}) \to \type{T}_\texttt{m} \mid \texttt{m} \in \ol{M}} \quad \quad
-        \forall \texttt{m} \in \ol{M}: \Delta \vdash \exptype{C}{\ol{X}} <: \type{T'_m}\\
+        \mathtt{\Pi}' = \mathtt{\Pi} \cup \set{ \texttt{m} : (\exptype{C}{\ol{X}}, \ol{T_\texttt{m}}) \to \type{T}_\texttt{m} \mid \texttt{m} \in \ol{M}} \\
         \mathtt{\Pi}'' = \mathtt{\Pi} \cup \set{ \texttt{m} :
             \generics{\ol{X \triangleleft \type{N}}, \ol{Y \triangleleft P}}(\exptype{C}{\ol{X}},\ol{T_\texttt{m}}) \to \type{T}_\texttt{m} \mid \texttt{m} \in \ol{M} } \\
         \triangle = \overline{\type{X} : \bot .. \type{U}} \quad \quad
@@ -335,4 +564,5 @@ $\begin{array}{l}
         \text{fields}(\exptype{C}{\ol{T}}) = \ol{U\ g}, [\ol{T}/\ol{X}]\ol{S\ f}
     \end{array}
 \end{array}$
+\caption{Field access}
 \end{figure}