Allow IWorkingCopyTransformers to remove elements

Until now the transformers could only modify java elements. Sometimes it
 is needed to completely remove elements which is now possible using the
  remove() method.

33 files changed, 632 insertions, 319 deletions

diff --git a/org.eclipse.scout.sdk.core.ecj/src/main/java/org/eclipse/scout/sdk/core/model/ecj/metavalue/MetaValueFactory.java b/org.eclipse.scout.sdk.core.ecj/src/main/java/org/eclipse/scout/sdk/core/model/ecj/metavalue/MetaValueFactory.java
index 9ed8b83a5..9624f7261 100644
--- a/org.eclipse.scout.sdk.core.ecj/src/main/java/org/eclipse/scout/sdk/core/model/ecj/metavalue/MetaValueFactory.java
+++ b/org.eclipse.scout.sdk.core.ecj/src/main/java/org/eclipse/scout/sdk/core/model/ecj/metavalue/MetaValueFactory.java
@@ -10,12 +10,15 @@
  */
 package org.eclipse.scout.sdk.core.model.ecj.metavalue;
 
+import java.util.stream.Stream;
+
 import org.eclipse.jdt.internal.compiler.impl.Constant;
 import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
 import org.eclipse.scout.sdk.core.model.api.AbstractMetaValue;
 import org.eclipse.scout.sdk.core.model.api.ArrayMetaValue;
 import org.eclipse.scout.sdk.core.model.api.IAnnotation;
 import org.eclipse.scout.sdk.core.model.api.IField;
+import org.eclipse.scout.sdk.core.model.api.IJavaElement;
 import org.eclipse.scout.sdk.core.model.api.IMetaValue;
 import org.eclipse.scout.sdk.core.model.api.IType;
 import org.eclipse.scout.sdk.core.model.api.MetaValueType;
@@ -152,6 +155,11 @@ public final class MetaValueFactory {
       }
 
       @Override
+      public Stream<IJavaElement> children() {
+        return Stream.of(as(IAnnotation.class));
+      }
+
+      @Override
       protected Object getInternalObject(Class<?> expectedType) {
         if (IAnnotation.class == expectedType || Object.class == expectedType) {
           return a.wrap();
diff --git a/org.eclipse.scout.sdk.core.s/src/main/java/org/eclipse/scout/sdk/core/s/jaxws/WebServiceClientGenerator.java b/org.eclipse.scout.sdk.core.s/src/main/java/org/eclipse/scout/sdk/core/s/jaxws/WebServiceClientGenerator.java
index 001e3b4a0..be831a861 100644
--- a/org.eclipse.scout.sdk.core.s/src/main/java/org/eclipse/scout/sdk/core/s/jaxws/WebServiceClientGenerator.java
+++ b/org.eclipse.scout.sdk.core.s/src/main/java/org/eclipse/scout/sdk/core/s/jaxws/WebServiceClientGenerator.java
@@ -19,10 +19,12 @@ import org.eclipse.scout.sdk.core.generator.annotation.AnnotationGenerator;
 import org.eclipse.scout.sdk.core.generator.method.IMethodGenerator;
 import org.eclipse.scout.sdk.core.generator.method.MethodGenerator;
 import org.eclipse.scout.sdk.core.generator.method.MethodOverrideGenerator;
+import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.ITransformInput;
 import org.eclipse.scout.sdk.core.generator.transformer.SimpleWorkingCopyTransformerBuilder;
 import org.eclipse.scout.sdk.core.generator.type.ITypeGenerator;
 import org.eclipse.scout.sdk.core.generator.type.PrimaryTypeGenerator;
 import org.eclipse.scout.sdk.core.generator.type.TypeGenerator;
+import org.eclipse.scout.sdk.core.model.api.IMethod;
 import org.eclipse.scout.sdk.core.s.IScoutRuntimeTypes;
 import org.eclipse.scout.sdk.core.s.ISdkProperties;
 import org.eclipse.scout.sdk.core.s.builder.java.body.ScoutMethodBodyBuilder;
@@ -56,8 +58,8 @@ public class WebServiceClientGenerator<TYPE extends WebServiceClientGenerator<TY
   }
 
   @SuppressWarnings("MethodMayBeStatic")
-  protected IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> fillOverriddenMethods(IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> unimplemented) {
-    return unimplemented.withBody(b -> b.appendCallToSame("newInvocationContext().getPort()"));
+  protected IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> fillOverriddenMethods(ITransformInput<IMethod, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> input) {
+    return input.requestDefaultWorkingCopy().withBody(b -> b.appendCallToSame("newInvocationContext().getPort()"));
   }
 
   protected String getBaseName() {
diff --git a/org.eclipse.scout.sdk.core.s/src/main/java/org/eclipse/scout/sdk/core/s/jaxws/WebServiceUpdateOperation.java b/org.eclipse.scout.sdk.core.s/src/main/java/org/eclipse/scout/sdk/core/s/jaxws/WebServiceUpdateOperation.java
index 6f2d09e32..186c9d340 100644
--- a/org.eclipse.scout.sdk.core.s/src/main/java/org/eclipse/scout/sdk/core/s/jaxws/WebServiceUpdateOperation.java
+++ b/org.eclipse.scout.sdk.core.s/src/main/java/org/eclipse/scout/sdk/core/s/jaxws/WebServiceUpdateOperation.java
@@ -26,8 +26,9 @@ import javax.xml.xpath.XPathExpressionException;
 import org.eclipse.scout.sdk.core.builder.java.expression.IExpressionBuilder;
 import org.eclipse.scout.sdk.core.generator.ISourceGenerator;
 import org.eclipse.scout.sdk.core.generator.compilationunit.ICompilationUnitGenerator;
-import org.eclipse.scout.sdk.core.generator.transformer.DefaultWorkingCopyTransformer;
+import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.ITransformInput;
+import org.eclipse.scout.sdk.core.generator.transformer.SimpleWorkingCopyTransformerBuilder;
 import org.eclipse.scout.sdk.core.generator.type.ITypeGenerator;
 import org.eclipse.scout.sdk.core.model.api.IAnnotationElement;
 import org.eclipse.scout.sdk.core.model.api.IClasspathEntry;
@@ -206,17 +207,15 @@ public class WebServiceUpdateOperation implements BiConsumer<IEnvironment, IProg
       }
 
       ICompilationUnit definition = entryPointDefinition.requireCompilationUnit();
-      ICompilationUnitGenerator<?> builder = definition.toWorkingCopy(new DefaultWorkingCopyTransformer() {
-        @Override
-        public ISourceGenerator<IExpressionBuilder<?>> transformAnnotationElement(ITransformInput<IAnnotationElement, ISourceGenerator<IExpressionBuilder<?>>> input) {
-          return rewriteEntryPointDefinitionAnnotationElements(input, up);
-        }
-      });
+      IWorkingCopyTransformer transformer = new SimpleWorkingCopyTransformerBuilder()
+          .withAnnotationElementMapper(input -> rewriteEntryPointDefinitionAnnotationElements(input, up))
+          .build();
+      ICompilationUnitGenerator<?> builder = definition.toWorkingCopy(transformer);
       env.writeCompilationUnit(builder, up.getSourceFolder(), progress);
     }
   }
 
-  protected ISourceGenerator<IExpressionBuilder<?>> rewriteEntryPointDefinitionAnnotationElements(ITransformInput<IAnnotationElement, ISourceGenerator<IExpressionBuilder<?>>> input, EntryPointDefinitionUpdate up) {
+  protected static ISourceGenerator<IExpressionBuilder<?>> rewriteEntryPointDefinitionAnnotationElements(ITransformInput<IAnnotationElement, ISourceGenerator<IExpressionBuilder<?>>> input, EntryPointDefinitionUpdate up) {
     if (IScoutRuntimeTypes.WebServiceEntryPoint.equals(input.model().declaringAnnotation().name())) {
       if (JaxWsUtils.ENTRY_POINT_DEFINITION_ENDPOINTINTERFACE_ATTRIBUTE.equals(input.model().elementName())) {
         String newPortTypeFqn = up.getPortTypePackage() + JavaTypes.C_DOT + up.getPortTypeName();
diff --git a/org.eclipse.scout.sdk.core.test/src/test/java/org/eclipse/scout/sdk/core/generator/transformer/SimpleWorkingCopyTransformerBuilderTest.java b/org.eclipse.scout.sdk.core.test/src/test/java/org/eclipse/scout/sdk/core/generator/transformer/SimpleWorkingCopyTransformerBuilderTest.java
index a16486f36..8dd2e3fe4 100644
--- a/org.eclipse.scout.sdk.core.test/src/test/java/org/eclipse/scout/sdk/core/generator/transformer/SimpleWorkingCopyTransformerBuilderTest.java
+++ b/org.eclipse.scout.sdk.core.test/src/test/java/org/eclipse/scout/sdk/core/generator/transformer/SimpleWorkingCopyTransformerBuilderTest.java
@@ -15,6 +15,8 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.eclipse.scout.sdk.core.fixture.ChildClass;
+import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.ITransformInput;
+import org.eclipse.scout.sdk.core.model.api.IJavaElement;
 import org.eclipse.scout.sdk.core.model.api.IJavaEnvironment;
 import org.eclipse.scout.sdk.core.testing.FixtureHelper.CoreJavaEnvironmentWithSourceFactory;
 import org.eclipse.scout.sdk.core.testing.context.ExtendWithJavaEnvironmentFactory;
@@ -52,11 +54,11 @@ public class SimpleWorkingCopyTransformerBuilderTest {
     env.requireType(ChildClass.class.getName())
         .requireCompilationUnit()
         .toWorkingCopy(transformer);
-    assertEquals(25, m_counter.get());
+    assertEquals(24, m_counter.get());
   }
 
-  private <A> A count(A a) {
+  private <M extends IJavaElement, G> G count(ITransformInput<M, G> input) {
     m_counter.incrementAndGet();
-    return a;
+    return input.requestDefaultWorkingCopy();
   }
 }
diff --git a/org.eclipse.scout.sdk.core.test/src/test/java/org/eclipse/scout/sdk/core/generator/transformer/WorkingCopyTransformerTest.java b/org.eclipse.scout.sdk.core.test/src/test/java/org/eclipse/scout/sdk/core/generator/transformer/WorkingCopyTransformerTest.java
index a209a3ad6..1320ebf34 100644
--- a/org.eclipse.scout.sdk.core.test/src/test/java/org/eclipse/scout/sdk/core/generator/transformer/WorkingCopyTransformerTest.java
+++ b/org.eclipse.scout.sdk.core.test/src/test/java/org/eclipse/scout/sdk/core/generator/transformer/WorkingCopyTransformerTest.java
@@ -14,6 +14,8 @@ import static org.eclipse.scout.sdk.core.testing.SdkAssertions.assertEqualsRefFi
 import static org.eclipse.scout.sdk.core.testing.SdkAssertions.assertNoCompileErrors;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.IOException;
@@ -21,9 +23,12 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.regex.Pattern;
 
 import org.eclipse.scout.sdk.core.builder.java.body.IMethodBodyBuilder;
 import org.eclipse.scout.sdk.core.builder.java.expression.IExpressionBuilder;
+import org.eclipse.scout.sdk.core.fixture.AnnotationWithArrayValues;
 import org.eclipse.scout.sdk.core.fixture.ChildClass;
 import org.eclipse.scout.sdk.core.fixture.ClassWithAnnotationWithArrayValues;
 import org.eclipse.scout.sdk.core.generator.ISourceGenerator;
@@ -33,9 +38,11 @@ import org.eclipse.scout.sdk.core.generator.field.IFieldGenerator;
 import org.eclipse.scout.sdk.core.generator.method.IMethodGenerator;
 import org.eclipse.scout.sdk.core.generator.method.MethodOverrideGenerator;
 import org.eclipse.scout.sdk.core.generator.methodparam.IMethodParameterGenerator;
+import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.ITransformInput;
 import org.eclipse.scout.sdk.core.generator.type.ITypeGenerator;
 import org.eclipse.scout.sdk.core.generator.type.PrimaryTypeGenerator;
 import org.eclipse.scout.sdk.core.generator.typeparam.ITypeParameterGenerator;
+import org.eclipse.scout.sdk.core.model.api.DefaultDepthFirstJavaElementVisitor;
 import org.eclipse.scout.sdk.core.model.api.Flags;
 import org.eclipse.scout.sdk.core.model.api.IAnnotation;
 import org.eclipse.scout.sdk.core.model.api.IAnnotationElement;
@@ -56,6 +63,7 @@ import org.eclipse.scout.sdk.core.testing.context.DefaultCommentGeneratorExtensi
 import org.eclipse.scout.sdk.core.testing.context.ExtendWithJavaEnvironmentFactory;
 import org.eclipse.scout.sdk.core.testing.context.JavaEnvironmentExtension;
 import org.eclipse.scout.sdk.core.testing.context.UsernameExtension;
+import org.eclipse.scout.sdk.core.util.visitor.TreeVisitResult;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 
@@ -70,6 +78,7 @@ import org.junit.jupiter.api.extension.ExtendWith;
 @ExtendWithJavaEnvironmentFactory(CoreJavaEnvironmentWithSourceFactory.class)
 public class WorkingCopyTransformerTest {
 
+  @SuppressWarnings("HardcodedFileSeparator")
   private static final String REF_FILE_FOLDER = "org/eclipse/scout/sdk/core/generator/transformer/";
 
   @Test
@@ -115,7 +124,6 @@ public class WorkingCopyTransformerTest {
     };
 
     ICompilationUnit transformedUnit = assertTransformedComponents(env, ChildClass.class, transformer,
-        "compilationUnit: ChildClass.java",
         "package: org.eclipse.scout.sdk.core.fixture",
         "import: IOException",
         "import: Serializable",
@@ -163,7 +171,6 @@ public class WorkingCopyTransformerTest {
   @Test
   public void testTransformationOnArrayAnnotationWithoutModifications(IJavaEnvironment env) {
     assertTransformedComponents(env, ClassWithAnnotationWithArrayValues.class,
-        "compilationUnit: ClassWithAnnotationWithArrayValues.java",
         "package: org.eclipse.scout.sdk.core.fixture",
         "import: RoundingMode",
         "import: Generated",
@@ -174,6 +181,14 @@ public class WorkingCopyTransformerTest {
         "annotationElement: strings",
         "annotationElement: types",
         "annotationElement: annos",
+        "method: run",
+        "annotation: AnnotationWithArrayValues",
+        "annotationElement: nums",
+        "annotationElement: enumValues",
+        "annotationElement: strings",
+        "annotationElement: types",
+        "annotationElement: annos",
+        "methodParam: a",
         "annotation: AnnotationWithSingleValues",
         "annotationElement: num",
         "annotationElement: enumValue",
@@ -190,13 +205,6 @@ public class WorkingCopyTransformerTest {
         "annotationElement: anno",
         "annotation: Generated",
         "annotationElement: value",
-        "method: run",
-        "annotation: AnnotationWithArrayValues",
-        "annotationElement: nums",
-        "annotationElement: enumValues",
-        "annotationElement: strings",
-        "annotationElement: types",
-        "annotationElement: annos",
         "annotation: AnnotationWithSingleValues",
         "annotationElement: num",
         "annotationElement: enumValue",
@@ -212,8 +220,7 @@ public class WorkingCopyTransformerTest {
         "annotationElement: type",
         "annotationElement: anno",
         "annotation: Generated",
-        "annotationElement: value",
-        "methodParam: a");
+        "annotationElement: value");
   }
 
   @Test
@@ -223,10 +230,11 @@ public class WorkingCopyTransformerTest {
 
     P_TestingWorkingCopyTransformer transformer = new P_TestingWorkingCopyTransformer();
     ITypeGenerator<?> generator = notExisting.toWorkingCopy(transformer);
-    assertEquals("classWhatEver{}", generator.toJavaSource(env).toString().replaceAll("\\s", ""));
+    assertEquals("classWhatEver{}", Pattern.compile("\\s").matcher(generator.toJavaSource(env)).replaceAll(""));
 
     transformer = new P_TestingWorkingCopyTransformer();
     generator = existing.toWorkingCopy(transformer);
+    assertNotNull(generator);
     assertTrue(transformer.m_protocol.size() > 10); // Long must be found and therefore has some elements
   }
 
@@ -261,6 +269,164 @@ public class WorkingCopyTransformerTest {
   }
 
   /**
+   * If changes in this method are necessary also update the corresponding example on {@link IWorkingCopyTransformer}
+   * class javadoc.
+   * 
+   * @param env
+   *          The environment passed
+   */
+  @Test
+  public void testTransformerDocumentation(IJavaEnvironment env) {
+    IWorkingCopyTransformer transformer = new DefaultWorkingCopyTransformer() {
+      @Override
+      public IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> transformMethod(ITransformInput<IMethod, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> input) {
+        IMethod templateMethod = input.model();
+        IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> overrideGenerator = input.requestDefaultWorkingCopy();
+        switch (templateMethod.elementName()) {
+          case "toString":
+            // provide method body for toString method
+            return overrideGenerator.withBody(b -> b.returnClause().stringLiteral("SampleCloseable class").semicolon());
+          case "close":
+            // remove throws declaration for close method
+            return overrideGenerator.withoutException(Exception.class.getName());
+          default:
+            return overrideGenerator;
+        }
+      }
+    };
+
+    //noinspection unused
+    PrimaryTypeGenerator<?> generator = PrimaryTypeGenerator.create()
+        .withElementName("SampleCloseable")
+        .withInterface(AutoCloseable.class.getName()) // defines the methods that can be overridden
+        .withMethod(MethodOverrideGenerator.createOverride(transformer)
+            .withElementName("toString")) // override toString
+        .withAllMethodsImplemented(transformer); // override all methods required by super types.
+
+    ICompilationUnit icu = env.requireType(Long.class.getName()).requireCompilationUnit();
+    //noinspection unused
+    ICompilationUnitGenerator<?> workingCopy = icu.toWorkingCopy(
+        new SimpleWorkingCopyTransformerBuilder()
+            .withAnnotationMapper(this::transformAnnotation) // change SuppressWarnings to 'all'
+            .withMethodParameterMapper(IWorkingCopyTransformer::remove) // remove all parameters from methods
+            .build());
+
+  }
+
+  @SuppressWarnings("MethodMayBeStatic")
+  private IAnnotationGenerator<?> transformAnnotation(ITransformInput<IAnnotation, IAnnotationGenerator<?>> input) {
+    if (SuppressWarnings.class.getName().equals(input.model().type().name())) {
+      // modify all suppress-warning annotations to suppress all warnings
+      return input.requestDefaultWorkingCopy().withElement("value", b -> b.stringLiteral("all"));
+    }
+    return input.requestDefaultWorkingCopy();
+  }
+
+  @Test
+  public void testTransformationOfOverriddenMethodWithRemove(IJavaEnvironment env) {
+    String methodToModify = "methodInChildClass";
+    IWorkingCopyTransformer transformer = new SimpleWorkingCopyTransformerBuilder()
+        .withMethodParameterMapper(IWorkingCopyTransformer::remove) // remove all method parameters
+        .build();
+    PrimaryTypeGenerator<?> generatorWithoutTransformer = PrimaryTypeGenerator.create()
+        .withElementName("TestOnly")
+        .withSuperClass(ChildClass.class.getName())
+        .withMethod(MethodOverrideGenerator.createOverride()
+            .withElementName(methodToModify));
+    PrimaryTypeGenerator<?> generatorWithTransformer = PrimaryTypeGenerator.create()
+        .withElementName("TestOnly")
+        .withSuperClass(ChildClass.class.getName())
+        .withMethod(MethodOverrideGenerator.createOverride(transformer)
+            .withElementName(methodToModify));
+
+    long numParamsWithoutTransformer = CoreTestingUtils.registerCompilationUnit(env, generatorWithoutTransformer)
+        .methods()
+        .withName(methodToModify)
+        .first().get()
+        .parameters().stream()
+        .count();
+    long numParamsWithTransformer = CoreTestingUtils.registerCompilationUnit(env, generatorWithTransformer)
+        .methods()
+        .withName(methodToModify)
+        .first().get()
+        .parameters().stream()
+        .count();
+    assertEquals(2, numParamsWithoutTransformer);
+    assertEquals(0, numParamsWithTransformer);
+  }
+
+  @Test
+  public void testRemovalOfOverriddenMethod(IJavaEnvironment env) {
+    IWorkingCopyTransformer transformer = new SimpleWorkingCopyTransformerBuilder()
+        .withMethodMapper(WorkingCopyTransformerTest::transformMethod)
+        .build();
+    PrimaryTypeGenerator<?> generator = PrimaryTypeGenerator.create()
+        .withElementName("SampleSequence")
+        .withInterface(CharSequence.class.getName());
+
+    long numMethodsWithoutTransformer = CoreTestingUtils.registerCompilationUnit(env, generator.withAllMethodsImplemented()).methods().stream().count();
+    long numMethodsWithTransformer = CoreTestingUtils.registerCompilationUnit(env, generator.withAllMethodsImplemented(transformer)).methods().stream().count();
+    assertEquals(numMethodsWithoutTransformer - 1 /* the method removed by the transformer */, numMethodsWithTransformer);
+  }
+
+  private static IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> transformMethod(ITransformInput<IMethod, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> input) {
+    if ("charAt".equals(input.model().elementName())) {
+      return null;
+    }
+    return input.requestDefaultWorkingCopy();
+  }
+
+  @Test
+  public void testTransformerRemovingAnnotationElement(IJavaEnvironment env) {
+    String annotationElementNameToRemove = "strings";
+    IType classWithAnnotationArrayValues = env.requireType(ClassWithAnnotationWithArrayValues.class.getName());
+    IAnnotation firstAnnotation = classWithAnnotationArrayValues.annotations().withName(AnnotationWithArrayValues.class.getName()).first().get();
+    assertFalse(firstAnnotation.element(annotationElementNameToRemove).get().isDefault());
+
+    IWorkingCopyTransformer removeElementTransformer = new DefaultWorkingCopyTransformer() {
+      @Override
+      public ISourceGenerator<IExpressionBuilder<?>> transformAnnotationElement(ITransformInput<IAnnotationElement, ISourceGenerator<IExpressionBuilder<?>>> input) {
+        if (annotationElementNameToRemove.equals(input.model().elementName())) {
+          return null; // remove the "strings" element from all annotations
+        }
+        return super.transformAnnotationElement(input);
+      }
+    };
+
+    assertTrue(classWithAnnotationArrayValues.toWorkingCopy().annotations().findAny().get().element(annotationElementNameToRemove).isPresent()); // is not removed with default transform
+    assertFalse(classWithAnnotationArrayValues.toWorkingCopy(removeElementTransformer).annotations().findAny().get().element(annotationElementNameToRemove).isPresent()); // is removed because of transformer
+  }
+
+  @Test
+  public void testTransformerRemovingAnnotations(IJavaEnvironment env) {
+    ICompilationUnit baseType = env.requireType(ClassWithAnnotationWithArrayValues.class.getName()).requireCompilationUnit();
+    assertEquals(10, numberOfAnnotationsIn(baseType));
+
+    IWorkingCopyTransformer removeAllAnnotationsTransformer = new DefaultWorkingCopyTransformer() {
+      @Override
+      public IAnnotationGenerator<?> transformAnnotation(ITransformInput<IAnnotation, IAnnotationGenerator<?>> input) {
+        return null;
+      }
+    };
+    ICompilationUnitGenerator<?> generator = baseType.toWorkingCopy(removeAllAnnotationsTransformer);
+    generator.mainType().get().withElementName("OtherClass"); // change the name so that the original class is not changed in the IJavaEnvironment. Otherwise it is modified for later tests
+    IType baseTypeWithoutAnnotations = assertNoCompileErrors(env, generator);
+    assertEquals(0, numberOfAnnotationsIn(baseTypeWithoutAnnotations));
+  }
+
+  private static int numberOfAnnotationsIn(IJavaElement element) {
+    AtomicInteger numberOfAnnotations = new AtomicInteger();
+    element.visit(new DefaultDepthFirstJavaElementVisitor() {
+      @Override
+      public TreeVisitResult preVisit(IAnnotation annotation, int level, int index) {
+        numberOfAnnotations.incrementAndGet();
+        return super.preVisit(annotation, level, index);
+      }
+    });
+    return numberOfAnnotations.get();
+  }
+
+  /**
    * Parses the specified fixture class and transforms it into a working copy. A default {@link IWorkingCopyTransformer}
    * is used that does not apply any transformation. It is ensured that the specified components have been called on the
    * transformer. The working copy is then parsed into an {@link ICompilationUnit} again and returned.
@@ -273,7 +439,7 @@ public class WorkingCopyTransformerTest {
    *          The components that must be called on the transformer.
    * @return The transformed {@link ICompilationUnit} of the specified fixture class.
    */
-  private ICompilationUnit assertTransformedComponents(IJavaEnvironment env, Class<?> fixture, String... components) {
+  private static ICompilationUnit assertTransformedComponents(IJavaEnvironment env, Class<?> fixture, String... components) {
     return assertTransformedComponents(env, fixture, null, components);
   }
 
@@ -292,7 +458,7 @@ public class WorkingCopyTransformerTest {
    *          The components that must be called on the transformer.
    * @return The transformed {@link ICompilationUnit} of the specified fixture class.
    */
-  private ICompilationUnit assertTransformedComponents(IJavaEnvironment env, Class<?> fixture, P_TestingWorkingCopyTransformer transformer, String... components) {
+  private static ICompilationUnit assertTransformedComponents(IJavaEnvironment env, Class<?> fixture, P_TestingWorkingCopyTransformer transformer, String... components) {
     P_TestingWorkingCopyTransformer t = Optional.ofNullable(transformer)
         .orElseGet(P_TestingWorkingCopyTransformer::new);
     ICompilationUnitGenerator<?> generator = env.requireType(fixture.getName())
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/AbstractAnnotatableGenerator.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/AbstractAnnotatableGenerator.java
index cb837681a..218e0c186 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/AbstractAnnotatableGenerator.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/AbstractAnnotatableGenerator.java
@@ -12,9 +12,11 @@ package org.eclipse.scout.sdk.core.generator;
 
 import static java.util.Comparator.comparingInt;
 import static java.util.stream.Collectors.toList;
+import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformAnnotation;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Stream;
 
 import org.eclipse.scout.sdk.core.builder.ISourceBuilder;
@@ -41,7 +43,9 @@ public abstract class AbstractAnnotatableGenerator<TYPE extends IAnnotatableGene
   protected AbstractAnnotatableGenerator(IAnnotatable element, IWorkingCopyTransformer transformer) {
     super(element);
     m_annotations = element.annotations().stream()
-        .map(a -> a.toWorkingCopy(transformer))
+        .map(a -> transformAnnotation(a, transformer))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
         .collect(toList());
   }
 
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/SimpleGenerators.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/SimpleGenerators.java
new file mode 100644
index 000000000..6c3da1eb9
--- /dev/null
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/SimpleGenerators.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2010-2020 BSI Business Systems Integration AG.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     BSI Business Systems Integration AG - initial API and implementation
+ */
+package org.eclipse.scout.sdk.core.generator;
+
+import static org.eclipse.scout.sdk.core.generator.ISourceGenerator.empty;
+import static org.eclipse.scout.sdk.core.generator.ISourceGenerator.raw;
+import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformAnnotation;
+import static org.eclipse.scout.sdk.core.imports.ImportCollector.createImportDeclaration;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+import org.eclipse.scout.sdk.core.builder.ISourceBuilder;
+import org.eclipse.scout.sdk.core.builder.java.IJavaSourceBuilder;
+import org.eclipse.scout.sdk.core.builder.java.expression.ExpressionBuilder;
+import org.eclipse.scout.sdk.core.builder.java.expression.IExpressionBuilder;
+import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
+import org.eclipse.scout.sdk.core.generator.type.ITypeGenerator;
+import org.eclipse.scout.sdk.core.generator.type.TypeGenerator;
+import org.eclipse.scout.sdk.core.model.api.IAnnotation;
+import org.eclipse.scout.sdk.core.model.api.IAnnotationElement;
+import org.eclipse.scout.sdk.core.model.api.IArrayMetaValue;
+import org.eclipse.scout.sdk.core.model.api.IField;
+import org.eclipse.scout.sdk.core.model.api.IImport;
+import org.eclipse.scout.sdk.core.model.api.IMetaValue;
+import org.eclipse.scout.sdk.core.model.api.IPackage;
+import org.eclipse.scout.sdk.core.model.api.IType;
+import org.eclipse.scout.sdk.core.model.api.IUnresolvedType;
+import org.eclipse.scout.sdk.core.model.api.MetaValueType;
+import org.eclipse.scout.sdk.core.util.JavaTypes;
+import org.eclipse.scout.sdk.core.util.Strings;
+
+public final class SimpleGenerators {
+
+  private SimpleGenerators() {
+  }
+
+  public static ISourceGenerator<ISourceBuilder<?>> createImportGenerator(IImport imp) {
+    return raw(createImportDeclaration(imp.isStatic(), imp.name()));
+  }
+
+  public static ISourceGenerator<IExpressionBuilder<?>> createMetaValueGenerator(IMetaValue mv, IWorkingCopyTransformer transformer) {
+    switch (mv.type()) {
+      case Null:
+        return b -> b.append("null");
+      case Int:
+        return b -> b.append(mv.as(Integer.class).intValue());
+      case Byte:
+        return b -> b.append(mv.as(Byte.class).byteValue());
+      case Short:
+        return b -> b.append(mv.as(Short.class).shortValue());
+      case Char:
+        return b -> b.append('\'')
+            .append(mv.as(Character.class))
+            .append('\'');
+      case Float:
+        return b -> b.append(mv.as(Float.class))
+            .append('f');
+      case Double:
+        return b -> b.append(mv.as(Double.class).doubleValue());
+      case Bool:
+        return b -> b.append(mv.as(Boolean.class).booleanValue());
+      case Long:
+        return b -> b.append(mv.as(Long.class))
+            .append('L');
+      case String:
+        return b -> b.stringLiteral(mv.as(String.class));
+      case Type:
+        return b -> b.classLiteral(mv.as(IType.class).reference(true));
+      case Enum:
+        IField field = mv.as(IField.class);
+        return b -> b.enumValue(field.declaringType().name(), field.elementName());
+      case Annotation:
+        return b -> transformAnnotation(mv.as(IAnnotation.class), transformer).ifPresent(b::append);
+      case Array:
+        return createArrayMetaValueGenerator((IArrayMetaValue) mv, transformer);
+      default:
+        return b -> b.append("UNKNOWN(").append(mv.type().toString()).append(", ").append(mv.toString()).append(')');
+    }
+  }
+
+  public static ISourceGenerator<IExpressionBuilder<?>> createArrayMetaValueGenerator(IArrayMetaValue mv, IWorkingCopyTransformer transformer) {
+    IMetaValue[] metaArray = mv.metaValueArray();
+    Stream<ISourceGenerator<ISourceBuilder<?>>> generators = Arrays.stream(metaArray)
+        .map(m -> createMetaValueGenerator(m, transformer))
+        .map(g -> g.generalize(ExpressionBuilder::create));
+
+    // use newlines on multi-dimensional arrays and annotation arrays only
+    boolean useNewlines = metaArray.length > 0 && (metaArray[0].type() == MetaValueType.Array || metaArray[0].type() == MetaValueType.Annotation);
+    return b -> b.array(generators, useNewlines);
+  }
+
+  public static ISourceGenerator<IExpressionBuilder<?>> createAnnotationElementGenerator(IAnnotationElement ae, IWorkingCopyTransformer transformer) {
+    if (ae.isDefault()) {
+      return empty();
+    }
+    return b -> b.append(ae.elementName()).equalSign().append(ae.value().toWorkingCopy(transformer).generalize(ExpressionBuilder::create));
+  }
+
+  public static ISourceGenerator<ISourceBuilder<?>> createPackageGenerator(@SuppressWarnings("TypeMayBeWeakened") IPackage p) {
+    return createPackageGenerator(p.elementName());
+  }
+
+  public static ISourceGenerator<ISourceBuilder<?>> createPackageGenerator(String packageName) {
+    return Strings.notBlank(packageName)
+        .<ISourceGenerator<IJavaSourceBuilder<?>>> map(s -> b -> b.append("package ").append(s).semicolon())
+        .map(g -> g.generalize(ExpressionBuilder::create))
+        .orElseGet(ISourceGenerator::empty);
+  }
+
+  public static ITypeGenerator<?> createUnresolvedTypeGenerator(IUnresolvedType ut, IWorkingCopyTransformer transformer) {
+    return ut.type()
+        .<ITypeGenerator<?>> map(t -> TypeGenerator.create(t, transformer))
+        .orElseGet(() -> TypeGenerator.create()
+            .setDeclaringFullyQualifiedName(JavaTypes.qualifier(ut.name().replace(JavaTypes.C_DOLLAR, JavaTypes.C_DOT)))
+            .withElementName(ut.elementName()));
+  }
+}
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/annotation/AnnotationGenerator.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/annotation/AnnotationGenerator.java
index 324610e91..44d4d1fac 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/annotation/AnnotationGenerator.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/annotation/AnnotationGenerator.java
@@ -16,6 +16,7 @@ import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTrans
 import static org.eclipse.scout.sdk.core.util.Ensure.failOnDuplicates;
 import static org.eclipse.scout.sdk.core.util.Ensure.newFail;
 
+import java.util.AbstractMap.SimpleEntry;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Optional;
@@ -32,7 +33,6 @@ import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.generator.transformer.SimpleWorkingCopyTransformerBuilder;
 import org.eclipse.scout.sdk.core.model.annotation.GeneratedAnnotation;
 import org.eclipse.scout.sdk.core.model.api.IAnnotation;
-import org.eclipse.scout.sdk.core.model.api.IJavaElement;
 import org.eclipse.scout.sdk.core.util.Ensure;
 import org.eclipse.scout.sdk.core.util.JavaTypes;
 import org.eclipse.scout.sdk.core.util.Strings;
@@ -51,10 +51,9 @@ public class AnnotationGenerator<TYPE extends IAnnotationGenerator<TYPE>> extend
     withElementName(annotation.type().name());
     m_values = annotation.elements().values().stream()
         .filter(ae -> !ae.isDefault())
-        .collect(toMap(IJavaElement::elementName,
-            ae -> transformAnnotationElement(ae, transformer),
-            failOnDuplicates(),
-            LinkedHashMap::new));
+        .map(ae -> new SimpleEntry<>(ae.elementName(), transformAnnotationElement(ae, transformer)))
+        .filter(ae -> ae.getValue().isPresent())
+        .collect(toMap(SimpleEntry::getKey, se -> se.getValue().get(), failOnDuplicates(), LinkedHashMap::new));
   }
 
   protected AnnotationGenerator() {
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/compilationunit/CompilationUnitGenerator.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/compilationunit/CompilationUnitGenerator.java
index a568a0e0a..c883d8d77 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/compilationunit/CompilationUnitGenerator.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/compilationunit/CompilationUnitGenerator.java
@@ -14,6 +14,7 @@ import static java.util.function.Function.identity;
 import static java.util.stream.Collectors.toList;
 import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformImport;
 import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformPackage;
+import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformType;
 import static org.eclipse.scout.sdk.core.model.api.Flags.isPublic;
 
 import java.util.ArrayList;
@@ -23,8 +24,8 @@ import java.util.List;
 import java.util.Optional;
 import java.util.stream.Stream;
 
+import org.eclipse.scout.sdk.core.builder.IBuilderContext;
 import org.eclipse.scout.sdk.core.builder.ISourceBuilder;
-import org.eclipse.scout.sdk.core.builder.java.IJavaBuilderContext;
 import org.eclipse.scout.sdk.core.builder.java.IJavaSourceBuilder;
 import org.eclipse.scout.sdk.core.builder.java.comment.CommentBuilder;
 import org.eclipse.scout.sdk.core.builder.java.comment.ICommentBuilder;
@@ -32,7 +33,9 @@ import org.eclipse.scout.sdk.core.builder.java.comment.IJavaElementCommentBuilde
 import org.eclipse.scout.sdk.core.builder.java.comment.JavaElementCommentBuilder;
 import org.eclipse.scout.sdk.core.builder.java.member.IMemberBuilder;
 import org.eclipse.scout.sdk.core.generator.AbstractJavaElementGenerator;
+import org.eclipse.scout.sdk.core.generator.IJavaElementGenerator;
 import org.eclipse.scout.sdk.core.generator.ISourceGenerator;
+import org.eclipse.scout.sdk.core.generator.SimpleGenerators;
 import org.eclipse.scout.sdk.core.generator.transformer.DefaultWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.generator.transformer.SimpleWorkingCopyTransformerBuilder;
@@ -71,17 +74,24 @@ public class CompilationUnitGenerator<TYPE extends ICompilationUnitGenerator<TYP
   protected CompilationUnitGenerator(ICompilationUnit cu, IWorkingCopyTransformer transformer) {
     super(cu);
 
-    m_packageName = transformPackage(cu.containingPackage(), transformer);
+    m_packageName = transformPackage(cu.containingPackage(), transformer).orElse(null);
     m_declaredImports = cu.imports()
         .filter(i -> !i.isStatic())
         .map(i -> transformImport(i, transformer))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
         .collect(toList());
     m_declaredStaticImports = cu.imports()
         .filter(IImport::isStatic)
         .map(i -> transformImport(i, transformer))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
         .collect(toList());
     m_types = cu.types().stream()
-        .map(t -> new SortedMemberEntry(t, transformer))
+        .map(t -> transformType(t, transformer)
+            .map(g -> new SortedMemberEntry(g, t)))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
         .peek(entry -> applyConnection((ITypeGenerator<?>) entry.generator(), this))
         .collect(toList());
     m_footerSourceBuilders = new ArrayList<>();
@@ -136,10 +146,13 @@ public class CompilationUnitGenerator<TYPE extends ICompilationUnitGenerator<TYP
     StringBuilder typeSource = buildTypeSource(builder.context()); // pre build type source so that all imports are defined
     String nl = builder.context().lineDelimiter();
 
+    ISourceGenerator<ISourceBuilder<?>> packageBuilder = packageName()
+        .map(SimpleGenerators::createPackageGenerator)
+        .<ISourceGenerator<ISourceBuilder<?>>> map(g -> b -> b.append(g).nl().nl())
+        .orElseGet(ISourceGenerator::empty);
+
     builder
-        .append(packageName()
-            .<ISourceGenerator<IJavaSourceBuilder<?>>> map(s -> b -> b.append("package ").append(s).semicolon().nl().nl())
-            .map(g -> g.generalize(b -> builder)))
+        .append(packageBuilder)
         .append(builder.context().validator().importCollector().createImportDeclarations()
             .map(ISourceGenerator::raw), null, nl, nl)
         .append(typeSource)
@@ -148,7 +161,7 @@ public class CompilationUnitGenerator<TYPE extends ICompilationUnitGenerator<TYP
             .map(b -> b.generalize(CommentBuilder::create)), nl, nl, null);
   }
 
-  protected StringBuilder buildTypeSource(IJavaBuilderContext context) {
+  protected StringBuilder buildTypeSource(IBuilderContext context) {
     ISourceGenerator<ISourceBuilder<?>> typeGenerator =
         builder -> builder.append(
             m_types.stream()
@@ -270,7 +283,7 @@ public class CompilationUnitGenerator<TYPE extends ICompilationUnitGenerator<TYP
     return currentInstance();
   }
 
-  protected static ITypeGenerator<?> applyConnection(ITypeGenerator<?> child, ICompilationUnitGenerator<?> parent) {
+  protected static ITypeGenerator<?> applyConnection(ITypeGenerator<?> child, IJavaElementGenerator<?> parent) {
     if (child instanceof TypeGenerator) {
       ((TypeGenerator<?>) child).withDeclaringGenerator(parent);
     }
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/field/FieldGenerator.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/field/FieldGenerator.java
index 7e7c10dda..8ce80e98b 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/field/FieldGenerator.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/field/FieldGenerator.java
@@ -10,6 +10,7 @@
  */
 package org.eclipse.scout.sdk.core.generator.field;
 
+import static org.eclipse.scout.sdk.core.generator.SimpleGenerators.createMetaValueGenerator;
 import static org.eclipse.scout.sdk.core.util.Ensure.newFail;
 
 import java.util.Optional;
@@ -52,7 +53,7 @@ public class FieldGenerator<TYPE extends IFieldGenerator<TYPE>> extends Abstract
             .map(ISourceRange::asCharSequence)
             .<ISourceGenerator<IExpressionBuilder<?>>> map(ISourceGenerator::raw)
             .orElseGet(() -> field.constantValue()
-                .map(mv -> mv.toWorkingCopy(transformer))
+                .map(mv -> createMetaValueGenerator(mv, transformer))
                 .orElse(null)));
   }
 
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/method/MethodGenerator.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/method/MethodGenerator.java
index b907dbe55..e5f32445c 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/method/MethodGenerator.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/method/MethodGenerator.java
@@ -12,6 +12,8 @@ package org.eclipse.scout.sdk.core.generator.method;
 
 import static java.util.stream.Collectors.toCollection;
 import static java.util.stream.Collectors.toList;
+import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformMethodParameter;
+import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformTypeParameter;
 import static org.eclipse.scout.sdk.core.model.api.Flags.isAbstract;
 import static org.eclipse.scout.sdk.core.model.api.Flags.isDefaultMethod;
 import static org.eclipse.scout.sdk.core.model.api.Flags.isInterface;
@@ -81,11 +83,15 @@ public class MethodGenerator<TYPE extends IMethodGenerator<TYPE, BODY>, BODY ext
         .orElse(null);
 
     m_typeParameters = method.typeParameters()
-        .map(p -> p.toWorkingCopy(transformer))
+        .map(p -> transformTypeParameter(p, transformer))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
         .collect(toList());
 
     m_parameters = method.parameters().stream()
-        .map(mp -> mp.toWorkingCopy(transformer))
+        .map(mp -> transformMethodParameter(mp, transformer))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
         .collect(toList());
 
     m_exceptions = method.exceptionTypes()
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/method/MethodOverrideGenerator.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/method/MethodOverrideGenerator.java
index 103cd577c..799da1a0a 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/method/MethodOverrideGenerator.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/method/MethodOverrideGenerator.java
@@ -12,6 +12,7 @@ package org.eclipse.scout.sdk.core.generator.method;
 
 import static java.util.function.Function.identity;
 import static java.util.stream.Collectors.toMap;
+import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transform;
 import static org.eclipse.scout.sdk.core.model.api.Flags.isAbstract;
 import static org.eclipse.scout.sdk.core.model.api.Flags.isInterface;
 import static org.eclipse.scout.sdk.core.util.Ensure.newFail;
@@ -139,7 +140,7 @@ public class MethodOverrideGenerator<TYPE extends IMethodGenerator<TYPE, BODY>,
     boolean needsImplementation = isFromInterface || isAbstract(template.flags());
 
     IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> innerGenerator =
-        template.toWorkingCopy(null /* do not pass the transformer here. it is called later explicitly as soon as the default setup is done. transformer is 'stronger'.*/)
+        template.toWorkingCopy(m_transformer)
             .clearAnnotations() // clear annotations from method
             .withComment(null)
             .withAnnotation(AnnotationGenerator.createOverride())
@@ -173,9 +174,8 @@ public class MethodOverrideGenerator<TYPE extends IMethodGenerator<TYPE, BODY>,
     };
   }
 
-  protected IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> createOverrideGenerator(IMethod template) {
-    return IWorkingCopyTransformer.<IMethod, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> transform(m_transformer, template,
-        () -> createDefaultOverrideGenerator(template), (t, i) -> t.transformMethod(i));
+  protected Optional<IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> createOverrideGenerator(IMethod template) {
+    return transform(m_transformer, template, () -> createDefaultOverrideGenerator(template), (t, i) -> t.transformMethod(i));
   }
 
   protected Optional<IMethod> findMethodToOverride(IType container) {
@@ -197,10 +197,8 @@ public class MethodOverrideGenerator<TYPE extends IMethodGenerator<TYPE, BODY>,
   @Override
   protected void build(IJavaSourceBuilder<?> builder) {
     callWithTmpType(declaringTypeGenerator(), builder.context().environment().orElseThrow(() -> newFail("Cannot override a method without java environment.")),
-        tmpType -> createOverrideGenerator(
-            findMethodToOverride(tmpType)
-                .orElseThrow(() -> newFail("Method '{}' cannot be found in the super hierarchy.", elementName().orElse(null)))))
-                    .generate(builder);
+        tmpType -> createOverrideGenerator(findMethodToOverride(tmpType).orElseThrow(() -> newFail("Method '{}' cannot be found in the super hierarchy.", elementName().orElse(null)))))
+            .ifPresent(generator -> generator.generate(builder));
   }
 
   /**
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/transformer/IWorkingCopyTransformer.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/transformer/IWorkingCopyTransformer.java
index e55d0312d..fc4dd9487 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/transformer/IWorkingCopyTransformer.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/transformer/IWorkingCopyTransformer.java
@@ -17,20 +17,13 @@ import java.util.function.Supplier;
 import org.eclipse.scout.sdk.core.builder.java.body.IMethodBodyBuilder;
 import org.eclipse.scout.sdk.core.builder.java.expression.IExpressionBuilder;
 import org.eclipse.scout.sdk.core.generator.ISourceGenerator;
-import org.eclipse.scout.sdk.core.generator.annotation.AnnotationGenerator;
 import org.eclipse.scout.sdk.core.generator.annotation.IAnnotationGenerator;
-import org.eclipse.scout.sdk.core.generator.compilationunit.CompilationUnitGenerator;
 import org.eclipse.scout.sdk.core.generator.compilationunit.ICompilationUnitGenerator;
-import org.eclipse.scout.sdk.core.generator.field.FieldGenerator;
 import org.eclipse.scout.sdk.core.generator.field.IFieldGenerator;
 import org.eclipse.scout.sdk.core.generator.method.IMethodGenerator;
-import org.eclipse.scout.sdk.core.generator.method.MethodGenerator;
 import org.eclipse.scout.sdk.core.generator.methodparam.IMethodParameterGenerator;
-import org.eclipse.scout.sdk.core.generator.methodparam.MethodParameterGenerator;
 import org.eclipse.scout.sdk.core.generator.type.ITypeGenerator;
-import org.eclipse.scout.sdk.core.generator.type.TypeGenerator;
 import org.eclipse.scout.sdk.core.generator.typeparam.ITypeParameterGenerator;
-import org.eclipse.scout.sdk.core.generator.typeparam.TypeParameterGenerator;
 import org.eclipse.scout.sdk.core.model.api.IAnnotation;
 import org.eclipse.scout.sdk.core.model.api.IAnnotationElement;
 import org.eclipse.scout.sdk.core.model.api.ICompilationUnit;
@@ -43,7 +36,6 @@ import org.eclipse.scout.sdk.core.model.api.IPackage;
 import org.eclipse.scout.sdk.core.model.api.IType;
 import org.eclipse.scout.sdk.core.model.api.ITypeParameter;
 import org.eclipse.scout.sdk.core.model.api.IUnresolvedType;
-import org.eclipse.scout.sdk.core.util.JavaTypes;
 
 /**
  * <h3>{@link IWorkingCopyTransformer}</h3>
@@ -55,11 +47,11 @@ import org.eclipse.scout.sdk.core.util.JavaTypes;
  * <b>Override Methods with modifications on the overridden components:</b>
  *
  * <pre>
- * final IWorkingCopyTransformer transformer = new DefaultWorkingCopyTransformer() {
+ * IWorkingCopyTransformer transformer = new DefaultWorkingCopyTransformer() {
  *   &#64;Override
- *   public IMethodGenerator&#60;?, ? extends IMethodBodyBuilder&#60;?&#62;&#62; transformMethod(final ITransformInput&#60;IMethod, IMethodGenerator&#60;?, ? extends IMethodBodyBuilder&#60;?&#62;&#62;&#62; input) {
- *     final IMethod templateMethod = input.model();
- *     final IMethodGenerator&#60;?, ? extends IMethodBodyBuilder&#60;?&#62;&#62; overrideGenerator = input.requestDefaultWorkingCopy();
+ *   public IMethodGenerator&#60;?, ? extends IMethodBodyBuilder&#60;?&#62;&#62; transformMethod(ITransformInput&#60;IMethod, IMethodGenerator&#60;?, ? extends IMethodBodyBuilder&#60;?&#62;&#62;&#62; input) {
+ *     IMethod templateMethod = input.model();
+ *     IMethodGenerator&#60;?, ? extends IMethodBodyBuilder&#60;?&#62;&#62; overrideGenerator = input.requestDefaultWorkingCopy();
  *     switch (templateMethod.elementName()) {
  *       case "toString":
  *         // provide method body for toString method
@@ -73,7 +65,7 @@ import org.eclipse.scout.sdk.core.util.JavaTypes;
  *   }
  * };
  *
- * final PrimaryTypeGenerator&#60;?&#62; generator = PrimaryTypeGenerator.create()
+ * PrimaryTypeGenerator&#60;?&#62; generator = PrimaryTypeGenerator.create()
  *     .withElementName("SampleCloseable")
  *     .withInterface(AutoCloseable.class.getName()) // defines the methods that can be overridden
  *     .withMethod(MethodOverrideGenerator.createOverride(transformer)
@@ -84,18 +76,19 @@ import org.eclipse.scout.sdk.core.util.JavaTypes;
  * <b>Convert to working copy applying modifications:</b>
  *
  * <pre>
- * final ICompilationUnit icu = env.requireType(Long.class.getName()).requireCompilationUnit();
- * final ICompilationUnitGenerator&#60;?&#62; workingCopy = icu.toWorkingCopy(
+ * ICompilationUnit icu = env.requireType(Long.class.getName()).requireCompilationUnit();
+ * ICompilationUnitGenerator&#60;?&#62; workingCopy = icu.toWorkingCopy(
  *     new SimpleWorkingCopyTransformerBuilder()
- *         .withAnnotationMapper(this::transformAnnotation)
+ *         .withAnnotationMapper(this::transformAnnotation) // change SuppressWarnings to 'all'
+ *         .withMethodParameterMapper(IWorkingCopyTransformer::remove) // remove all parameters from methods
  *         .build());
  *
- * private IAnnotationGenerator&#60;?&#62; transformAnnotation(final IAnnotationGenerator&#60;?&#62; gen) {
- *   if (SuppressWarnings.class.getName().equals(gen.elementName().orElse(null))) {
+ * private IAnnotationGenerator&#60;?&#62; transformAnnotation(ITransformInput&#60;IAnnotation, IAnnotationGenerator&#60;?&#62;&#62; input) {
+ *   if (SuppressWarnings.class.getName().equals(input.model().type().name())) {
  *     // modify all suppress-warning annotations to suppress all warnings
- *     gen.withElement("value", b -&#62; b.stringLiteral("all"));
+ *     return input.requestDefaultWorkingCopy().withElement("value", b -&#62; b.stringLiteral("all"));
  *   }
- *   return gen;
+ *   return input.requestDefaultWorkingCopy();
  * }
  * </pre>
  *
@@ -133,11 +126,11 @@ public interface IWorkingCopyTransformer {
    *          The {@link IAnnotation} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link IAnnotationGenerator} to use as working copy for the {@link IAnnotation} specified.
+   * @return The {@link IAnnotationGenerator} to use as working copy for the {@link IAnnotation} specified or an empty
+   *         {@link Optional} if the annotation should be removed.
    */
-  static IAnnotationGenerator<?> transformAnnotation(IAnnotation a, IWorkingCopyTransformer transformer) {
-    return IWorkingCopyTransformer.<IAnnotation, IAnnotationGenerator<?>> transform(transformer, a,
-        () -> AnnotationGenerator.create(a, transformer), (t, i) -> t.transformAnnotation(i));
+  static Optional<IAnnotationGenerator<?>> transformAnnotation(IAnnotation a, IWorkingCopyTransformer transformer) {
+    return transform(transformer, a, () -> a.toWorkingCopy(transformer), (t, i) -> t.transformAnnotation(i));
   }
 
   /**
@@ -147,11 +140,11 @@ public interface IWorkingCopyTransformer {
    *          The {@link ICompilationUnit} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link ICompilationUnitGenerator} to use as working copy for the {@link ICompilationUnit} specified.
+   * @return The {@link ICompilationUnitGenerator} to use as working copy for the {@link ICompilationUnit} specified or
+   *         an empty {@link Optional} if the compilation unit should be removed.
    */
-  static ICompilationUnitGenerator<?> transformCompilationUnit(ICompilationUnit icu, IWorkingCopyTransformer transformer) {
-    return IWorkingCopyTransformer.<ICompilationUnit, ICompilationUnitGenerator<?>> transform(transformer, icu,
-        () -> CompilationUnitGenerator.create(icu, transformer), (t, i) -> t.transformCompilationUnit(i));
+  static Optional<ICompilationUnitGenerator<?>> transformCompilationUnit(ICompilationUnit icu, IWorkingCopyTransformer transformer) {
+    return transform(transformer, icu, () -> icu.toWorkingCopy(transformer), (t, i) -> t.transformCompilationUnit(i));
   }
 
   /**
@@ -161,11 +154,11 @@ public interface IWorkingCopyTransformer {
    *          The {@link ITypeParameter} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link ITypeParameterGenerator} to use as working copy for the {@link ITypeParameter} specified.
+   * @return The {@link ITypeParameterGenerator} to use as working copy for the {@link ITypeParameter} specified or an
+   *         empty {@link Optional} if the type parameter should be removed.
    */
-  static ITypeParameterGenerator<?> transformTypeParameter(ITypeParameter param, IWorkingCopyTransformer transformer) {
-    return IWorkingCopyTransformer.<ITypeParameter, ITypeParameterGenerator<?>> transform(transformer, param,
-        () -> TypeParameterGenerator.create(param), (t, i) -> t.transformTypeParameter(i));
+  static Optional<ITypeParameterGenerator<?>> transformTypeParameter(ITypeParameter param, IWorkingCopyTransformer transformer) {
+    return transform(transformer, param, () -> param.toWorkingCopy(transformer), (t, i) -> t.transformTypeParameter(i));
   }
 
   /**
@@ -175,11 +168,11 @@ public interface IWorkingCopyTransformer {
    *          The {@link IMethodParameter} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link IMethodParameterGenerator} to use as working copy for the {@link IMethodParameter} specified.
+   * @return The {@link IMethodParameterGenerator} to use as working copy for the {@link IMethodParameter} specified or
+   *         an empty {@link Optional} if the parameter should be removed.
    */
-  static IMethodParameterGenerator<?> transformMethodParameter(IMethodParameter mp, IWorkingCopyTransformer transformer) {
-    return IWorkingCopyTransformer.<IMethodParameter, IMethodParameterGenerator<?>> transform(transformer, mp,
-        () -> MethodParameterGenerator.create(mp, transformer), (t, i) -> t.transformMethodParameter(i));
+  static Optional<IMethodParameterGenerator<?>> transformMethodParameter(IMethodParameter mp, IWorkingCopyTransformer transformer) {
+    return transform(transformer, mp, () -> mp.toWorkingCopy(transformer), (t, i) -> t.transformMethodParameter(i));
   }
 
   /**
@@ -189,11 +182,11 @@ public interface IWorkingCopyTransformer {
    *          The {@link IField} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link IFieldGenerator} to use as working copy for the {@link IField} specified.
+   * @return The {@link IFieldGenerator} to use as working copy for the {@link IField} specified or an empty
+   *         {@link Optional} if the field should be removed.
    */
-  static IFieldGenerator<?> transformField(IField f, IWorkingCopyTransformer transformer) {
-    return IWorkingCopyTransformer.<IField, IFieldGenerator<?>> transform(transformer, f,
-        () -> FieldGenerator.create(f, transformer), (t, i) -> t.transformField(i));
+  static Optional<IFieldGenerator<?>> transformField(IField f, IWorkingCopyTransformer transformer) {
+    return transform(transformer, f, () -> f.toWorkingCopy(transformer), (t, i) -> t.transformField(i));
   }
 
   /**
@@ -203,11 +196,11 @@ public interface IWorkingCopyTransformer {
    *          The {@link IMethod} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link IMethodGenerator} to use as working copy for the {@link IMethod} specified.
+   * @return The {@link IMethodGenerator} to use as working copy for the {@link IMethod} specified or an empty
+   *         {@link Optional} if the method should be removed.
    */
-  static IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> transformMethod(IMethod m, IWorkingCopyTransformer transformer) {
-    return IWorkingCopyTransformer.<IMethod, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> transform(transformer, m,
-        () -> MethodGenerator.create(m, transformer), (t, i) -> t.transformMethod(i));
+  static Optional<IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> transformMethod(IMethod m, IWorkingCopyTransformer transformer) {
+    return transform(transformer, m, () -> m.toWorkingCopy(transformer), (t, i) -> t.transformMethod(i));
   }
 
   /**
@@ -217,11 +210,11 @@ public interface IWorkingCopyTransformer {
    *          The {@link IType} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link ITypeGenerator} to use as working copy for the {@link IType} specified.
+   * @return The {@link ITypeGenerator} to use as working copy for the {@link IType} specified or an empty
+   *         {@link Optional} if the type should be removed.
    */
-  static ITypeGenerator<?> transformType(IType type, IWorkingCopyTransformer transformer) {
-    return IWorkingCopyTransformer.<IType, ITypeGenerator<?>> transform(transformer, type,
-        () -> TypeGenerator.create(type, transformer).setDeclaringFullyQualifiedName(type.qualifier()), (t, i) -> t.transformType(i));
+  static Optional<ITypeGenerator<?>> transformType(IType type, IWorkingCopyTransformer transformer) {
+    return transform(transformer, type, () -> type.toWorkingCopy(transformer), (t, i) -> t.transformType(i));
   }
 
   /**
@@ -231,15 +224,12 @@ public interface IWorkingCopyTransformer {
    *          The {@link IUnresolvedType} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link ITypeGenerator} to use as working copy for the {@link IUnresolvedType} specified.
+   * @return The {@link ITypeGenerator} to use as working copy for the {@link IUnresolvedType} specified or an empty
+   *         {@link Optional} if the type should be removed.
    */
-  static ITypeGenerator<?> transformUnresolvedType(IUnresolvedType ut, IWorkingCopyTransformer transformer) {
-    return IWorkingCopyTransformer.<IUnresolvedType, ITypeGenerator<?>> transform(transformer, ut,
-        () -> ut.type()
-            .<ITypeGenerator<?>> map(t -> TypeGenerator.create(t, transformer))
-            .orElseGet(() -> TypeGenerator.create()
-                .setDeclaringFullyQualifiedName(JavaTypes.qualifier(ut.name().replace(JavaTypes.C_DOLLAR, JavaTypes.C_DOT)))
-                .withElementName(ut.elementName())),
+  static Optional<ITypeGenerator<?>> transformUnresolvedType(IUnresolvedType ut, IWorkingCopyTransformer transformer) {
+    return transform(transformer, ut,
+        () -> ut.toWorkingCopy(transformer),
         (t, i) -> t.transformUnresolvedType(i));
   }
 
@@ -250,10 +240,10 @@ public interface IWorkingCopyTransformer {
    *          The {@link IPackage} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link String} to use as package (without package key word and semicolon). May be {@code null} if the
-   *         default package should be used.
+   * @return The {@link String} to use as package (without package key word and semicolon) or an empty {@link Optional}
+   *         if the package should be removed (move to the default package).
    */
-  static String transformPackage(IPackage p, IWorkingCopyTransformer transformer) {
+  static Optional<String> transformPackage(IPackage p, IWorkingCopyTransformer transformer) {
     return transform(transformer, p, p::elementName, (t, i) -> t.transformPackage(i));
   }
 
@@ -264,11 +254,14 @@ public interface IWorkingCopyTransformer {
    *          The {@link IAnnotationElement} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link ISourceGenerator} to use as working copy for the {@link IAnnotationElement} specified.
+   * @return The {@link ISourceGenerator} to use as working copy for the value (without annotation element name and
+   *         equal sign) of the {@link IAnnotationElement} specified or an empty {@link Optional} if the element should
+   *         be removed.
    */
-  static ISourceGenerator<IExpressionBuilder<?>> transformAnnotationElement(IAnnotationElement ae, IWorkingCopyTransformer transformer) {
+  static Optional<ISourceGenerator<IExpressionBuilder<?>>> transformAnnotationElement(IAnnotationElement ae, IWorkingCopyTransformer transformer) {
     return transform(transformer, ae,
-        () -> ae.value().toWorkingCopy(transformer), (t, i) -> t.transformAnnotationElement(i));
+        () -> ae.value().toWorkingCopy(transformer),
+        (t, i) -> t.transformAnnotationElement(i));
   }
 
   /**
@@ -278,11 +271,11 @@ public interface IWorkingCopyTransformer {
    *          The {@link IImport} to transform. Must not be {@code null}.
    * @param transformer
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
-   * @return The {@link CharSequence} to use as import (without import key word and semicolon). Must not be
-   *         {@code null}.
+   * @return The {@link CharSequence} to use as import (without import key word and semicolon) or an empty
+   *         {@link Optional} if the import should be removed.
    */
-  static CharSequence transformImport(IImport imp, IWorkingCopyTransformer transformer) {
-    return IWorkingCopyTransformer.<IImport, CharSequence> transform(transformer, imp, imp::name, (t, i) -> t.transformImport(i));
+  static Optional<CharSequence> transformImport(IImport imp, IWorkingCopyTransformer transformer) {
+    return transform(transformer, imp, imp::name, (t, i) -> t.transformImport(i));
   }
 
   /**
@@ -292,18 +285,50 @@ public interface IWorkingCopyTransformer {
    *          The transformer to use. May be {@code null} if a default transformation should be performed.
    * @param model
    *          The model object to transform. May not be {@code null}.
-   * @param generatorSupplier
+   * @param defaultGeneratorSupplier
    *          {@link Supplier} to create a default transformer.
    * @param transformerCall
    *          The transformation call to execute if a transformer is present. The inputs of the {@link BiFunction} are
    *          never {@code null}.
-   * @return The transformed model.
+   * @return The transformed model or an empty {@link Optional} if the model element should not be generated at all.
    */
-  static <M extends IJavaElement, G> G transform(IWorkingCopyTransformer transformer, M model, Supplier<G> generatorSupplier,
+  static <M extends IJavaElement, G> Optional<G> transform(IWorkingCopyTransformer transformer, M model, Supplier<G> defaultGeneratorSupplier,
       BiFunction<IWorkingCopyTransformer, ITransformInput<M, G>, G> transformerCall) {
-    return Optional.ofNullable(transformer)
-        .map(t -> transformerCall.apply(t, new TransformInput<>(model, generatorSupplier)))
-        .orElseGet(generatorSupplier);
+    if (transformer == null) {
+      return Optional.of(defaultGeneratorSupplier.get()); // default transformers are not allowed to return a null generator
+    }
+    return Optional.ofNullable(transformerCall.apply(transformer, new TransformInput<>(model, defaultGeneratorSupplier)));
+  }
+
+  /**
+   * This function may be used as reference to remove elements during transformation.
+   * <p>
+   * <b>Example:</b>
+   * <p>
+   * 
+   * <pre>
+   * IWorkingCopyTransformer transformer = new SimpleWorkingCopyTransformerBuilder()
+   *     .withMethodParameterMapper(IWorkingCopyTransformer::remove) // remove all method parameters
+   *     .build();
+   * </pre>
+   * 
+   * @param input
+   *          The input element to remove.
+   * @param <G>
+   * @return always {@code null} which removes the element.
+   */
+  static <G> G remove(ITransformInput<?, G> input) {
+    return null; // removes the element
+  }
+
+  /**
+   * This method can be called if an {@link IWorkingCopyTransformer} would like to completely remove an element.
+   * 
+   * @param <G>
+   * @return always {@code null} which removes the element.
+   */
+  default <G> G remove() {
+    return remove(null);
   }
 
   /**
@@ -314,8 +339,8 @@ public interface IWorkingCopyTransformer {
    * @param input
    *          The transformation input providing the source {@link IAnnotation} and a default
    *          {@link IAnnotationGenerator}. Is never {@code null}.
-   * @return The {@link IAnnotationGenerator} to use as working copy for the {@link IAnnotation}. Must not be
-   *         {@code null}.
+   * @return The {@link IAnnotationGenerator} to use as working copy for the {@link IAnnotation}. May be {@code null} if
+   *         the annotation should be removed (use {@link #remove()}).
    */
   IAnnotationGenerator<?> transformAnnotation(ITransformInput<IAnnotation, IAnnotationGenerator<?>> input);
 
@@ -327,8 +352,8 @@ public interface IWorkingCopyTransformer {
    * @param input
    *          The transformation input providing the source {@link ICompilationUnit} and a default
    *          {@link ICompilationUnitGenerator}. Is never {@code null}.
-   * @return The {@link ICompilationUnitGenerator} to use as working copy for the {@link ICompilationUnit}. Must not be
-   *         {@code null}.
+   * @return The {@link ICompilationUnitGenerator} to use as working copy for the {@link ICompilationUnit}. May be
+   *         {@code null} if the compilation unit should be removed (use {@link #remove()}).
    */
   ICompilationUnitGenerator<?> transformCompilationUnit(ITransformInput<ICompilationUnit, ICompilationUnitGenerator<?>> input);
 
@@ -340,8 +365,8 @@ public interface IWorkingCopyTransformer {
    * @param input
    *          The transformation input providing the source {@link ITypeParameter} and a default
    *          {@link ITypeParameterGenerator}. Is never {@code null}.
-   * @return The {@link ITypeParameterGenerator} to use as working copy for the {@link ITypeParameter}. Must not be
-   *         {@code null}.
+   * @return The {@link ITypeParameterGenerator} to use as working copy for the {@link ITypeParameter}. May be
+   *         {@code null} if the type parameter should be removed (use {@link #remove()}).
    */
   ITypeParameterGenerator<?> transformTypeParameter(ITransformInput<ITypeParameter, ITypeParameterGenerator<?>> input);
 
@@ -353,8 +378,8 @@ public interface IWorkingCopyTransformer {
    * @param input
    *          The transformation input providing the source {@link IMethodParameter} and a default
    *          {@link IMethodParameterGenerator}. Is never {@code null}.
-   * @return The {@link IMethodParameterGenerator} to use as working copy for the {@link IMethodParameter}. Must not be
-   *         {@code null}.
+   * @return The {@link IMethodParameterGenerator} to use as working copy for the {@link IMethodParameter}. May be
+   *         {@code null} if the method parameter should be removed (use {@link #remove()}).
    */
   IMethodParameterGenerator<?> transformMethodParameter(ITransformInput<IMethodParameter, IMethodParameterGenerator<?>> input);
 
@@ -366,7 +391,8 @@ public interface IWorkingCopyTransformer {
    * @param input
    *          The transformation input providing the source {@link IField} and a default {@link IFieldGenerator}. Is
    *          never {@code null}.
-   * @return The {@link IFieldGenerator} to use as working copy for the {@link IField}. Must not be {@code null}.
+   * @return The {@link IFieldGenerator} to use as working copy for the {@link IField}. May be {@code null} if the field
+   *         should be removed (use {@link #remove()}).
    */
   IFieldGenerator<?> transformField(ITransformInput<IField, IFieldGenerator<?>> input);
 
@@ -378,7 +404,8 @@ public interface IWorkingCopyTransformer {
    * @param input
    *          The transformation input providing the source {@link IMethod} and a default {@link IMethodGenerator}. Is
    *          never {@code null}.
-   * @return The {@link IMethodGenerator} to use as working copy for the {@link IMethod}. Must not be {@code null}.
+   * @return The {@link IMethodGenerator} to use as working copy for the {@link IMethod}. May be {@code null} if the
+   *         method should be removed (use {@link #remove()}).
    */
   IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> transformMethod(ITransformInput<IMethod, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> input);
 
@@ -390,7 +417,8 @@ public interface IWorkingCopyTransformer {
    * @param input
    *          The transformation input providing the source {@link IType} and a default {@link ITypeGenerator}. Is never
    *          {@code null}.
-   * @return The {@link ITypeGenerator} to use as working copy for the {@link IType}. Must not be {@code null}.
+   * @return The {@link ITypeGenerator} to use as working copy for the {@link IType}. May be {@code null} if the type
+   *         should be removed (use {@link #remove()}).
    */
   ITypeGenerator<?> transformType(ITransformInput<IType, ITypeGenerator<?>> input);
 
@@ -402,8 +430,8 @@ public interface IWorkingCopyTransformer {
    * @param input
    *          The transformation input providing the source {@link IUnresolvedType} and a default
    *          {@link ITypeGenerator}. Is never {@code null}.
-   * @return The {@link ITypeGenerator} to use as working copy for the {@link IUnresolvedType}. Must not be
-   *         {@code null}.
+   * @return The {@link ITypeGenerator} to use as working copy for the {@link IUnresolvedType}. May be {@code null} if
+   *         the annotation should be removed (use {@link #remove()}).
    */
   ITypeGenerator<?> transformUnresolvedType(ITransformInput<IUnresolvedType, ITypeGenerator<?>> input);
 
@@ -426,8 +454,8 @@ public interface IWorkingCopyTransformer {
    * @param input
    *          The transformation input providing the source {@link IAnnotationElement} and a default
    *          {@link ISourceGenerator}. Is never {@code null}.
-   * @return The {@link ISourceGenerator} to use as working copy for the {@link IAnnotationElement}. Must not be
-   *         {@code null}.
+   * @return The {@link ISourceGenerator} to use as working copy for the {@link IAnnotationElement}. May be {@code null}
+   *         if the annotation element should be removed (use {@link #remove()}).
    */
   ISourceGenerator<IExpressionBuilder<?>> transformAnnotationElement(ITransformInput<IAnnotationElement, ISourceGenerator<IExpressionBuilder<?>>> input);
 
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/transformer/SimpleWorkingCopyTransformerBuilder.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/transformer/SimpleWorkingCopyTransformerBuilder.java
index 5bd0e0ab2..8e2c17137 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/transformer/SimpleWorkingCopyTransformerBuilder.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/transformer/SimpleWorkingCopyTransformerBuilder.java
@@ -21,6 +21,7 @@ import org.eclipse.scout.sdk.core.generator.compilationunit.ICompilationUnitGene
 import org.eclipse.scout.sdk.core.generator.field.IFieldGenerator;
 import org.eclipse.scout.sdk.core.generator.method.IMethodGenerator;
 import org.eclipse.scout.sdk.core.generator.methodparam.IMethodParameterGenerator;
+import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.ITransformInput;
 import org.eclipse.scout.sdk.core.generator.type.ITypeGenerator;
 import org.eclipse.scout.sdk.core.generator.typeparam.ITypeParameterGenerator;
 import org.eclipse.scout.sdk.core.model.api.IAnnotation;
@@ -28,6 +29,7 @@ import org.eclipse.scout.sdk.core.model.api.IAnnotationElement;
 import org.eclipse.scout.sdk.core.model.api.ICompilationUnit;
 import org.eclipse.scout.sdk.core.model.api.IField;
 import org.eclipse.scout.sdk.core.model.api.IImport;
+import org.eclipse.scout.sdk.core.model.api.IJavaElement;
 import org.eclipse.scout.sdk.core.model.api.IMethod;
 import org.eclipse.scout.sdk.core.model.api.IMethodParameter;
 import org.eclipse.scout.sdk.core.model.api.IPackage;
@@ -45,119 +47,119 @@ import org.eclipse.scout.sdk.core.model.api.IUnresolvedType;
  */
 public class SimpleWorkingCopyTransformerBuilder {
 
-  private Function<IAnnotationGenerator<?>, IAnnotationGenerator<?>> m_annotationMapper = Function.identity();
-  private Function<ICompilationUnitGenerator<?>, ICompilationUnitGenerator<?>> m_compilationUnitMapper = Function.identity();
-  private Function<ITypeParameterGenerator<?>, ITypeParameterGenerator<?>> m_typeParameterMapper = Function.identity();
-  private Function<IMethodParameterGenerator<?>, IMethodParameterGenerator<?>> m_methodParameterMapper = Function.identity();
-  private Function<IFieldGenerator<?>, IFieldGenerator<?>> m_fieldMapper = Function.identity();
-  private Function<IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> m_methodMapper = Function.identity();
-  private Function<ITypeGenerator<?>, ITypeGenerator<?>> m_typeMapper = Function.identity();
-  private Function<ITypeGenerator<?>, ITypeGenerator<?>> m_unresolvedTypeMapper = Function.identity();
-  private Function<String, String> m_packageMapper = Function.identity();
-  private Function<ISourceGenerator<IExpressionBuilder<?>>, ISourceGenerator<IExpressionBuilder<?>>> m_annotationElementMapper = Function.identity();
-  private Function<CharSequence, CharSequence> m_importMapper = Function.identity();
-
-  public Function<IAnnotationGenerator<?>, IAnnotationGenerator<?>> annotationMapper() {
+  private Function<ITransformInput<IAnnotation, IAnnotationGenerator<?>>, IAnnotationGenerator<?>> m_annotationMapper = ITransformInput::requestDefaultWorkingCopy;
+  private Function<ITransformInput<ICompilationUnit, ICompilationUnitGenerator<?>>, ICompilationUnitGenerator<?>> m_compilationUnitMapper = ITransformInput::requestDefaultWorkingCopy;
+  private Function<ITransformInput<ITypeParameter, ITypeParameterGenerator<?>>, ITypeParameterGenerator<?>> m_typeParameterMapper = ITransformInput::requestDefaultWorkingCopy;
+  private Function<ITransformInput<IMethodParameter, IMethodParameterGenerator<?>>, IMethodParameterGenerator<?>> m_methodParameterMapper = ITransformInput::requestDefaultWorkingCopy;
+  private Function<ITransformInput<IField, IFieldGenerator<?>>, IFieldGenerator<?>> m_fieldMapper = ITransformInput::requestDefaultWorkingCopy;
+  private Function<ITransformInput<IMethod, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>>, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> m_methodMapper = ITransformInput::requestDefaultWorkingCopy;
+  private Function<ITransformInput<IType, ITypeGenerator<?>>, ITypeGenerator<?>> m_typeMapper = ITransformInput::requestDefaultWorkingCopy;
+  private Function<ITransformInput<IUnresolvedType, ITypeGenerator<?>>, ITypeGenerator<?>> m_unresolvedTypeMapper = ITransformInput::requestDefaultWorkingCopy;
+  private Function<ITransformInput<IPackage, String>, String> m_packageMapper = ITransformInput::requestDefaultWorkingCopy;
+  private Function<ITransformInput<IAnnotationElement, ISourceGenerator<IExpressionBuilder<?>>>, ISourceGenerator<IExpressionBuilder<?>>> m_annotationElementMapper = ITransformInput::requestDefaultWorkingCopy;
+  private Function<ITransformInput<IImport, CharSequence>, CharSequence> m_importMapper = ITransformInput::requestDefaultWorkingCopy;
+
+  public Function<ITransformInput<IAnnotation, IAnnotationGenerator<?>>, IAnnotationGenerator<?>> annotationMapper() {
     return m_annotationMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withAnnotationMapper(Function<IAnnotationGenerator<?>, IAnnotationGenerator<?>> annotationFunction) {
-    m_annotationMapper = identityIfNull(annotationFunction);
+  public SimpleWorkingCopyTransformerBuilder withAnnotationMapper(Function<ITransformInput<IAnnotation, IAnnotationGenerator<?>>, IAnnotationGenerator<?>> annotationFunction) {
+    m_annotationMapper = defaultIfNull(annotationFunction);
     return this;
   }
 
-  public Function<ICompilationUnitGenerator<?>, ICompilationUnitGenerator<?>> compilationUnitMapper() {
+  public Function<ITransformInput<ICompilationUnit, ICompilationUnitGenerator<?>>, ICompilationUnitGenerator<?>> compilationUnitMapper() {
     return m_compilationUnitMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withCompilationUnitMapper(Function<ICompilationUnitGenerator<?>, ICompilationUnitGenerator<?>> compilationUnitFunction) {
-    m_compilationUnitMapper = identityIfNull(compilationUnitFunction);
+  public SimpleWorkingCopyTransformerBuilder withCompilationUnitMapper(Function<ITransformInput<ICompilationUnit, ICompilationUnitGenerator<?>>, ICompilationUnitGenerator<?>> compilationUnitFunction) {
+    m_compilationUnitMapper = defaultIfNull(compilationUnitFunction);
     return this;
   }
 
-  public Function<ITypeParameterGenerator<?>, ITypeParameterGenerator<?>> typeParameterMapper() {
+  public Function<ITransformInput<ITypeParameter, ITypeParameterGenerator<?>>, ITypeParameterGenerator<?>> typeParameterMapper() {
     return m_typeParameterMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withTypeParameterMapper(Function<ITypeParameterGenerator<?>, ITypeParameterGenerator<?>> typeParameterFunction) {
-    m_typeParameterMapper = identityIfNull(typeParameterFunction);
+  public SimpleWorkingCopyTransformerBuilder withTypeParameterMapper(Function<ITransformInput<ITypeParameter, ITypeParameterGenerator<?>>, ITypeParameterGenerator<?>> typeParameterFunction) {
+    m_typeParameterMapper = defaultIfNull(typeParameterFunction);
     return this;
   }
 
-  public Function<IMethodParameterGenerator<?>, IMethodParameterGenerator<?>> methodParameterMapper() {
+  public Function<ITransformInput<IMethodParameter, IMethodParameterGenerator<?>>, IMethodParameterGenerator<?>> methodParameterMapper() {
     return m_methodParameterMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withMethodParameterMapper(Function<IMethodParameterGenerator<?>, IMethodParameterGenerator<?>> methodParameterFunction) {
-    m_methodParameterMapper = identityIfNull(methodParameterFunction);
+  public SimpleWorkingCopyTransformerBuilder withMethodParameterMapper(Function<ITransformInput<IMethodParameter, IMethodParameterGenerator<?>>, IMethodParameterGenerator<?>> methodParameterFunction) {
+    m_methodParameterMapper = defaultIfNull(methodParameterFunction);
     return this;
   }
 
-  public Function<IFieldGenerator<?>, IFieldGenerator<?>> fieldMapper() {
+  public Function<ITransformInput<IField, IFieldGenerator<?>>, IFieldGenerator<?>> fieldMapper() {
     return m_fieldMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withFieldMapper(Function<IFieldGenerator<?>, IFieldGenerator<?>> fieldFunction) {
-    m_fieldMapper = identityIfNull(fieldFunction);
+  public SimpleWorkingCopyTransformerBuilder withFieldMapper(Function<ITransformInput<IField, IFieldGenerator<?>>, IFieldGenerator<?>> fieldFunction) {
+    m_fieldMapper = defaultIfNull(fieldFunction);
     return this;
   }
 
-  public Function<IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> methodMapper() {
+  public Function<ITransformInput<IMethod, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>>, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> methodMapper() {
     return m_methodMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withMethodMapper(Function<IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> methodFunction) {
-    m_methodMapper = identityIfNull(methodFunction);
+  public SimpleWorkingCopyTransformerBuilder withMethodMapper(Function<ITransformInput<IMethod, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>>, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> methodFunction) {
+    m_methodMapper = defaultIfNull(methodFunction);
     return this;
   }
 
-  public Function<ITypeGenerator<?>, ITypeGenerator<?>> typeMapper() {
+  public Function<ITransformInput<IType, ITypeGenerator<?>>, ITypeGenerator<?>> typeMapper() {
     return m_typeMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withTypeMapper(Function<ITypeGenerator<?>, ITypeGenerator<?>> typeFunction) {
-    m_typeMapper = identityIfNull(typeFunction);
+  public SimpleWorkingCopyTransformerBuilder withTypeMapper(Function<ITransformInput<IType, ITypeGenerator<?>>, ITypeGenerator<?>> typeFunction) {
+    m_typeMapper = defaultIfNull(typeFunction);
     return this;
   }
 
-  public Function<ITypeGenerator<?>, ITypeGenerator<?>> unresolvedTypeMapper() {
+  public Function<ITransformInput<IUnresolvedType, ITypeGenerator<?>>, ITypeGenerator<?>> unresolvedTypeMapper() {
     return m_unresolvedTypeMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withUnresolvedTypeMapper(Function<ITypeGenerator<?>, ITypeGenerator<?>> unresolvedTypeFunction) {
-    m_unresolvedTypeMapper = identityIfNull(unresolvedTypeFunction);
+  public SimpleWorkingCopyTransformerBuilder withUnresolvedTypeMapper(Function<ITransformInput<IUnresolvedType, ITypeGenerator<?>>, ITypeGenerator<?>> unresolvedTypeFunction) {
+    m_unresolvedTypeMapper = defaultIfNull(unresolvedTypeFunction);
     return this;
   }
 
-  public Function<String, String> packageMapper() {
+  public Function<ITransformInput<IPackage, String>, String> packageMapper() {
     return m_packageMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withPackageMapper(Function<String, String> packageFunction) {
-    m_packageMapper = identityIfNull(packageFunction);
+  public SimpleWorkingCopyTransformerBuilder withPackageMapper(Function<ITransformInput<IPackage, String>, String> packageFunction) {
+    m_packageMapper = defaultIfNull(packageFunction);
     return this;
   }
 
-  public Function<ISourceGenerator<IExpressionBuilder<?>>, ISourceGenerator<IExpressionBuilder<?>>> annotationElementMapper() {
+  public Function<ITransformInput<IAnnotationElement, ISourceGenerator<IExpressionBuilder<?>>>, ISourceGenerator<IExpressionBuilder<?>>> annotationElementMapper() {
     return m_annotationElementMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withAnnotationElementMapper(Function<ISourceGenerator<IExpressionBuilder<?>>, ISourceGenerator<IExpressionBuilder<?>>> annotationElementFunction) {
-    m_annotationElementMapper = identityIfNull(annotationElementFunction);
+  public SimpleWorkingCopyTransformerBuilder withAnnotationElementMapper(Function<ITransformInput<IAnnotationElement, ISourceGenerator<IExpressionBuilder<?>>>, ISourceGenerator<IExpressionBuilder<?>>> annotationElementFunction) {
+    m_annotationElementMapper = defaultIfNull(annotationElementFunction);
     return this;
   }
 
-  public Function<CharSequence, CharSequence> importMapper() {
+  public Function<ITransformInput<IImport, CharSequence>, CharSequence> importMapper() {
     return m_importMapper;
   }
 
-  public SimpleWorkingCopyTransformerBuilder withImportMapper(Function<CharSequence, CharSequence> importFunction) {
-    m_importMapper = identityIfNull(importFunction);
+  public SimpleWorkingCopyTransformerBuilder withImportMapper(Function<ITransformInput<IImport, CharSequence>, CharSequence> importFunction) {
+    m_importMapper = defaultIfNull(importFunction);
     return this;
   }
 
-  protected static <T> Function<T, T> identityIfNull(Function<T, T> candidate) {
-    return Optional.ofNullable(candidate).orElseGet(Function::identity);
+  protected static <M extends IJavaElement, G> Function<ITransformInput<M, G>, G> defaultIfNull(Function<ITransformInput<M, G>, G> candidate) {
+    return Optional.ofNullable(candidate).orElseGet(() -> ITransformInput::requestDefaultWorkingCopy);
   }
 
   @SuppressWarnings("ReturnOfInnerClass")
@@ -166,57 +168,57 @@ public class SimpleWorkingCopyTransformerBuilder {
 
       @Override
       public IAnnotationGenerator<?> transformAnnotation(ITransformInput<IAnnotation, IAnnotationGenerator<?>> input) {
-        return annotationMapper().apply(input.requestDefaultWorkingCopy());
+        return annotationMapper().apply(input);
       }
 
       @Override
       public ICompilationUnitGenerator<?> transformCompilationUnit(ITransformInput<ICompilationUnit, ICompilationUnitGenerator<?>> input) {
-        return compilationUnitMapper().apply(input.requestDefaultWorkingCopy());
+        return compilationUnitMapper().apply(input);
       }
 
       @Override
       public ITypeParameterGenerator<?> transformTypeParameter(ITransformInput<ITypeParameter, ITypeParameterGenerator<?>> input) {
-        return typeParameterMapper().apply(input.requestDefaultWorkingCopy());
+        return typeParameterMapper().apply(input);
       }
 
       @Override
       public IMethodParameterGenerator<?> transformMethodParameter(ITransformInput<IMethodParameter, IMethodParameterGenerator<?>> input) {
-        return methodParameterMapper().apply(input.requestDefaultWorkingCopy());
+        return methodParameterMapper().apply(input);
       }
 
       @Override
       public IFieldGenerator<?> transformField(ITransformInput<IField, IFieldGenerator<?>> input) {
-        return fieldMapper().apply(input.requestDefaultWorkingCopy());
+        return fieldMapper().apply(input);
       }
 
       @Override
       public IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> transformMethod(ITransformInput<IMethod, IMethodGenerator<?, ? extends IMethodBodyBuilder<?>>> input) {
-        return methodMapper().apply(input.requestDefaultWorkingCopy());
+        return methodMapper().apply(input);
       }
 
       @Override
       public ITypeGenerator<?> transformType(ITransformInput<IType, ITypeGenerator<?>> input) {
-        return typeMapper().apply(input.requestDefaultWorkingCopy());
+        return typeMapper().apply(input);
       }
 
       @Override
       public ITypeGenerator<?> transformUnresolvedType(ITransformInput<IUnresolvedType, ITypeGenerator<?>> input) {
-        return unresolvedTypeMapper().apply(input.requestDefaultWorkingCopy());
+        return unresolvedTypeMapper().apply(input);
       }
 
       @Override
       public String transformPackage(ITransformInput<IPackage, String> input) {
-        return packageMapper().apply(input.requestDefaultWorkingCopy());
+        return packageMapper().apply(input);
       }
 
       @Override
       public ISourceGenerator<IExpressionBuilder<?>> transformAnnotationElement(ITransformInput<IAnnotationElement, ISourceGenerator<IExpressionBuilder<?>>> input) {
-        return annotationElementMapper().apply(input.requestDefaultWorkingCopy());
+        return annotationElementMapper().apply(input);
       }
 
       @Override
       public CharSequence transformImport(ITransformInput<IImport, CharSequence> input) {
-        return importMapper().apply(input.requestDefaultWorkingCopy());
+        return importMapper().apply(input);
       }
     };
   }
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/ITypeGenerator.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/ITypeGenerator.java
index 960158303..eeda4d3a4 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/ITypeGenerator.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/ITypeGenerator.java
@@ -346,7 +346,7 @@ public interface ITypeGenerator<TYPE extends ITypeGenerator<TYPE>> extends IMemb
    * <p>
    * <b>Example:</b> See {@link IWorkingCopyTransformer}.
    *
-   * @param callbackForMehtodsAdded
+   * @param callbackForMethodsAdded
    *          Optional callback that is invoked for each missing method that is generated. May be {@code null}.<br>
    *          The {@link IWorkingCopyTransformer} is called for each {@link IJavaElement} in every method that is
    *          created. The corresponding {@link ITransformInput}s default working copy (see
@@ -366,7 +366,7 @@ public interface ITypeGenerator<TYPE extends ITypeGenerator<TYPE>> extends IMemb
    * @see DefaultWorkingCopyTransformer
    * @see SimpleWorkingCopyTransformerBuilder
    */
-  TYPE withAllMethodsImplemented(IWorkingCopyTransformer callbackForMehtodsAdded);
+  TYPE withAllMethodsImplemented(IWorkingCopyTransformer callbackForMethodsAdded);
 
   /**
    * Instructs this {@link ITypeGenerator} to not automatically add missing methods. This is the default.
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/PrimaryTypeGenerator.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/PrimaryTypeGenerator.java
index fe5363c99..fae00a42b 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/PrimaryTypeGenerator.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/PrimaryTypeGenerator.java
@@ -400,8 +400,8 @@ public class PrimaryTypeGenerator<TYPE extends PrimaryTypeGenerator<TYPE>> imple
   }
 
   @Override
-  public TYPE withAllMethodsImplemented(IWorkingCopyTransformer callbackForMehtodsAdded) {
-    primary().withAllMethodsImplemented(callbackForMehtodsAdded);
+  public TYPE withAllMethodsImplemented(IWorkingCopyTransformer callbackForMethodsAdded) {
+    primary().withAllMethodsImplemented(callbackForMethodsAdded);
     return currentInstance();
   }
 
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/SortedMemberEntry.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/SortedMemberEntry.java
index 3196966cd..7b9d0057a 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/SortedMemberEntry.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/SortedMemberEntry.java
@@ -22,11 +22,7 @@ import org.eclipse.scout.sdk.core.builder.java.body.IMethodBodyBuilder;
 import org.eclipse.scout.sdk.core.generator.field.IFieldGenerator;
 import org.eclipse.scout.sdk.core.generator.member.IMemberGenerator;
 import org.eclipse.scout.sdk.core.generator.method.IMethodGenerator;
-import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
-import org.eclipse.scout.sdk.core.model.api.IField;
 import org.eclipse.scout.sdk.core.model.api.IJavaElement;
-import org.eclipse.scout.sdk.core.model.api.IMethod;
-import org.eclipse.scout.sdk.core.model.api.IType;
 import org.eclipse.scout.sdk.core.model.api.PropertyBean;
 import org.eclipse.scout.sdk.core.util.CompositeObject;
 import org.eclipse.scout.sdk.core.util.Ensure;
@@ -50,18 +46,6 @@ public class SortedMemberEntry implements Comparable<SortedMemberEntry> {
   private final FinalValue<CompositeObject> m_sortOrder;
   private final long m_index;
 
-  protected SortedMemberEntry(IField origin, IWorkingCopyTransformer transformer) {
-    this(Ensure.notNull(origin).toWorkingCopy(transformer), origin);
-  }
-
-  public SortedMemberEntry(IType origin, IWorkingCopyTransformer transformer) {
-    this(Ensure.notNull(origin).toWorkingCopy(transformer), origin);
-  }
-
-  public SortedMemberEntry(IMethod origin, IWorkingCopyTransformer transformer) {
-    this(Ensure.notNull(origin).toWorkingCopy(transformer), origin);
-  }
-
   public SortedMemberEntry(IMemberGenerator<?> generator, IJavaElement origin) {
     this(generator,
         PARSED_ORDER, origin.source()
@@ -93,7 +77,6 @@ public class SortedMemberEntry implements Comparable<SortedMemberEntry> {
     return m_sortOrder.computeIfAbsentAndGet(this::calculateDefaultOrder);
   }
 
-  @SuppressWarnings("unchecked")
   protected CompositeObject calculateDefaultOrder() {
     IMemberGenerator<?> generator = generator();
     if (isType()) {
@@ -143,7 +126,7 @@ public class SortedMemberEntry implements Comparable<SortedMemberEntry> {
     return sortOrder().equals(other.sortOrder());
   }
 
-  protected static CompositeObject defaultFieldOrder(IFieldGenerator<?> generator, long insertionOrder) {
+  protected static CompositeObject defaultFieldOrder(@SuppressWarnings("TypeMayBeWeakened") IFieldGenerator<?> generator, long insertionOrder) {
     int flags = generator.flags();
     boolean isFinal = isFinal(flags);
     boolean isConstant = isStatic(flags) && isFinal;
@@ -166,7 +149,7 @@ public class SortedMemberEntry implements Comparable<SortedMemberEntry> {
     return new CompositeObject(DEFAULT_ORDER, FIELD_ORDER, pos, insertionOrder);
   }
 
-  protected static CompositeObject defaultTypeOrder(ITypeGenerator<?> generator, long insertionOrder) {
+  protected static CompositeObject defaultTypeOrder(@SuppressWarnings("TypeMayBeWeakened") ITypeGenerator<?> generator, long insertionOrder) {
     int pos;
     int flags = generator.flags();
     if (isPublic(flags)) {
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/TypeGenerator.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/TypeGenerator.java
index 4a8374b1b..7f36b2806 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/TypeGenerator.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/generator/type/TypeGenerator.java
@@ -15,6 +15,10 @@ import static java.util.function.Function.identity;
 import static java.util.stream.Collectors.toCollection;
 import static java.util.stream.Collectors.toList;
 import static java.util.stream.Collectors.toMap;
+import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformField;
+import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformMethod;
+import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformType;
+import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformTypeParameter;
 import static org.eclipse.scout.sdk.core.model.api.Flags.isAbstract;
 import static org.eclipse.scout.sdk.core.model.api.Flags.isAnnotation;
 import static org.eclipse.scout.sdk.core.model.api.Flags.isDefaultMethod;
@@ -97,7 +101,9 @@ public class TypeGenerator<TYPE extends ITypeGenerator<TYPE>> extends AbstractMe
     m_fullyQualifiedName = new FinalValue<>();
     m_qualifier = new FinalValue<>();
     m_typeParameters = type.typeParameters()
-        .map(p -> p.toWorkingCopy(transformer))
+        .map(p -> transformTypeParameter(p, transformer))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
         .collect(toList());
 
     m_superType = type.superClass()
@@ -110,13 +116,22 @@ public class TypeGenerator<TYPE extends ITypeGenerator<TYPE>> extends AbstractMe
 
     m_members = new ArrayList<>();
     type.fields().stream()
-        .map(f -> new SortedMemberEntry(f, transformer))
+        .map(f -> transformField(f, transformer)
+            .map(g -> new SortedMemberEntry(g, f)))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
         .collect(toCollection(() -> m_members));
     type.methods().stream()
-        .map(m -> new SortedMemberEntry(m, transformer))
+        .map(m -> transformMethod(m, transformer)
+            .map(g -> new SortedMemberEntry(g, m)))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
         .collect(toCollection(() -> m_members));
     type.innerTypes().stream()
-        .map(t -> new SortedMemberEntry(t, transformer))
+        .map(t -> transformType(t, transformer)
+            .map(g -> new SortedMemberEntry(g, t)))
+        .filter(Optional::isPresent)
+        .map(Optional::get)
         .peek(s -> applyConnection(s.generator(), this))
         .collect(toCollection(() -> m_members));
 
@@ -145,7 +160,7 @@ public class TypeGenerator<TYPE extends ITypeGenerator<TYPE>> extends AbstractMe
    * @see SimpleWorkingCopyTransformerBuilder
    */
   public static ITypeGenerator<?> create(IType type, IWorkingCopyTransformer transformer) {
-    return new TypeGenerator<>(type, transformer);
+    return new TypeGenerator<>(type, transformer).setDeclaringFullyQualifiedName(type.qualifier());
   }
 
   /**
@@ -431,9 +446,9 @@ public class TypeGenerator<TYPE extends ITypeGenerator<TYPE>> extends AbstractMe
   }
 
   @Override
-  public TYPE withAllMethodsImplemented(IWorkingCopyTransformer callbackForMehtodsAdded) {
+  public TYPE withAllMethodsImplemented(IWorkingCopyTransformer callbackForMethodsAdded) {
     m_addAllNecessaryMehtods = true;
-    m_unimplementedMethodsTransformer = callbackForMehtodsAdded;
+    m_unimplementedMethodsTransformer = callbackForMethodsAdded;
     return currentInstance();
   }
 
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/AbstractMetaValue.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/AbstractMetaValue.java
index 5f10f6adc..0742e351a 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/AbstractMetaValue.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/AbstractMetaValue.java
@@ -10,11 +10,13 @@
  */
 package org.eclipse.scout.sdk.core.model.api;
 
+import static org.eclipse.scout.sdk.core.generator.SimpleGenerators.createMetaValueGenerator;
+
 import java.lang.reflect.Array;
+import java.util.stream.Stream;
 
 import org.eclipse.scout.sdk.core.builder.java.expression.IExpressionBuilder;
 import org.eclipse.scout.sdk.core.generator.ISourceGenerator;
-import org.eclipse.scout.sdk.core.generator.annotation.IAnnotationGenerator;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 
 /**
@@ -33,43 +35,12 @@ public abstract class AbstractMetaValue implements IMetaValue {
 
   @Override
   public ISourceGenerator<IExpressionBuilder<?>> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    switch (type()) {
-      case Null:
-        return b -> b.append("null");
-      case Int:
-        return b -> b.append(as(Integer.class).intValue());
-      case Byte:
-        return b -> b.append(as(Byte.class).byteValue());
-      case Short:
-        return b -> b.append(as(Short.class).shortValue());
-      case Char:
-        return b -> b.append('\'')
-            .append(as(Character.class))
-            .append('\'');
-      case Float:
-        return b -> b.append(as(Float.class))
-            .append('f');
-      case Double:
-        return b -> b.append(as(Double.class).doubleValue());
-      case Bool:
-        return b -> b.append(as(Boolean.class).booleanValue());
-      case Long:
-        return b -> b.append(as(Long.class))
-            .append('L');
-      case String:
-        return b -> b.stringLiteral(as(String.class));
-      case Type:
-        return b -> b.classLiteral(as(IType.class).reference(true));
-      case Enum:
-        IField field = as(IField.class);
-        return b -> b.enumValue(field.declaringType().name(), field.elementName());
-      case Annotation:
-        IAnnotationGenerator<?> annotationGenerator = as(IAnnotation.class).toWorkingCopy(transformer);
-        return b -> b.append(annotationGenerator);
-      // array case is handled in corresponding subclass
-      default:
-        return b -> b.append("UNKNOWN(").append(type().toString()).append(", ").append(toString()).append(')');
-    }
+    return createMetaValueGenerator(this, transformer);
+  }
+
+  @Override
+  public Stream<IJavaElement> children() {
+    return Stream.empty();
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/ArrayMetaValue.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/ArrayMetaValue.java
index 2553d3b50..e51f335e8 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/ArrayMetaValue.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/ArrayMetaValue.java
@@ -10,14 +10,11 @@
  */
 package org.eclipse.scout.sdk.core.model.api;
 
-import static java.util.stream.Collectors.toList;
+import static org.eclipse.scout.sdk.core.generator.SimpleGenerators.createArrayMetaValueGenerator;
 
 import java.lang.reflect.Array;
-import java.util.Arrays;
-import java.util.List;
+import java.util.stream.Stream;
 
-import org.eclipse.scout.sdk.core.builder.ISourceBuilder;
-import org.eclipse.scout.sdk.core.builder.java.expression.ExpressionBuilder;
 import org.eclipse.scout.sdk.core.builder.java.expression.IExpressionBuilder;
 import org.eclipse.scout.sdk.core.generator.ISourceGenerator;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
@@ -43,15 +40,12 @@ public class ArrayMetaValue extends AbstractMetaValue implements IArrayMetaValue
 
   @Override
   public ISourceGenerator<IExpressionBuilder<?>> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    IMetaValue[] metaArray = metaValueArray();
-    List<ISourceGenerator<ISourceBuilder<?>>> generators = Arrays.stream(metaArray)
-        .map(mv -> mv.toWorkingCopy(transformer))
-        .map(g -> g.generalize(ExpressionBuilder::create))
-        .collect(toList());
-
-    // use newlines on multi-dimensional arrays and annotation arrays only
-    boolean useNewlines = metaArray.length > 0 && (metaArray[0].type() == MetaValueType.Array || metaArray[0].type() == MetaValueType.Annotation);
-    return b -> b.array(generators.stream(), useNewlines);
+    return createArrayMetaValueGenerator(this, transformer);
+  }
+
+  @Override
+  public Stream<IJavaElement> children() {
+    return Stream.of(m_metaArray).flatMap(IMetaValue::children);
   }
 
   /**
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/IMetaValue.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/IMetaValue.java
index 5947ea390..e0458ab6a 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/IMetaValue.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/IMetaValue.java
@@ -10,6 +10,8 @@
  */
 package org.eclipse.scout.sdk.core.model.api;
 
+import java.util.stream.Stream;
+
 import org.eclipse.scout.sdk.core.builder.ISourceBuilder;
 import org.eclipse.scout.sdk.core.builder.java.expression.IExpressionBuilder;
 import org.eclipse.scout.sdk.core.generator.ISourceGenerator;
@@ -44,6 +46,12 @@ public interface IMetaValue {
   <T> T as(Class<T> expectedType);
 
   /**
+   * @return A {@link Stream} of {@link IJavaElement}s that are children of this {@link IMetaValue}. The {@link Stream}
+   *         can only contain {@link IAnnotation}s as all oder values are no {@link IJavaElement}s.
+   */
+  Stream<IJavaElement> children();
+
+  /**
    * Converts this {@link IMetaValue} into a {@link ISourceGenerator} that generates source that is structurally equal
    * to this {@link IMetaValue}. This may be a simple scalar value or a complex annotation structure.
    *
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/MetaValueType.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/MetaValueType.java
index e33c204c1..89b938afb 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/MetaValueType.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/MetaValueType.java
@@ -50,7 +50,7 @@ public enum MetaValueType {
    */
   Float,
   /**
-   * {@link IMetaValue#as(Class)} is a {@link Float}
+   * {@link IMetaValue#as(Class)} is a {@link String}
    */
   String,
   /**
@@ -66,7 +66,8 @@ public enum MetaValueType {
    */
   Annotation,
   /**
-   * {@link IMetaValue#as(Class)} is a primitive array int[] or a typed object array such as String[]
+   * {@link IMetaValue#as(Class)} is a primitive array int[] or a typed object array such as String[] or an
+   * {@link IAnnotation} array.
    * <p>
    * The meta value itself is a {@link IArrayMetaValue}
    */
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/AnnotationElementImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/AnnotationElementImplementor.java
index 1f061a8e7..703d7a624 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/AnnotationElementImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/AnnotationElementImplementor.java
@@ -10,14 +10,13 @@
  */
 package org.eclipse.scout.sdk.core.model.api.internal;
 
-import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformAnnotationElement;
+import static org.eclipse.scout.sdk.core.generator.SimpleGenerators.createAnnotationElementGenerator;
 
 import java.util.Optional;
 import java.util.stream.Stream;
 
 import org.eclipse.scout.sdk.core.builder.ISourceBuilder;
 import org.eclipse.scout.sdk.core.builder.java.expression.ExpressionBuilder;
-import org.eclipse.scout.sdk.core.builder.java.expression.IExpressionBuilder;
 import org.eclipse.scout.sdk.core.generator.ISourceGenerator;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.model.api.IAnnotation;
@@ -55,17 +54,12 @@ public class AnnotationElementImplementor extends AbstractJavaElementImplementor
 
   @Override
   public Stream<IJavaElement> children() {
-    return Stream.empty();
+    return value().children();
   }
 
   @Override
   public ISourceGenerator<ISourceBuilder<?>> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    if (isDefault()) {
-      return ISourceGenerator.empty();
-    }
-    ISourceGenerator<IExpressionBuilder<?>> g = b -> b.append(elementName()).equalSign().append(transformAnnotationElement(this, transformer)
-        .generalize(ExpressionBuilder::create));
-    return g.generalize(ExpressionBuilder::create);
+    return createAnnotationElementGenerator(this, transformer).generalize(ExpressionBuilder::create);
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/AnnotationImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/AnnotationImplementor.java
index b7cf3299d..40b25c0bd 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/AnnotationImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/AnnotationImplementor.java
@@ -11,7 +11,6 @@
 package org.eclipse.scout.sdk.core.model.api.internal;
 
 import static java.util.Collections.unmodifiableMap;
-import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformAnnotation;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
@@ -20,6 +19,7 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;
 
+import org.eclipse.scout.sdk.core.generator.annotation.AnnotationGenerator;
 import org.eclipse.scout.sdk.core.generator.annotation.IAnnotationGenerator;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.model.api.AbstractManagedAnnotation;
@@ -91,7 +91,7 @@ public class AnnotationImplementor extends AbstractJavaElementImplementor<Annota
 
   @Override
   public IAnnotationGenerator<?> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    return transformAnnotation(this, transformer);
+    return AnnotationGenerator.create(this, transformer);
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/CompilationUnitImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/CompilationUnitImplementor.java
index b8c41f80b..4134bcb58 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/CompilationUnitImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/CompilationUnitImplementor.java
@@ -16,6 +16,7 @@ import java.nio.file.Path;
 import java.util.Optional;
 import java.util.stream.Stream;
 
+import org.eclipse.scout.sdk.core.generator.compilationunit.CompilationUnitGenerator;
 import org.eclipse.scout.sdk.core.generator.compilationunit.ICompilationUnitGenerator;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.model.api.ICompilationUnit;
@@ -94,7 +95,7 @@ public class CompilationUnitImplementor extends AbstractJavaElementImplementor<C
 
   @Override
   public ICompilationUnitGenerator<?> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    return IWorkingCopyTransformer.transformCompilationUnit(this, transformer);
+    return CompilationUnitGenerator.create(this, transformer);
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/FieldImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/FieldImplementor.java
index 4aeec6553..80fee6740 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/FieldImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/FieldImplementor.java
@@ -10,11 +10,10 @@
  */
 package org.eclipse.scout.sdk.core.model.api.internal;
 
-import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformField;
-
 import java.util.Optional;
 import java.util.stream.Stream;
 
+import org.eclipse.scout.sdk.core.generator.field.FieldGenerator;
 import org.eclipse.scout.sdk.core.generator.field.IFieldGenerator;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.model.api.IAnnotation;
@@ -64,7 +63,7 @@ public class FieldImplementor extends AbstractMemberImplementor<FieldSpi> implem
 
   @Override
   public IFieldGenerator<?> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    return transformField(this, transformer);
+    return FieldGenerator.create(this, transformer);
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/ImportImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/ImportImplementor.java
index 0c9d737e7..6c8090985 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/ImportImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/ImportImplementor.java
@@ -10,8 +10,7 @@
  */
 package org.eclipse.scout.sdk.core.model.api.internal;
 
-import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformImport;
-import static org.eclipse.scout.sdk.core.imports.ImportCollector.createImportDeclaration;
+import static org.eclipse.scout.sdk.core.generator.SimpleGenerators.createImportGenerator;
 
 import java.util.stream.Stream;
 
@@ -56,7 +55,7 @@ public class ImportImplementor extends AbstractJavaElementImplementor<ImportSpi>
 
   @Override
   public ISourceGenerator<ISourceBuilder<?>> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    return ISourceGenerator.raw(createImportDeclaration(isStatic(), transformImport(this, transformer)));
+    return createImportGenerator(this);
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/MethodImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/MethodImplementor.java
index b38bed750..a6509465f 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/MethodImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/MethodImplementor.java
@@ -11,7 +11,6 @@
 package org.eclipse.scout.sdk.core.model.api.internal;
 
 import static java.util.stream.Collectors.toList;
-import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformMethod;
 import static org.eclipse.scout.sdk.core.util.Ensure.newFail;
 
 import java.util.List;
@@ -20,6 +19,7 @@ import java.util.stream.Stream;
 
 import org.eclipse.scout.sdk.core.builder.java.body.IMethodBodyBuilder;
 import org.eclipse.scout.sdk.core.generator.method.IMethodGenerator;
+import org.eclipse.scout.sdk.core.generator.method.MethodGenerator;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.model.api.IAnnotation;
 import org.eclipse.scout.sdk.core.model.api.IJavaElement;
@@ -113,7 +113,7 @@ public class MethodImplementor extends AbstractMemberImplementor<MethodSpi> impl
 
   @Override
   public IMethodGenerator<?, ? extends IMethodBodyBuilder<?>> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    return transformMethod(this, transformer);
+    return MethodGenerator.create(this, transformer);
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/MethodParameterImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/MethodParameterImplementor.java
index e9f1e749e..84480f875 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/MethodParameterImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/MethodParameterImplementor.java
@@ -10,11 +10,10 @@
  */
 package org.eclipse.scout.sdk.core.model.api.internal;
 
-import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformMethodParameter;
-
 import java.util.stream.Stream;
 
 import org.eclipse.scout.sdk.core.generator.methodparam.IMethodParameterGenerator;
+import org.eclipse.scout.sdk.core.generator.methodparam.MethodParameterGenerator;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.model.api.IAnnotation;
 import org.eclipse.scout.sdk.core.model.api.IJavaElement;
@@ -67,7 +66,7 @@ public class MethodParameterImplementor extends AbstractAnnotatableImplementor<M
 
   @Override
   public IMethodParameterGenerator<?> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    return transformMethodParameter(this, transformer);
+    return MethodParameterGenerator.create(this, transformer);
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/PackageImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/PackageImplementor.java
index 0d6da26d7..fb90b76fd 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/PackageImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/PackageImplementor.java
@@ -10,22 +10,20 @@
  */
 package org.eclipse.scout.sdk.core.model.api.internal;
 
-import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformPackage;
+import static org.eclipse.scout.sdk.core.generator.SimpleGenerators.createPackageGenerator;
 
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.stream.Stream;
 
 import org.eclipse.scout.sdk.core.builder.ISourceBuilder;
-import org.eclipse.scout.sdk.core.builder.java.IJavaSourceBuilder;
-import org.eclipse.scout.sdk.core.builder.java.JavaSourceBuilder;
+import org.eclipse.scout.sdk.core.builder.java.expression.ExpressionBuilder;
 import org.eclipse.scout.sdk.core.generator.ISourceGenerator;
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.model.api.IJavaElement;
 import org.eclipse.scout.sdk.core.model.api.IPackage;
 import org.eclipse.scout.sdk.core.model.spi.PackageSpi;
 import org.eclipse.scout.sdk.core.util.JavaTypes;
-import org.eclipse.scout.sdk.core.util.Strings;
 
 public class PackageImplementor extends AbstractJavaElementImplementor<PackageSpi> implements IPackage {
 
@@ -35,15 +33,13 @@ public class PackageImplementor extends AbstractJavaElementImplementor<PackageSp
 
   @Override
   public Path asPath() {
+    //noinspection HardcodedFileSeparator
     return Paths.get(elementName().replace(JavaTypes.C_DOT, '/'));
   }
 
   @Override
   public ISourceGenerator<ISourceBuilder<?>> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    return Strings.notBlank(transformPackage(this, transformer))
-        .<ISourceGenerator<IJavaSourceBuilder<?>>> map(name -> builder -> builder.append("package ").append(name).semicolon())
-        .map(g -> g.generalize(JavaSourceBuilder::create))
-        .orElseGet(ISourceGenerator::empty);
+    return createPackageGenerator(this).generalize(ExpressionBuilder::create);
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/TypeImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/TypeImplementor.java
index 9a2513d51..6de68a637 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/TypeImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/TypeImplementor.java
@@ -11,7 +11,6 @@
 package org.eclipse.scout.sdk.core.model.api.internal;
 
 import static java.util.stream.Collectors.toList;
-import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformType;
 import static org.eclipse.scout.sdk.core.util.Ensure.newFail;
 
 import java.util.Comparator;
@@ -22,6 +21,7 @@ import java.util.stream.Stream;
 
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.generator.type.ITypeGenerator;
+import org.eclipse.scout.sdk.core.generator.type.TypeGenerator;
 import org.eclipse.scout.sdk.core.model.api.Flags;
 import org.eclipse.scout.sdk.core.model.api.IAnnotation;
 import org.eclipse.scout.sdk.core.model.api.ICompilationUnit;
@@ -342,7 +342,7 @@ public class TypeImplementor extends AbstractMemberImplementor<TypeSpi> implemen
 
   @Override
   public ITypeGenerator<?> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    return transformType(this, transformer);
+    return TypeGenerator.create(this, transformer);
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/TypeParameterImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/TypeParameterImplementor.java
index 8b1a0c9bf..326c10709 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/TypeParameterImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/TypeParameterImplementor.java
@@ -10,12 +10,11 @@
  */
 package org.eclipse.scout.sdk.core.model.api.internal;
 
-import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformTypeParameter;
-
 import java.util.stream.Stream;
 
 import org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer;
 import org.eclipse.scout.sdk.core.generator.typeparam.ITypeParameterGenerator;
+import org.eclipse.scout.sdk.core.generator.typeparam.TypeParameterGenerator;
 import org.eclipse.scout.sdk.core.model.api.IJavaElement;
 import org.eclipse.scout.sdk.core.model.api.IMember;
 import org.eclipse.scout.sdk.core.model.api.IType;
@@ -51,7 +50,7 @@ public class TypeParameterImplementor extends AbstractJavaElementImplementor<Typ
 
   @Override
   public ITypeParameterGenerator<?> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    return transformTypeParameter(this, transformer);
+    return TypeParameterGenerator.create(this);
   }
 
   @Override
diff --git a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/UnresolvedTypeImplementor.java b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/UnresolvedTypeImplementor.java
index a2400a960..fb3eb5ccf 100644
--- a/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/UnresolvedTypeImplementor.java
+++ b/org.eclipse.scout.sdk.core/src/main/java/org/eclipse/scout/sdk/core/model/api/internal/UnresolvedTypeImplementor.java
@@ -10,7 +10,7 @@
  */
 package org.eclipse.scout.sdk.core.model.api.internal;
 
-import static org.eclipse.scout.sdk.core.generator.transformer.IWorkingCopyTransformer.transformUnresolvedType;
+import static org.eclipse.scout.sdk.core.generator.SimpleGenerators.createUnresolvedTypeGenerator;
 
 import java.util.Optional;
 import java.util.stream.Stream;
@@ -75,7 +75,7 @@ public class UnresolvedTypeImplementor extends AbstractJavaElementImplementor<Un
 
   @Override
   public ITypeGenerator<?> toWorkingCopy(IWorkingCopyTransformer transformer) {
-    return transformUnresolvedType(this, transformer);
+    return createUnresolvedTypeGenerator(this, transformer);
   }
 
   @Override