Extract inner type hoisting to separate step

27 files changed, 577 insertions, 217 deletions

diff --git a/src/main/java/org/zwobble/couscous/ast/ClassNode.java b/src/main/java/org/zwobble/couscous/ast/ClassNode.java
index 3a53cfd..322a32a 100644
--- a/src/main/java/org/zwobble/couscous/ast/ClassNode.java
+++ b/src/main/java/org/zwobble/couscous/ast/ClassNode.java
@@ -9,6 +9,9 @@ import org.zwobble.couscous.util.ExtraIterables;
 import java.util.List;
 import java.util.Set;
 
+import static org.zwobble.couscous.util.ExtraLists.eagerFlatMap;
+import static org.zwobble.couscous.util.ExtraLists.list;
+
 public class ClassNode implements TypeNode {
     public static ClassNodeBuilder builder(ScalarType name) {
         return new ClassNodeBuilder(name);
@@ -24,9 +27,11 @@ public class ClassNode implements TypeNode {
         List<FieldDeclarationNode> fields,
         List<StatementNode> staticConstructor,
         ConstructorNode constructor,
-        List<MethodNode> methods)
+        List<MethodNode> methods,
+        List<TypeNode> innerTypes
+    )
     {
-        return new ClassNode(name, typeParameters, superTypes, fields, staticConstructor, constructor, methods);
+        return new ClassNode(name, typeParameters, superTypes, fields, staticConstructor, constructor, methods, innerTypes);
     }
     
     private final ScalarType name;
@@ -36,7 +41,8 @@ public class ClassNode implements TypeNode {
     private final List<StatementNode> staticConstructor;
     private final ConstructorNode constructor;
     private final List<MethodNode> methods;
-    
+    private final List<TypeNode> innerTypes;
+
     public ClassNode(
         ScalarType name,
         List<FormalTypeParameterNode> typeParameters,
@@ -44,7 +50,9 @@ public class ClassNode implements TypeNode {
         List<FieldDeclarationNode> fields,
         List<StatementNode> staticConstructor,
         ConstructorNode constructor,
-        List<MethodNode> methodNodes)
+        List<MethodNode> methodNodes,
+        List<TypeNode> innerTypes
+    )
     {
         this.name = name;
         this.typeParameters = typeParameters;
@@ -53,6 +61,7 @@ public class ClassNode implements TypeNode {
         this.staticConstructor = staticConstructor;
         this.constructor = constructor;
         methods = methodNodes;
+        this.innerTypes = innerTypes;
     }
 
     @Override
@@ -86,7 +95,12 @@ public class ClassNode implements TypeNode {
     public List<MethodNode> getMethods() {
         return methods;
     }
-    
+
+    @Override
+    public List<TypeNode> getInnerTypes() {
+        return innerTypes;
+    }
+
     public String getSimpleName() {
         return name.getSimpleName();
     }
@@ -114,7 +128,23 @@ public class ClassNode implements TypeNode {
             transformer.transformFields(fields),
             transformer.transformStatements(staticConstructor),
             transformer.transformConstructor(constructor),
-            transformer.transformMethods(methods));
+            transformer.transformMethods(methods),
+            eagerFlatMap(innerTypes, transformer::transformTypeDeclaration)
+        );
+    }
+
+    @Override
+    public TypeNode stripInnerTypes() {
+        return new ClassNode(
+            name,
+            typeParameters,
+            superTypes,
+            fields,
+            staticConstructor,
+            constructor,
+            methods,
+            list()
+        );
     }
 
     @Override
@@ -127,6 +157,7 @@ public class ClassNode implements TypeNode {
             ", staticConstructor=" + staticConstructor +
             ", constructor=" + constructor +
             ", methods=" + methods +
+            ", innerTypes=" + innerTypes +
             ')';
     }
 
@@ -143,7 +174,8 @@ public class ClassNode implements TypeNode {
         if (!fields.equals(classNode.fields)) return false;
         if (!staticConstructor.equals(classNode.staticConstructor)) return false;
         if (!constructor.equals(classNode.constructor)) return false;
-        return methods.equals(classNode.methods);
+        if (!methods.equals(classNode.methods)) return false;
+        return innerTypes.equals(classNode.innerTypes);
 
     }
 
@@ -156,6 +188,7 @@ public class ClassNode implements TypeNode {
         result = 31 * result + staticConstructor.hashCode();
         result = 31 * result + constructor.hashCode();
         result = 31 * result + methods.hashCode();
+        result = 31 * result + innerTypes.hashCode();
         return result;
     }
 }
diff --git a/src/main/java/org/zwobble/couscous/ast/ClassNodeBuilder.java b/src/main/java/org/zwobble/couscous/ast/ClassNodeBuilder.java
index 4735a2e..ec17c9b 100644
--- a/src/main/java/org/zwobble/couscous/ast/ClassNodeBuilder.java
+++ b/src/main/java/org/zwobble/couscous/ast/ClassNodeBuilder.java
@@ -24,6 +24,7 @@ public class ClassNodeBuilder {
     private List<StatementNode> staticConstructor;
     private Optional<ConstructorNode> constructor;
     private final ImmutableList.Builder<MethodNode> methods;
+    private final ImmutableList.Builder<TypeNode> innerTypes;
 
     public ClassNodeBuilder(ScalarType name) {
         this.name = name;
@@ -33,6 +34,7 @@ public class ClassNodeBuilder {
         staticConstructor = list();
         this.constructor = Optional.empty();
         this.methods = ImmutableList.builder();
+        this.innerTypes = ImmutableList.builder();
     }
 
     public ClassNodeBuilder(String name) {
@@ -119,7 +121,9 @@ public class ClassNodeBuilder {
             fields.build(),
             staticConstructor,
             constructor.orElse(ConstructorNode.DEFAULT),
-            methods.build());
+            methods.build(),
+            innerTypes.build()
+        );
     }
 
     public InterfaceNode buildInterface() {
@@ -129,7 +133,8 @@ public class ClassNodeBuilder {
             superTypes.build(),
             fields.build(),
             staticConstructor,
-            methods.build()
+            methods.build(),
+            innerTypes.build()
         );
     }
 
diff --git a/src/main/java/org/zwobble/couscous/ast/EnumNode.java b/src/main/java/org/zwobble/couscous/ast/EnumNode.java
index 92084dd..4a41a03 100644
--- a/src/main/java/org/zwobble/couscous/ast/EnumNode.java
+++ b/src/main/java/org/zwobble/couscous/ast/EnumNode.java
@@ -50,6 +50,11 @@ public class EnumNode implements TypeNode {
     }
 
     @Override
+    public List<TypeNode> getInnerTypes() {
+        return list();
+    }
+
+    @Override
     public int nodeType() {
         return NodeTypes.ENUM;
     }
@@ -67,6 +72,11 @@ public class EnumNode implements TypeNode {
     }
 
     @Override
+    public TypeNode stripInnerTypes() {
+        return this;
+    }
+
+    @Override
     public String toString() {
         return "EnumNode(" +
             "name=" + name +
diff --git a/src/main/java/org/zwobble/couscous/ast/InterfaceNode.java b/src/main/java/org/zwobble/couscous/ast/InterfaceNode.java
index c0444a4..3159d03 100644
--- a/src/main/java/org/zwobble/couscous/ast/InterfaceNode.java
+++ b/src/main/java/org/zwobble/couscous/ast/InterfaceNode.java
@@ -7,6 +7,9 @@ import org.zwobble.couscous.types.Type;
 import java.util.List;
 import java.util.Set;
 
+import static org.zwobble.couscous.util.ExtraLists.eagerFlatMap;
+import static org.zwobble.couscous.util.ExtraLists.list;
+
 public class InterfaceNode implements TypeNode {
     public static InterfaceNode declareInterface(
         ScalarType name,
@@ -14,9 +17,11 @@ public class InterfaceNode implements TypeNode {
         Set<Type> superTypes,
         List<FieldDeclarationNode> fields,
         List<StatementNode> staticConstructor,
-        List<MethodNode> methods)
+        List<MethodNode> methods,
+        List<TypeNode> innerTypes
+    )
     {
-        return new InterfaceNode(name, typeParameters, superTypes, fields, staticConstructor, methods);
+        return new InterfaceNode(name, typeParameters, superTypes, fields, staticConstructor, methods, innerTypes);
     }
 
     private final ScalarType name;
@@ -25,6 +30,7 @@ public class InterfaceNode implements TypeNode {
     private final List<FieldDeclarationNode> fields;
     private final List<StatementNode> staticConstructor;
     private final List<MethodNode> methods;
+    private final List<TypeNode> innerTypes;
 
     private InterfaceNode(
         ScalarType name,
@@ -32,7 +38,9 @@ public class InterfaceNode implements TypeNode {
         Set<Type> superTypes,
         List<FieldDeclarationNode> fields,
         List<StatementNode> staticConstructor,
-        List<MethodNode> methods)
+        List<MethodNode> methods,
+        List<TypeNode> innerTypes
+    )
     {
         this.name = name;
         this.typeParameters = typeParameters;
@@ -40,6 +48,7 @@ public class InterfaceNode implements TypeNode {
         this.fields = fields;
         this.staticConstructor = staticConstructor;
         this.methods = methods;
+        this.innerTypes = innerTypes;
     }
 
     @Override
@@ -71,6 +80,11 @@ public class InterfaceNode implements TypeNode {
     }
 
     @Override
+    public List<TypeNode> getInnerTypes() {
+        return innerTypes;
+    }
+
+    @Override
     public int nodeType() {
         return NodeTypes.INTERFACE;
     }
@@ -88,7 +102,22 @@ public class InterfaceNode implements TypeNode {
             transformer.transformTypes(superTypes),
             transformer.transformFields(fields),
             transformer.transformStatements(staticConstructor),
-            transformer.transformMethods(methods));
+            transformer.transformMethods(methods),
+            eagerFlatMap(innerTypes, transformer::transformTypeDeclaration)
+        );
+    }
+
+    @Override
+    public TypeNode stripInnerTypes() {
+        return new InterfaceNode(
+            name,
+            typeParameters,
+            superTypes,
+            fields,
+            staticConstructor,
+            methods,
+            list()
+        );
     }
 
     @Override
@@ -100,6 +129,7 @@ public class InterfaceNode implements TypeNode {
             ", fields=" + fields +
             ", staticConstructor=" + staticConstructor +
             ", methods=" + methods +
+            ", innerTypes=" + innerTypes +
             ')';
     }
 
@@ -115,7 +145,8 @@ public class InterfaceNode implements TypeNode {
         if (!superTypes.equals(that.superTypes)) return false;
         if (!fields.equals(that.fields)) return false;
         if (!staticConstructor.equals(that.staticConstructor)) return false;
-        return methods.equals(that.methods);
+        if (!methods.equals(that.methods)) return false;
+        return innerTypes.equals(that.innerTypes);
 
     }
 
@@ -127,6 +158,7 @@ public class InterfaceNode implements TypeNode {
         result = 31 * result + fields.hashCode();
         result = 31 * result + staticConstructor.hashCode();
         result = 31 * result + methods.hashCode();
+        result = 31 * result + innerTypes.hashCode();
         return result;
     }
 }
diff --git a/src/main/java/org/zwobble/couscous/ast/TypeNode.java b/src/main/java/org/zwobble/couscous/ast/TypeNode.java
index 9aa9cfb..01b033b 100644
--- a/src/main/java/org/zwobble/couscous/ast/TypeNode.java
+++ b/src/main/java/org/zwobble/couscous/ast/TypeNode.java
@@ -12,5 +12,7 @@ public interface TypeNode extends Node {
     List<FormalTypeParameterNode> getTypeParameters();
     Set<Type> getSuperTypes();
     List<MethodNode> getMethods();
+    List<TypeNode> getInnerTypes();
     TypeNode transformSubtree(NodeTransformer transformer);
+    TypeNode stripInnerTypes();
 }
diff --git a/src/main/java/org/zwobble/couscous/ast/sugar/TypeDeclarationBody.java b/src/main/java/org/zwobble/couscous/ast/sugar/TypeDeclarationBody.java
index 381c521..99b7c06 100644
--- a/src/main/java/org/zwobble/couscous/ast/sugar/TypeDeclarationBody.java
+++ b/src/main/java/org/zwobble/couscous/ast/sugar/TypeDeclarationBody.java
@@ -19,6 +19,7 @@ public class TypeDeclarationBody {
         private final ImmutableList.Builder<StatementNode> instanceInitializers = ImmutableList.builder();
         private ConstructorNode constructor = ConstructorNode.DEFAULT;
         private final ImmutableList.Builder<MethodNode> methods = ImmutableList.builder();
+        private final ImmutableList.Builder<TypeNode> innerTypes = ImmutableList.builder();
 
         private Builder() {
         }
@@ -43,6 +44,10 @@ public class TypeDeclarationBody {
             this.methods.add(method);
         }
 
+        public void addInnerType(TypeNode typeDeclaration) {
+            this.innerTypes.add(typeDeclaration);
+        }
+
         public TypeDeclarationBody build() {
             return new TypeDeclarationBody(
                 fields.build(),
@@ -50,7 +55,9 @@ public class TypeDeclarationBody {
                 ConstructorNode.constructor(
                     constructor.getArguments(),
                     ExtraLists.concat(instanceInitializers.build(), constructor.getBody())),
-                methods.build());
+                methods.build(),
+                innerTypes.build()
+            );
         }
     }
 
@@ -58,16 +65,21 @@ public class TypeDeclarationBody {
     private final List<StatementNode> staticConstructor;
     private final ConstructorNode constructor;
     private final List<MethodNode> methods;
+    private final List<TypeNode> innerTypes;
 
     public TypeDeclarationBody(
         List<FieldDeclarationNode> fields,
-        List<StatementNode> staticConstructor, ConstructorNode constructor,
-        List<MethodNode> methods)
+        List<StatementNode> staticConstructor,
+        ConstructorNode constructor,
+        List<MethodNode> methods,
+        List<TypeNode> innerTypes
+    )
     {
         this.fields = fields;
         this.staticConstructor = staticConstructor;
         this.constructor = constructor;
         this.methods = methods;
+        this.innerTypes = innerTypes;
     }
 
     public List<FieldDeclarationNode> getFields() {
@@ -85,4 +97,8 @@ public class TypeDeclarationBody {
     public List<MethodNode> getMethods() {
         return methods;
     }
+
+    public List<TypeNode> getInnerTypes() {
+        return innerTypes;
+    }
 }
diff --git a/src/main/java/org/zwobble/couscous/backends/csharp/CsharpCodeGenerator.java b/src/main/java/org/zwobble/couscous/backends/csharp/CsharpCodeGenerator.java
index 47a7635..260d7ec 100644
--- a/src/main/java/org/zwobble/couscous/backends/csharp/CsharpCodeGenerator.java
+++ b/src/main/java/org/zwobble/couscous/backends/csharp/CsharpCodeGenerator.java
@@ -7,6 +7,7 @@ import org.zwobble.couscous.backends.csharp.primitives.CsharpPrimitiveMethods;
 import org.zwobble.couscous.backends.naming.Naming;
 import org.zwobble.couscous.transforms.DesugarForEachToFor;
 import org.zwobble.couscous.transforms.DesugarForToWhile;
+import org.zwobble.couscous.transforms.HoistNestedTypes;
 import org.zwobble.couscous.transforms.SplitStaticsFromInterface;
 import org.zwobble.couscous.types.*;
 
@@ -56,7 +57,7 @@ public class CsharpCodeGenerator {
                     CsharpPrimitiveMethods.TRANSFORMER,
                     nodeTransformer
                 ),
-                types
+                HoistNestedTypes.hoist(types)
             )
         );
     }
diff --git a/src/main/java/org/zwobble/couscous/backends/csharp/CsharpSerializer.java b/src/main/java/org/zwobble/couscous/backends/csharp/CsharpSerializer.java
index 4ddeb7c..c2fa029 100644
--- a/src/main/java/org/zwobble/couscous/backends/csharp/CsharpSerializer.java
+++ b/src/main/java/org/zwobble/couscous/backends/csharp/CsharpSerializer.java
@@ -596,7 +596,7 @@ public class CsharpSerializer {
     }
 
     private void writeInNamespace(TypeNode typeNode, Action writeBody) {
-        writeInNamespace(typeNode.getName().getPackage().get(), writeBody);
+        writeInNamespace(typeNode.getName().getQualifier().get(), writeBody);
     }
 
     private void writeInNamespace(String namespace, Action writeBody) {
diff --git a/src/main/java/org/zwobble/couscous/backends/python/PythonBackend.java b/src/main/java/org/zwobble/couscous/backends/python/PythonBackend.java
index 5b6e819..6509fc4 100644
--- a/src/main/java/org/zwobble/couscous/backends/python/PythonBackend.java
+++ b/src/main/java/org/zwobble/couscous/backends/python/PythonBackend.java
@@ -8,6 +8,7 @@ import org.zwobble.couscous.ast.visitors.NodeTransformer;
 import org.zwobble.couscous.transforms.DesugarForEachToFor;
 import org.zwobble.couscous.transforms.DesugarForToWhile;
 import org.zwobble.couscous.transforms.DesugarSwitchToIfElse;
+import org.zwobble.couscous.transforms.HoistNestedTypes;
 
 import java.io.File;
 import java.io.IOException;
@@ -50,13 +51,15 @@ public class PythonBackend implements Backend {
     }
 
     private List<TypeNode> desugar(List<TypeNode> classes) {
-        return NodeTransformer.applyAll(
-            list(
-                DesugarSwitchToIfElse.transformer(),
-                DesugarForEachToFor.transformer(),
-                DesugarForToWhile.transformer()
-            ),
-            classes
+        return HoistNestedTypes.hoist(
+            NodeTransformer.applyAll(
+                list(
+                    DesugarSwitchToIfElse.transformer(),
+                    DesugarForEachToFor.transformer(),
+                    DesugarForToWhile.transformer()
+                ),
+                classes
+            )
         );
     }
 
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/AnonymousType.java b/src/main/java/org/zwobble/couscous/frontends/java/AnonymousType.java
index 845c6f9..5d5915d 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/AnonymousType.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/AnonymousType.java
@@ -2,6 +2,8 @@ package org.zwobble.couscous.frontends.java;
 
 import org.zwobble.couscous.types.Type;
 
+import java.util.function.Function;
+
 public class AnonymousType implements Type {
     public static Type anonymousType(String key) {
         return new AnonymousType(key);
@@ -19,6 +21,11 @@ public class AnonymousType implements Type {
     }
 
     @Override
+    public Type transformSubTypes(Function<Type, Type> transform) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/FreeVariables.java b/src/main/java/org/zwobble/couscous/frontends/java/FreeVariables.java
index b904f0d..7679431 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/FreeVariables.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/FreeVariables.java
@@ -14,8 +14,6 @@ import java.util.stream.Stream;
 import static org.zwobble.couscous.ast.structure.NodeStructure.descendantNodesAndSelf;
 import static org.zwobble.couscous.util.Casts.tryCast;
 import static org.zwobble.couscous.util.ExtraIterables.iterable;
-import static org.zwobble.couscous.util.ExtraIterables.lazyFlatMap;
-import static org.zwobble.couscous.util.ExtraLists.list;
 import static org.zwobble.couscous.util.ExtraStreams.toStream;
 
 public class FreeVariables {
@@ -50,32 +48,52 @@ public class FreeVariables {
         }
     }
 
+    public static class FindDeclaredTypes {
+        private static final Function<Node, Stream<TypeParameter>> VISITOR =
+            DynamicNodeMapper.instantiate(new FindDeclaredTypes(), "visit");
+
+        public Stream<TypeParameter> visit(Node node) {
+            return Stream.empty();
+        }
+
+        public Stream<TypeParameter> visit(MethodNode methodNode) {
+            return methodNode.getTypeParameters().stream().map(parameter -> parameter.getType());
+        }
+    }
+
     public static Set<TypeParameter> findFreeTypeParameters(Node root) {
+        // TODO: test removal of declared types
+        Set<TypeParameter> declaredTypes = descendantNodesAndSelf(root)
+            .flatMap(FindDeclaredTypes.VISITOR)
+            .collect(Collectors.toSet());
+
         // TODO: this assumes that *all* type parameters are free, which is often but not always true in inner types
-        Iterable<Type> types = iterable(() -> descendantNodesAndSelf(root)
-            .flatMap(FindReferencedTypes.VISITOR));
-
-        return ImmutableSet.copyOf(lazyFlatMap(types, type -> type.accept(new Type.Visitor<Iterable<TypeParameter>>() {
-            @Override
-            public Iterable<TypeParameter> visit(ScalarType type) {
-                return list();
-            }
-
-            @Override
-            public Iterable<TypeParameter> visit(TypeParameter parameter) {
-                return list(parameter);
-            }
-
-            @Override
-            public Iterable<TypeParameter> visit(ParameterizedType type) {
-                return lazyFlatMap(type.getParameters(), parameter -> parameter.accept(this));
-            }
-
-            @Override
-            public Iterable<TypeParameter> visit(BoundTypeParameter type) {
-                return type.getValue().accept(this);
-            }
-        })));
+        Stream<TypeParameter> types = descendantNodesAndSelf(root)
+            .flatMap(FindReferencedTypes.VISITOR)
+            .flatMap(type -> type.accept(new Type.Visitor<Stream<TypeParameter>>() {
+                @Override
+                public Stream<TypeParameter> visit(ScalarType type) {
+                    return Stream.empty();
+                }
+
+                @Override
+                public Stream<TypeParameter> visit(TypeParameter parameter) {
+                    return Stream.of(parameter);
+                }
+
+                @Override
+                public Stream<TypeParameter> visit(ParameterizedType type) {
+                    return type.getParameters().stream().flatMap(parameter -> parameter.accept(this));
+                }
+
+                @Override
+                public Stream<TypeParameter> visit(BoundTypeParameter type) {
+                    return type.getValue().accept(this);
+                }
+            }))
+            .filter(type -> !declaredTypes.contains(type));
+
+        return ImmutableSet.copyOf(iterable(() -> types));
     }
 
     public static List<ReferenceNode> findFreeVariables(List<? extends Node> body) {
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/GeneratedClosure.java b/src/main/java/org/zwobble/couscous/frontends/java/GeneratedClosure.java
index 9bad1d2..c019cb8 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/GeneratedClosure.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/GeneratedClosure.java
@@ -40,6 +40,10 @@ public class GeneratedClosure {
             concat(capturedVariables, arguments));
     }
 
+    public boolean hasCaptures() {
+        return !capturedTypes.isEmpty() || !capturedVariables.isEmpty();
+    }
+
     private ScalarType getType() {
         return classNode.getName();
     }
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaExpressionReader.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaExpressionReader.java
index 00198a6..aa64543 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaExpressionReader.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaExpressionReader.java
@@ -290,6 +290,7 @@ public class JavaExpressionReader {
                 return methodCall(
                     thisReference(typeOf(declaringClass.getDeclaringClass())),
                     // TODO: remove duplication with JavaReader in name generation
+                    // TODO: handle this when hoisting (i.e. in HoistNestedTypes)
                     "create_" + declaringClass.getName(),
                     arguments,
                     type);
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
index 5202127..a047e9e 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaReader.java
@@ -1,8 +1,6 @@
 package org.zwobble.couscous.frontends.java;
 
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
 import org.eclipse.jdt.core.compiler.IProblem;
 import org.eclipse.jdt.core.dom.*;
 import org.zwobble.couscous.ast.*;
@@ -11,21 +9,19 @@ import org.zwobble.couscous.ast.sugar.AnonymousClass;
 import org.zwobble.couscous.ast.sugar.Lambda;
 import org.zwobble.couscous.ast.sugar.TypeDeclarationBody;
 import org.zwobble.couscous.ast.visitors.NodeTransformer;
-import org.zwobble.couscous.types.*;
+import org.zwobble.couscous.transforms.ClosureGenerator;
+import org.zwobble.couscous.types.ScalarType;
 import org.zwobble.couscous.types.Type;
 import org.zwobble.couscous.util.ExtraLists;
-import org.zwobble.couscous.util.InsertionOrderSet;
 
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import static com.google.common.collect.Iterables.concat;
 import static com.google.common.collect.Iterables.transform;
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
@@ -37,17 +33,12 @@ import static org.zwobble.couscous.ast.FieldDeclarationNode.field;
 import static org.zwobble.couscous.ast.FormalArgumentNode.formalArg;
 import static org.zwobble.couscous.ast.FormalTypeParameterNode.formalTypeParameter;
 import static org.zwobble.couscous.ast.InstanceReceiver.instanceReceiver;
-import static org.zwobble.couscous.ast.ReturnNode.returns;
 import static org.zwobble.couscous.ast.StaticReceiver.staticReceiver;
 import static org.zwobble.couscous.ast.ThisReferenceNode.thisReference;
-import static org.zwobble.couscous.ast.VariableReferenceNode.reference;
-import static org.zwobble.couscous.frontends.java.FreeVariables.findFreeTypeParameters;
-import static org.zwobble.couscous.frontends.java.FreeVariables.findFreeVariables;
 import static org.zwobble.couscous.frontends.java.JavaMethods.signature;
 import static org.zwobble.couscous.frontends.java.JavaTypes.*;
 import static org.zwobble.couscous.types.Types.erasure;
 import static org.zwobble.couscous.util.Casts.tryCast;
-import static org.zwobble.couscous.util.ExtraIterables.lazyMap;
 import static org.zwobble.couscous.util.ExtraLists.*;
 import static org.zwobble.couscous.util.ExtraMaps.map;
 
@@ -125,7 +116,8 @@ public class JavaReader {
                 superTypes,
                 body.getFields(),
                 body.getStaticConstructor(),
-                body.getMethods()
+                body.getMethods(),
+                body.getInnerTypes()
             );
         } else {
             return ClassNode.declareClass(
@@ -135,7 +127,9 @@ public class JavaReader {
                 body.getFields(),
                 body.getStaticConstructor(),
                 body.getConstructor(),
-                body.getMethods());
+                body.getMethods(),
+                body.getInnerTypes()
+            );
         }
     }
 
@@ -197,46 +191,6 @@ public class JavaReader {
             list(method));
     }
 
-    private List<StatementNode> replaceCaptureReferences(
-        ScalarType className,
-        List<StatementNode> body,
-        InsertionOrderSet<CapturedVariable> freeVariables)
-    {
-        Map<ExpressionNode, ExpressionNode> replacements = Maps.transformValues(
-            Maps.uniqueIndex(freeVariables, variable -> variable.freeVariable),
-            freeVariable -> captureAccess(className, freeVariable));
-        NodeTransformer transformer = NodeTransformer.replaceExpressions(replacements);
-        return eagerFlatMap(body, transformer::transformStatement);
-    }
-
-    private ConstructorNode buildConstructor(
-        Scope outerScope,
-        ScalarType type,
-        InsertionOrderSet<CapturedVariable> freeVariables,
-        ConstructorNode existing)
-    {
-        Scope scope = outerScope.enterConstructor();
-
-        ImmutableList.Builder<FormalArgumentNode> arguments = ImmutableList.builder();
-        ImmutableList.Builder<StatementNode> body = ImmutableList.builder();
-
-        for (CapturedVariable variable : freeVariables) {
-            FormalArgumentNode argument = scope.formalArgument(variable.field.getName(), variable.field.getType());
-            arguments.add(argument);
-            body.add(assignStatement(captureAccess(type, variable), reference(argument)));
-        }
-
-        arguments.addAll(existing.getArguments());
-        body.addAll(existing.getBody());
-
-        return new ConstructorNode(arguments.build(), body.build());
-    }
-
-    private FieldAccessNode captureAccess(ScalarType type, CapturedVariable freeVariable) {
-        FieldDeclarationNode field = freeVariable.field;
-        return fieldAccess(thisReference(type), field.getName(), field.getType());
-    }
-
     GeneratedClosure readAnonymousClass(Scope outerScope, AnonymousClassDeclaration declaration) {
         ScalarType className = generateAnonymousName(declaration);
         Scope scope = outerScope.enterClass(className);
@@ -255,61 +209,6 @@ public class JavaReader {
         return closure;
     }
 
-    private static class CapturedVariable {
-        private final ReferenceNode freeVariable;
-        private final FieldDeclarationNode field;
-
-        public CapturedVariable(ReferenceNode freeVariable, FieldDeclarationNode field) {
-            this.freeVariable = freeVariable;
-            this.field = field;
-        }
-    }
-
-    private GeneratedClosure classWithCapture(
-        Scope scope,
-        ClassNode classNode
-    ) {
-        InsertionOrderSet<org.zwobble.couscous.types.TypeParameter> freeTypeParameters = InsertionOrderSet.copyOf(
-            findFreeTypeParameters(classNode));
-
-        InsertionOrderSet<ReferenceNode> freeVariables = InsertionOrderSet.copyOf(Iterables.filter(
-            findFreeVariables(ExtraLists.concat(
-                classNode.getFields(),
-                classNode.getMethods())),
-            // TODO: check this references work correctly in anonymous classes
-            variable -> !isThisReference(classNode.getName(), variable)));
-        InsertionOrderSet<CapturedVariable> capturedVariables = InsertionOrderSet.copyOf(transform(
-            freeVariables,
-            freeVariable -> new CapturedVariable(freeVariable, fieldForCapture(freeVariable))));
-        Iterable<FieldDeclarationNode> captureFields = transform(capturedVariables, capture -> capture.field);
-
-        List<FieldDeclarationNode> fields = ImmutableList.copyOf(concat(
-            classNode.getFields(),
-            captureFields));
-
-        if (!classNode.getStaticConstructor().isEmpty()) {
-            throw new RuntimeException("Class has unexpected static constructor");
-        }
-
-        ClassNode generatedClass = new ClassNode(
-            classNode.getName(),
-            // TODO: generate fresh type parameter and replace in body
-            ExtraLists.concat(lazyMap(freeTypeParameters, parameter -> formalTypeParameter(parameter)), classNode.getTypeParameters()),
-            classNode.getSuperTypes(),
-            fields,
-            list(),
-            buildConstructor(scope, classNode.getName(), capturedVariables, classNode.getConstructor()),
-            eagerMap(classNode.getMethods(), method ->
-                method.mapBody(body -> replaceCaptureReferences(classNode.getName(), body, capturedVariables))));
-        return new GeneratedClosure(generatedClass, freeTypeParameters, freeVariables);
-    }
-
-    private boolean isThisReference(ScalarType name, ReferenceNode reference) {
-        return tryCast(ThisReferenceNode.class, reference)
-            .map(node -> node.getType().equals(name))
-            .orElse(false);
-    }
-
     private GeneratedClosure classWithCapture(
         Scope scope,
         ScalarType className,
@@ -322,7 +221,9 @@ public class JavaReader {
             anonymousClass.getFields(),
             list(),
             ConstructorNode.DEFAULT,
-            anonymousClass.getMethods());
+            anonymousClass.getMethods(),
+            list()
+        );
         if (anonymousClass.getType().isPresent()) {
             NodeTransformer nodeTransformer = NodeTransformer.replaceExpressions(map(
                 thisReference(anonymousClass.getType().get()),
@@ -330,23 +231,7 @@ public class JavaReader {
             ));
             classNode = nodeTransformer.transformClass(classNode);
         }
-        return classWithCapture(scope, classNode);
-    }
-
-    private FieldDeclarationNode fieldForCapture(ReferenceNode freeVariable) {
-        return freeVariable.accept(new ReferenceNode.Visitor<FieldDeclarationNode>() {
-            @Override
-            public FieldDeclarationNode visit(VariableReferenceNode reference) {
-                return field(reference.getReferent().getName(), reference.getType());
-            }
-
-            @Override
-            public FieldDeclarationNode visit(ThisReferenceNode thisReference) {
-                Type type = thisReference.getType();
-                String name = "this_" + erasure(type).getQualifiedName().replace(".", "__");
-                return field(name, type);
-            }
-        });
+        return ClosureGenerator.classWithCapture(scope, classNode);
     }
 
     private ScalarType generateAnonymousName(ASTNode node) {
@@ -380,39 +265,11 @@ public class JavaReader {
                 .ifPresent(field -> readField(body, scope, type, field, isInterface));
 
             tryCast(TypeDeclaration.class, declaration)
-                .ifPresent(typeDeclaration -> classes.add(readNestedTypeDeclaration(body, typeDeclaration)));
+                .ifPresent(typeDeclaration -> body.addInnerType(readTypeDeclaration(typeDeclaration)));
         }
         return body.build();
     }
 
-    private TypeNode readNestedTypeDeclaration(TypeDeclarationBody.Builder body, TypeDeclaration typeDeclaration) {
-        TypeNode typeNode = readTypeDeclaration(typeDeclaration);
-        // TODO: can we remove duplication of scope creation with readTypeDeclaration()?
-        Scope scope = topScope.enterClass(typeNode.getName());
-        return tryCast(ClassNode.class, typeNode)
-            .filter(node -> !Modifier.isStatic(typeDeclaration.getModifiers()))
-            .<TypeNode>map(node -> {
-                GeneratedClosure closure = classWithCapture(scope, node);
-//                Type type = node.getTypeParameters().isEmpty()
-//                    ? typeNode.getName()
-//                    : parameterizedType(typeNode.getName(), eagerMap(node.getTypeParameters()));
-                Type type = typeNode.getName();
-                // TODO: method type parameters
-                List<FormalArgumentNode> methodArguments = eagerMap(
-                    node.getConstructor().getArguments(),
-                    // TODO: use scope of outer class
-                    argument -> scope.formalArgument(argument.getName(), argument.getType()));
-                MethodNode method = MethodNode.builder("create_" + typeDeclaration.getName().getIdentifier())
-                    .arguments(methodArguments)
-                    .returns(type)
-                    .statement(returns(closure.generateConstructor(lazyMap(methodArguments, argument -> reference(argument)))))
-                    .build();
-                body.addMethod(method);
-                return closure.getClassNode();
-            })
-            .orElse(typeNode);
-    }
-
     private void readField(TypeDeclarationBody.Builder builder, Scope scope, ScalarType declaringType, FieldDeclaration field, boolean isInterface) {
         @SuppressWarnings("unchecked")
         List<VariableDeclarationFragment> fragments = field.fragments();
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaTypes.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaTypes.java
index aa20fc9..5d9eddd 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaTypes.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaTypes.java
@@ -47,10 +47,12 @@ public class JavaTypes {
             Identifier declaringScope = getDeclaringScope(typeBinding);
             return new TypeParameter(declaringScope, typeBinding.getName());
         }
-        ScalarType rawType = outerClass == null
-            ? ScalarType.of(typeBinding.getErasure().getQualifiedName())
-            // TODO: test for erasure of inner type name
-            : ScalarType.of(erasure(typeOf(outerClass)).getQualifiedName() + "__" + typeBinding.getErasure().getName());
+        // TODO: tidy-up
+//        ScalarType rawType = outerClass == null
+//            ? ScalarType.of(typeBinding.getErasure().getQualifiedName())
+//            // TODO: test for erasure of inner type name
+//            : ScalarType.of(erasure(typeOf(outerClass)).getQualifiedName() + "__" + typeBinding.getErasure().getName());
+        ScalarType rawType = ScalarType.of(typeBinding.getErasure().getQualifiedName());
         if (typeBinding.isParameterizedType()) {
             List<Type> typeParameters = eagerMap(
                 asList(typeBinding.getTypeArguments()),
diff --git a/src/main/java/org/zwobble/couscous/interpreter/JavaProject.java b/src/main/java/org/zwobble/couscous/interpreter/JavaProject.java
index f813faf..a85d126 100644
--- a/src/main/java/org/zwobble/couscous/interpreter/JavaProject.java
+++ b/src/main/java/org/zwobble/couscous/interpreter/JavaProject.java
@@ -10,6 +10,7 @@ import org.zwobble.couscous.interpreter.values.BoxedIntegerInterpreterValue;
 import org.zwobble.couscous.interpreter.values.InternalCouscousInterpreterValue;
 import org.zwobble.couscous.transforms.DesugarForToWhile;
 import org.zwobble.couscous.transforms.DesugarSwitchToIfElse;
+import org.zwobble.couscous.transforms.HoistNestedTypes;
 
 import java.util.List;
 
@@ -30,7 +31,9 @@ public class JavaProject {
         NodeTransformer switchTransformer = DesugarSwitchToIfElse.transformer();
         NodeTransformer forTransformer = DesugarForToWhile.transformer();
         Iterable<InterpreterType> concreteTypes = Iterables.transform(
-            NodeTransformer.applyAll(list(switchTransformer, forTransformer), classNodes),
+            HoistNestedTypes.hoist(
+                NodeTransformer.applyAll(list(switchTransformer, forTransformer), classNodes)
+            ),
             UserDefinedInterpreterType::new
         );
         return builder()
diff --git a/src/main/java/org/zwobble/couscous/transforms/ClosureGenerator.java b/src/main/java/org/zwobble/couscous/transforms/ClosureGenerator.java
new file mode 100644
index 0000000..68c0aa6
--- /dev/null
+++ b/src/main/java/org/zwobble/couscous/transforms/ClosureGenerator.java
@@ -0,0 +1,147 @@
+package org.zwobble.couscous.transforms;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Maps;
+import org.zwobble.couscous.ast.*;
+import org.zwobble.couscous.ast.visitors.NodeTransformer;
+import org.zwobble.couscous.frontends.java.GeneratedClosure;
+import org.zwobble.couscous.frontends.java.Scope;
+import org.zwobble.couscous.types.ScalarType;
+import org.zwobble.couscous.types.Type;
+import org.zwobble.couscous.types.TypeParameter;
+import org.zwobble.couscous.util.ExtraLists;
+import org.zwobble.couscous.util.InsertionOrderSet;
+
+import java.util.List;
+import java.util.Map;
+
+import static com.google.common.collect.Iterables.concat;
+import static com.google.common.collect.Iterables.transform;
+import static org.zwobble.couscous.ast.AssignmentNode.assignStatement;
+import static org.zwobble.couscous.ast.FieldAccessNode.fieldAccess;
+import static org.zwobble.couscous.ast.FieldDeclarationNode.field;
+import static org.zwobble.couscous.ast.FormalTypeParameterNode.formalTypeParameter;
+import static org.zwobble.couscous.ast.ThisReferenceNode.thisReference;
+import static org.zwobble.couscous.ast.VariableReferenceNode.reference;
+import static org.zwobble.couscous.frontends.java.FreeVariables.findFreeTypeParameters;
+import static org.zwobble.couscous.frontends.java.FreeVariables.findFreeVariables;
+import static org.zwobble.couscous.types.Types.erasure;
+import static org.zwobble.couscous.util.Casts.tryCast;
+import static org.zwobble.couscous.util.ExtraIterables.lazyMap;
+import static org.zwobble.couscous.util.ExtraLists.*;
+
+public class ClosureGenerator {
+    public static GeneratedClosure classWithCapture(
+        Scope scope,
+        ClassNode classNode
+    ) {
+        InsertionOrderSet<TypeParameter> freeTypeParameters = InsertionOrderSet.copyOf(
+            findFreeTypeParameters(classNode));
+
+        InsertionOrderSet<ReferenceNode> freeVariables = InsertionOrderSet.copyOf(Iterables.filter(
+            findFreeVariables(ExtraLists.concat(
+                classNode.getFields(),
+                classNode.getMethods())),
+            // TODO: check this references work correctly in anonymous classes
+            variable -> !isThisReference(classNode.getName(), variable)));
+        InsertionOrderSet<CapturedVariable> capturedVariables = InsertionOrderSet.copyOf(transform(
+            freeVariables,
+            freeVariable -> new CapturedVariable(freeVariable, fieldForCapture(freeVariable))));
+        Iterable<FieldDeclarationNode> captureFields = transform(capturedVariables, capture -> capture.field);
+
+        List<FieldDeclarationNode> fields = ImmutableList.copyOf(concat(
+            classNode.getFields(),
+            captureFields));
+
+        if (!classNode.getStaticConstructor().isEmpty()) {
+            throw new RuntimeException("Class has unexpected static constructor");
+        }
+
+        ClassNode generatedClass = new ClassNode(
+            classNode.getName(),
+            // TODO: generate fresh type parameter and replace in body
+            ExtraLists.concat(lazyMap(freeTypeParameters, parameter -> formalTypeParameter(parameter)), classNode.getTypeParameters()),
+            classNode.getSuperTypes(),
+            fields,
+            list(),
+            buildConstructor(scope, classNode.getName(), capturedVariables, classNode.getConstructor()),
+            eagerMap(classNode.getMethods(), method ->
+                method.mapBody(body -> replaceCaptureReferences(classNode.getName(), body, capturedVariables))),
+            list()
+        );
+        return new GeneratedClosure(generatedClass, freeTypeParameters, freeVariables);
+    }
+
+    private static boolean isThisReference(ScalarType name, ReferenceNode reference) {
+        return tryCast(ThisReferenceNode.class, reference)
+            .map(node -> node.getType().equals(name))
+            .orElse(false);
+    }
+
+    private static FieldDeclarationNode fieldForCapture(ReferenceNode freeVariable) {
+        return freeVariable.accept(new ReferenceNode.Visitor<FieldDeclarationNode>() {
+            @Override
+            public FieldDeclarationNode visit(VariableReferenceNode reference) {
+                return field(reference.getReferent().getName(), reference.getType());
+            }
+
+            @Override
+            public FieldDeclarationNode visit(ThisReferenceNode thisReference) {
+                Type type = thisReference.getType();
+                String name = "this_" + erasure(type).getQualifiedName().replace(".", "__");
+                return field(name, type);
+            }
+        });
+    }
+
+    private static List<StatementNode> replaceCaptureReferences(
+        ScalarType className,
+        List<StatementNode> body,
+        InsertionOrderSet<CapturedVariable> freeVariables)
+    {
+        Map<ExpressionNode, ExpressionNode> replacements = Maps.transformValues(
+            Maps.uniqueIndex(freeVariables, variable -> variable.freeVariable),
+            freeVariable -> captureAccess(className, freeVariable));
+        NodeTransformer transformer = NodeTransformer.replaceExpressions(replacements);
+        return eagerFlatMap(body, transformer::transformStatement);
+    }
+
+    private static ConstructorNode buildConstructor(
+        Scope outerScope,
+        ScalarType type,
+        InsertionOrderSet<CapturedVariable> freeVariables,
+        ConstructorNode existing)
+    {
+        Scope scope = outerScope.enterConstructor();
+
+        ImmutableList.Builder<FormalArgumentNode> arguments = ImmutableList.builder();
+        ImmutableList.Builder<StatementNode> body = ImmutableList.builder();
+
+        for (CapturedVariable variable : freeVariables) {
+            FormalArgumentNode argument = scope.formalArgument(variable.field.getName(), variable.field.getType());
+            arguments.add(argument);
+            body.add(assignStatement(captureAccess(type, variable), reference(argument)));
+        }
+
+        arguments.addAll(existing.getArguments());
+        body.addAll(existing.getBody());
+
+        return new ConstructorNode(arguments.build(), body.build());
+    }
+
+    private static FieldAccessNode captureAccess(ScalarType type, CapturedVariable freeVariable) {
+        FieldDeclarationNode field = freeVariable.field;
+        return fieldAccess(thisReference(type), field.getName(), field.getType());
+    }
+
+    private static class CapturedVariable {
+        private final ReferenceNode freeVariable;
+        private final FieldDeclarationNode field;
+
+        public CapturedVariable(ReferenceNode freeVariable, FieldDeclarationNode field) {
+            this.freeVariable = freeVariable;
+            this.field = field;
+        }
+    }
+}
diff --git a/src/main/java/org/zwobble/couscous/transforms/HoistNestedTypes.java b/src/main/java/org/zwobble/couscous/transforms/HoistNestedTypes.java
new file mode 100644
index 0000000..e4ff1c8
--- /dev/null
+++ b/src/main/java/org/zwobble/couscous/transforms/HoistNestedTypes.java
@@ -0,0 +1,137 @@
+package org.zwobble.couscous.transforms;
+
+import org.zwobble.couscous.ast.ClassNode;
+import org.zwobble.couscous.ast.FormalArgumentNode;
+import org.zwobble.couscous.ast.MethodNode;
+import org.zwobble.couscous.ast.TypeNode;
+import org.zwobble.couscous.ast.visitors.NodeTransformer;
+import org.zwobble.couscous.frontends.java.GeneratedClosure;
+import org.zwobble.couscous.frontends.java.Scope;
+import org.zwobble.couscous.types.ScalarType;
+import org.zwobble.couscous.types.Type;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.regex.Pattern;
+
+import static org.zwobble.couscous.ast.ReturnNode.returns;
+import static org.zwobble.couscous.ast.VariableReferenceNode.reference;
+import static org.zwobble.couscous.util.Casts.tryCast;
+import static org.zwobble.couscous.util.ExtraIterables.iterable;
+import static org.zwobble.couscous.util.ExtraIterables.lazyMap;
+import static org.zwobble.couscous.util.ExtraLists.*;
+
+public class HoistNestedTypes {
+    public static List<TypeNode> hoist(List<TypeNode> declarations) {
+        return new HoistNestedTypes().hoistTypes(declarations);
+    }
+
+    private final Scope topScope = Scope.create().temporaryPrefix("_couscous_hoist_nested_types");
+
+    private List<TypeNode> hoistTypes(List<TypeNode> declarations) {
+        Iterable<TypeNode> types = eagerFlatMap(declarations, declaration -> hoistInnerTypes(declaration));
+
+        NodeTransformer referenceTransformer = NodeTransformer.builder()
+            .transformType(this::transformType)
+            .build();
+
+        return eagerFlatMap(types, referenceTransformer::transformTypeDeclaration);
+    }
+
+    private Type transformType(Type type) {
+        if (isInnerType(type)) {
+            return hoistedTypeName((ScalarType) type);
+        } else {
+            return type.transformSubTypes(this::transformType);
+        }
+    }
+
+    private static final Pattern INNER_TYPE_QUALIFIER_REGEX = Pattern.compile(".*\\.[A-Z][^.]*$");
+
+    private boolean isInnerType(Type type) {
+        // TODO: implement separate type classes for top-level and inner types rather than using this heuristic
+
+        return tryCast(ScalarType.class, type)
+            .flatMap(scalarType -> scalarType.getQualifier())
+            .map(qualifier -> INNER_TYPE_QUALIFIER_REGEX.matcher(qualifier).matches())
+            .orElse(false);
+    }
+
+    private static Type hoistedTypeName(ScalarType type) {
+        return ScalarType.of(type.getQualifier().get() + "__" + type.getSimpleName());
+    }
+
+    private Iterable<TypeNode> hoistInnerTypes(TypeNode declaration) {
+        TypeNode type = declaration.stripInnerTypes();
+        Iterable<HoistedType> hoistedTypes = eagerMap(declaration.getInnerTypes(), this::hoistType);
+
+        return cons(
+            addMethods(type, eagerFlatMap(hoistedTypes, hoisted -> iterable(hoisted.method))),
+            lazyMap(hoistedTypes, hoisted -> hoisted.type)
+        );
+    }
+
+    private static TypeNode addMethods(TypeNode declaration, List<MethodNode> methods) {
+        if (methods.isEmpty()) {
+            return declaration;
+        } else if (declaration instanceof ClassNode) {
+            ClassNode classDeclaration = (ClassNode) declaration;
+            return new ClassNode(
+                classDeclaration.getName(),
+                classDeclaration.getTypeParameters(),
+                classDeclaration.getSuperTypes(),
+                classDeclaration.getFields(),
+                classDeclaration.getStaticConstructor(),
+                classDeclaration.getConstructor(),
+                concat(classDeclaration.getMethods(), methods),
+                classDeclaration.getInnerTypes()
+            );
+        } else {
+            throw new UnsupportedOperationException("Cannot add methods to non-class node");
+        }
+    }
+
+    private HoistedType hoistType(TypeNode typeNode) {
+        // TODO: we need to hoist inner types of the inner types, specifically *after* the initial hoist (to make closures easier to generate)
+        // TODO: can we remove duplication of scope creation with readTypeDeclaration()?
+        Scope scope = topScope.enterClass(typeNode.getName());
+        return tryCast(ClassNode.class, typeNode)
+            .flatMap(node -> {
+                // TODO: don't generate closure if not necessary (i.e. it's an explicit or implicit static inner class)
+                GeneratedClosure closure = ClosureGenerator.classWithCapture(scope, node);
+//                Type type = node.getTypeParameters().isEmpty()
+//                    ? typeNode.getName()
+//                    : parameterizedType(typeNode.getName(), eagerMap(node.getTypeParameters()));
+                if (closure.hasCaptures()) {
+                    Type type = typeNode.getName();
+                    // TODO: method type parameters
+                    List<FormalArgumentNode> methodArguments = eagerMap(
+                        node.getConstructor().getArguments(),
+                        // TODO: use scope of outer class
+                        argument -> scope.formalArgument(argument.getName(), argument.getType()));
+                    MethodNode method = MethodNode.builder("create_" + typeNode.getName().getSimpleName())
+                        .arguments(methodArguments)
+                        .returns(type)
+                        .statement(returns(closure.generateConstructor(lazyMap(methodArguments, argument -> reference(argument)))))
+                        .build();
+                    return Optional.of(new HoistedType(
+                        closure.getClassNode(),
+                        Optional.of(method)
+                    ));
+                } else {
+                    return Optional.empty();
+                }
+            })
+            .orElse(new HoistedType(typeNode, Optional.empty()));
+    }
+
+    private static class HoistedType {
+        private final TypeNode type;
+        private final Optional<MethodNode> method;
+
+        private HoistedType(TypeNode type, Optional<MethodNode> method) {
+            this.type = type;
+            this.method = method;
+        }
+    }
+}
diff --git a/src/main/java/org/zwobble/couscous/transforms/SplitStaticsFromInterface.java b/src/main/java/org/zwobble/couscous/transforms/SplitStaticsFromInterface.java
index b2c88ea..3af4042 100644
--- a/src/main/java/org/zwobble/couscous/transforms/SplitStaticsFromInterface.java
+++ b/src/main/java/org/zwobble/couscous/transforms/SplitStaticsFromInterface.java
@@ -27,7 +27,8 @@ public class SplitStaticsFromInterface {
                     interfaceNode.getFields(),
                     interfaceNode.getStaticConstructor(),
                     ConstructorNode.DEFAULT,
-                    eagerFilter(interfaceNode.getMethods(), method -> method.isStatic())
+                    eagerFilter(interfaceNode.getMethods(), method -> method.isStatic()),
+                    list()
                 ));
                 result.add(InterfaceNode.declareInterface(
                     interfaceNode.getName(),
@@ -35,7 +36,8 @@ public class SplitStaticsFromInterface {
                     interfaceNode.getSuperTypes(),
                     list(),
                     list(),
-                    eagerFilter(interfaceNode.getMethods(), method -> !method.isStatic())
+                    eagerFilter(interfaceNode.getMethods(), method -> !method.isStatic()),
+                    interfaceNode.getInnerTypes()
                 ));
             } else {
                 result.add(typeNode);
diff --git a/src/main/java/org/zwobble/couscous/types/BoundTypeParameter.java b/src/main/java/org/zwobble/couscous/types/BoundTypeParameter.java
index 8eb5f5a..4272ac7 100644
--- a/src/main/java/org/zwobble/couscous/types/BoundTypeParameter.java
+++ b/src/main/java/org/zwobble/couscous/types/BoundTypeParameter.java
@@ -1,5 +1,7 @@
 package org.zwobble.couscous.types;
 
+import java.util.function.Function;
+
 public class BoundTypeParameter implements Type {
     public static BoundTypeParameter boundTypeParameter(TypeParameter parameter, Type value) {
         return new BoundTypeParameter(parameter, value);
@@ -27,6 +29,14 @@ public class BoundTypeParameter implements Type {
     }
 
     @Override
+    public Type transformSubTypes(Function<Type, Type> transform) {
+        return new BoundTypeParameter(
+            (TypeParameter) transform.apply(parameter),
+            transform.apply(value)
+        );
+    }
+
+    @Override
     public String toString() {
         return "BoundTypeParameter(" +
             "parameter=" + parameter +
diff --git a/src/main/java/org/zwobble/couscous/types/ParameterizedType.java b/src/main/java/org/zwobble/couscous/types/ParameterizedType.java
index 7db73e0..6d4dca1 100644
--- a/src/main/java/org/zwobble/couscous/types/ParameterizedType.java
+++ b/src/main/java/org/zwobble/couscous/types/ParameterizedType.java
@@ -1,6 +1,9 @@
 package org.zwobble.couscous.types;
 
 import java.util.List;
+import java.util.function.Function;
+
+import static org.zwobble.couscous.util.ExtraLists.eagerMap;
 
 public class ParameterizedType implements Type {
     public static ParameterizedType parameterizedType(ScalarType rawType, List<Type> parameters) {
@@ -29,6 +32,14 @@ public class ParameterizedType implements Type {
     }
 
     @Override
+    public Type transformSubTypes(Function<Type, Type> transform) {
+        return new ParameterizedType(
+            (ScalarType)transform.apply(rawType),
+            eagerMap(parameters, transform)
+        );
+    }
+
+    @Override
     public String toString() {
         return "ParameterizedType(" +
             "rawType=" + rawType +
diff --git a/src/main/java/org/zwobble/couscous/types/ScalarType.java b/src/main/java/org/zwobble/couscous/types/ScalarType.java
index 136b6cb..4f77342 100644
--- a/src/main/java/org/zwobble/couscous/types/ScalarType.java
+++ b/src/main/java/org/zwobble/couscous/types/ScalarType.java
@@ -3,6 +3,7 @@ package org.zwobble.couscous.types;
 import com.google.common.base.Strings;
 
 import java.util.Optional;
+import java.util.function.Function;
 
 public class ScalarType implements Type {
     public static ScalarType of(String qualifiedName) {
@@ -29,7 +30,7 @@ public class ScalarType implements Type {
         return qualifiedName.substring(qualifiedName.lastIndexOf(".") + 1);
     }
 
-    public Optional<String> getPackage() {
+    public Optional<String> getQualifier() {
         int lastDot = qualifiedName.lastIndexOf(".");
         if (lastDot == -1) {
             return Optional.empty();
@@ -73,4 +74,9 @@ public class ScalarType implements Type {
     public <T> T accept(Visitor<T> visitor) {
         return visitor.visit(this);
     }
+
+    @Override
+    public Type transformSubTypes(Function<Type, Type> transform) {
+        return this;
+    }
 }
diff --git a/src/main/java/org/zwobble/couscous/types/Type.java b/src/main/java/org/zwobble/couscous/types/Type.java
index ad0f6fc..b5acd6d 100644
--- a/src/main/java/org/zwobble/couscous/types/Type.java
+++ b/src/main/java/org/zwobble/couscous/types/Type.java
@@ -1,5 +1,7 @@
 package org.zwobble.couscous.types;
 
+import java.util.function.Function;
+
 public interface Type {
     <T> T accept(Visitor<T> visitor);
 
@@ -9,4 +11,6 @@ public interface Type {
         T visit(ParameterizedType type);
         T visit(BoundTypeParameter type);
     }
+
+    Type transformSubTypes(Function<Type, Type> transform);
 }
diff --git a/src/main/java/org/zwobble/couscous/types/TypeParameter.java b/src/main/java/org/zwobble/couscous/types/TypeParameter.java
index 39bf46b..fd4ada4 100644
--- a/src/main/java/org/zwobble/couscous/types/TypeParameter.java
+++ b/src/main/java/org/zwobble/couscous/types/TypeParameter.java
@@ -2,6 +2,8 @@ package org.zwobble.couscous.types;
 
 import org.zwobble.couscous.ast.identifiers.Identifier;
 
+import java.util.function.Function;
+
 public class TypeParameter implements Type {
     public static TypeParameter typeParameter(Identifier declaringScope, String name) {
         return new TypeParameter(declaringScope, name);
@@ -29,6 +31,11 @@ public class TypeParameter implements Type {
     }
 
     @Override
+    public Type transformSubTypes(Function<Type, Type> transform) {
+        return this;
+    }
+
+    @Override
     public String toString() {
         return "TypeParameter(" +
             "declaringScope=" + declaringScope +
diff --git a/src/main/java/org/zwobble/couscous/util/ExtraLists.java b/src/main/java/org/zwobble/couscous/util/ExtraLists.java
index 7849ea6..b84afcd 100644
--- a/src/main/java/org/zwobble/couscous/util/ExtraLists.java
+++ b/src/main/java/org/zwobble/couscous/util/ExtraLists.java
@@ -158,4 +158,12 @@ public class ExtraLists {
     public static <T> List<T> copyOf(Iterable<T> iterable) {
         return ImmutableList.copyOf(iterable);
     }
+
+    public static <T> T getLast(T[] values) {
+        return values[values.length - 1];
+    }
+
+    public static <T> T getLast(List<T> values) {
+        return values.get(values.size() - 1);
+    }
 }
diff --git a/src/main/java/org/zwobble/couscous/util/InsertionOrderSet.java b/src/main/java/org/zwobble/couscous/util/InsertionOrderSet.java
index 4272add..8d168fc 100644
--- a/src/main/java/org/zwobble/couscous/util/InsertionOrderSet.java
+++ b/src/main/java/org/zwobble/couscous/util/InsertionOrderSet.java
@@ -20,8 +20,14 @@ public interface InsertionOrderSet<T> extends Iterable<T> {
             public Iterator<T> iterator() {
                 return list.iterator();
             }
+
+            @Override
+            public boolean isEmpty() {
+                return list.isEmpty();
+            }
         };
     }
 
     List<T> asList();
+    boolean isEmpty();
 }
diff --git a/src/test/java/org/zwobble/couscous/tests/frontends/java/FreeVariablesTests.java b/src/test/java/org/zwobble/couscous/tests/frontends/java/FreeVariablesTests.java
index 8bcf38d..0af0020 100644
--- a/src/test/java/org/zwobble/couscous/tests/frontends/java/FreeVariablesTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/frontends/java/FreeVariablesTests.java
@@ -1,22 +1,27 @@
 package org.zwobble.couscous.tests.frontends.java;
 
 import org.junit.Test;
-import org.zwobble.couscous.ast.ReferenceNode;
-import org.zwobble.couscous.ast.VariableDeclaration;
+import org.zwobble.couscous.ast.*;
+import org.zwobble.couscous.frontends.java.FreeVariables;
 import org.zwobble.couscous.tests.TestIds;
+import org.zwobble.couscous.types.Type;
+import org.zwobble.couscous.types.TypeParameter;
 import org.zwobble.couscous.types.Types;
 
 import java.util.List;
+import java.util.Set;
 
 import static java.util.Collections.emptyList;
 import static org.junit.Assert.assertEquals;
 import static org.zwobble.couscous.ast.FormalArgumentNode.formalArg;
+import static org.zwobble.couscous.ast.FormalTypeParameterNode.formalTypeParameter;
 import static org.zwobble.couscous.ast.LiteralNode.literal;
 import static org.zwobble.couscous.ast.LocalVariableDeclarationNode.localVariableDeclaration;
 import static org.zwobble.couscous.ast.VariableDeclaration.var;
 import static org.zwobble.couscous.ast.VariableReferenceNode.reference;
 import static org.zwobble.couscous.frontends.java.FreeVariables.findFreeVariables;
 import static org.zwobble.couscous.util.ExtraLists.list;
+import static org.zwobble.couscous.util.ExtraSets.set;
 
 public class FreeVariablesTests {
     @Test
@@ -43,4 +48,27 @@ public class FreeVariablesTests {
                 reference(declaration)));
         assertEquals(emptyList(), freeVariables);
     }
+
+    @Test
+    public void typeParameterIsFreeIfThereIsNoAssociatedDeclaration() {
+        TypeParameter typeParameter = new TypeParameter(TestIds.ANY_ID, "T");
+        MethodNode method = MethodNode.builder("f").argument(argOfType(typeParameter)).build();
+        Set<TypeParameter> freeTypeParameters = FreeVariables.findFreeTypeParameters(method);
+        assertEquals(set(typeParameter), freeTypeParameters);
+    }
+
+    @Test
+    public void typeParameterIsNotFreeIfItIsDeclared() {
+        TypeParameter typeParameter = new TypeParameter(TestIds.ANY_ID, "T");
+        MethodNode method = MethodNode.builder("f")
+            .typeParameter(formalTypeParameter(typeParameter))
+            .argument(argOfType(typeParameter))
+            .build();
+        Set<TypeParameter> freeTypeParameters = FreeVariables.findFreeTypeParameters(method);
+        assertEquals(set(), freeTypeParameters);
+    }
+
+    private FormalArgumentNode argOfType(Type type) {
+        return FormalArgumentNode.formalArg(var(TestIds.variable("x"), "x", type));
+    }
 }