use of com.google.devtools.j2objc.translate.EnumRewriter in project j2objc by google.
the class TranslationProcessor method applyMutations.
/**
* Translates a parsed source file, modifying the compilation unit by
* substituting core Java type and method references with iOS equivalents.
* For example, <code>java.lang.Object</code> maps to <code>NSObject</code>,
* and <code>java.lang.String</code> to <code>NSString</code>. The source is
* also modified to add support for iOS memory management, extract inner
* classes, etc.
*/
public static void applyMutations(CompilationUnit unit, CodeReferenceMap deadCodeMap, TimeTracker ticker) {
ticker.push();
// Before: OuterReferenceResolver - OuterReferenceResolver needs the bindings fixed.
new LambdaTypeElementAdder(unit).run();
ticker.tick("LambdaTypeElementAdder");
if (deadCodeMap != null) {
new DeadCodeEliminator(unit, deadCodeMap).run();
ticker.tick("DeadCodeEliminator");
}
new OuterReferenceResolver(unit).run();
ticker.tick("OuterReferenceResolver");
// Update code that has GWT references.
new GwtConverter(unit).run();
ticker.tick("GwtConverter");
// Before: Rewriter - Pruning unreachable statements must happen before
// rewriting labeled break statements.
// Before: InnerClassExtractor - Removes unreachable local classes.
new ConstantBranchPruner(unit).run();
ticker.tick("ConstantBranchPruner");
// Modify AST to be more compatible with Objective C
new Rewriter(unit).run();
ticker.tick("Rewriter");
// Add abstract method stubs.
new AbstractMethodRewriter(unit, deadCodeMap).run();
ticker.tick("AbstractMethodRewriter");
new VariableRenamer(unit).run();
ticker.tick("VariableRenamer");
// Rewrite enhanced for loops into correct C code.
new EnhancedForRewriter(unit).run();
ticker.tick("EnhancedForRewriter");
// Before: Autoboxer - Must generate implementations so autoboxing can be applied to result.
new LambdaRewriter(unit).run();
ticker.tick("LambdaRewriter");
// Add auto-boxing conversions.
new Autoboxer(unit).run();
ticker.tick("Autoboxer");
new InnerClassExtractor(unit).run();
ticker.tick("InnerClassExtractor");
// Generate method shims for classes implementing interfaces that have default methods
new DefaultMethodShimGenerator(unit).run();
ticker.tick("DefaultMethodShimGenerator");
// Normalize init statements
new InitializationNormalizer(unit).run();
ticker.tick("InitializationNormalizer");
// Adds nil_chk calls wherever an expression is dereferenced.
// After: InnerClassExtractor - Cannot handle local classes.
// After: InitializationNormalizer
// Before: LabelRewriter - Control flow analysis requires original Java
// labels.
new NilCheckResolver(unit).run();
ticker.tick("NilCheckResolver");
// Rewrites expressions that would cause unsequenced compile errors.
if (unit.getEnv().options().extractUnsequencedModifications()) {
new UnsequencedExpressionRewriter(unit).run();
ticker.tick("UnsequencedExpressionRewriter");
}
// Rewrites labeled break and continue statements.
unit.accept(new LabelRewriter());
ticker.tick("LabelRewriter");
// Before: ArrayRewriter - Adds ArrayCreation nodes.
// Before: Functionizer - Can't rewrite function arguments.
new VarargsRewriter(unit).run();
ticker.tick("VarargsRewriter");
new JavaCloneWriter(unit).run();
ticker.tick("JavaCloneWriter");
new OcniExtractor(unit, deadCodeMap).run();
ticker.tick("OcniExtractor");
// Before: AnnotationRewriter - Needs AnnotationRewriter to add the
// annotation metadata to the generated package-info type.
PackageInfoRewriter.run(unit);
ticker.tick("PackageInfoRewriter");
// Before: DestructorGenerator - Annotation types need a destructor to
// release the added fields.
new AnnotationRewriter(unit).run();
ticker.tick("AnnotationRewriter");
// Before: Functionizer - Edits constructor invocations before they are
// functionized.
new EnumRewriter(unit).run();
ticker.tick("EnumRewriter");
// Add dealloc/finalize method(s), if necessary. This is done
// after inner class extraction, so that each class releases
// only its own instance variables.
new DestructorGenerator(unit).run();
ticker.tick("DestructorGenerator");
// Before: StaticVarRewriter - Generates static variable access expressions.
new MetadataWriter(unit).run();
ticker.tick("MetadataWriter");
// Before: Functionizer - Needs to rewrite some ClassInstanceCreation nodes
// before Functionizer does.
// Before: StaticVarRewriter, OperatorRewriter - Doesn't know how to handle
// the hasRetainedResult flag on ClassInstanceCreation nodes.
new JavaToIOSMethodTranslator(unit).run();
ticker.tick("JavaToIOSMethodTranslator");
// After: OcniExtractor - So that native methods can be correctly
// functionized.
new Functionizer(unit).run();
ticker.tick("Functionizer");
// After: Functionizer - Edits the qualifier on SuperMethodInvocation nodes.
new SuperMethodInvocationRewriter(unit).run();
ticker.tick("SuperMethodInvocationRewriter");
new OperatorRewriter(unit).run();
ticker.tick("OperatorRewriter");
// After: OperatorRewriter - Static load rewriting needs to happen after
// operator rewriting.
new StaticVarRewriter(unit).run();
ticker.tick("StaticVarRewriter");
// After: StaticVarRewriter, OperatorRewriter - They set the
// hasRetainedResult on ArrayCreation nodes.
new ArrayRewriter(unit).run();
ticker.tick("ArrayRewriter");
new SwitchRewriter(unit).run();
ticker.tick("SwitchRewriter");
// Breaks up deeply nested expressions such as chained method calls.
// Should be one of the last translations because other mutations will
// affect how deep the expressions are.
unit.accept(new ComplexExpressionExtractor());
ticker.tick("ComplexExpressionExtractor");
// Should be one of the last translations because methods and functions
// added in other phases may need added casts.
new CastResolver(unit).run();
ticker.tick("CastResolver");
// After: InnerClassExtractor, Functionizer - Expects all types to be
// top-level and functionizing to have occured.
new PrivateDeclarationResolver(unit).run();
ticker.tick("PrivateDeclarationResolver");
// Make sure we still have a valid AST.
unit.validate();
ticker.pop();
}
Aggregations