Examples with OuterReferenceResolver com.google.devtools.j2objc.translate.OuterReferenceResolver used on opensource projects

Example 1 with OuterReferenceResolver

use of com.google.devtools.j2objc.translate.OuterReferenceResolver 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();
}

Example 2 with OuterReferenceResolver

use of com.google.devtools.j2objc.translate.OuterReferenceResolver in project j2objc by google.

the class CycleFinder method findCycles.

public List<List<Edge>> findCycles() throws IOException {
    Parser parser = createParser();
    NameList whitelist = NameList.createFromFiles(options.getWhitelistFiles(), options.fileEncoding());
    final GraphBuilder graphBuilder = new GraphBuilder(whitelist);
    List<String> sourceFiles = options.getSourceFiles();
    File strippedDir = stripIncompatible(sourceFiles, parser);
    Parser.Handler handler = new Parser.Handler() {

        @Override
        public void handleParsedUnit(String path, CompilationUnit unit) {
            new LambdaTypeElementAdder(unit).run();
            new OuterReferenceResolver(unit).run();
            graphBuilder.visitAST(unit);
        }
    };
    parser.parseFiles(sourceFiles, handler, options.sourceVersion());
    FileUtil.deleteTempDir(strippedDir);
    if (ErrorUtil.errorCount() > 0) {
        return null;
    }
    // Construct the graph and find cycles.
    ReferenceGraph graph = graphBuilder.constructGraph().getGraph();
    for (ReferenceGraph component : graph.getStronglyConnectedComponents(getSeedNodes(graph))) {
        handleStronglyConnectedComponent(component);
    }
    return cycles;
}