com.google.errorprone.refaster.RefasterRuleCompiler.java Source code

Introduction

Here is the source code for com.google.errorprone.refaster.RefasterRuleCompiler.java

Source

/*
 * Copyright 2016 Google Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.errorprone.refaster;

import static com.google.common.base.Preconditions.checkArgument;

import com.google.common.collect.Iterables;
import com.google.errorprone.InvalidCommandLineOptionException;
import com.google.errorprone.MaskedClassLoader;
import com.sun.tools.javac.api.MultiTaskListener;
import com.sun.tools.javac.main.Main;
import com.sun.tools.javac.main.Main.Result;
import com.sun.tools.javac.util.Context;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileSystems;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import javax.tools.DiagnosticCollector;
import javax.tools.DiagnosticListener;
import javax.tools.JavaFileObject;

/**
 * A compiler for Refaster rules that outputs a {@code .analyzer} file containing a compiled
 * Refaster rule.
 *
 * @author lowasser@google.com
 */
public class RefasterRuleCompiler {

    /**
     * Entry point for compiling a Refaster rule to an analyzer.
     *
     * @param args the same args which could be passed to javac on the command line
     */
    public static void main(String[] args) {
        new RefasterRuleCompiler().run(args, new Context());
    }

    private Result run(String[] argv, Context context) {
        try {
            argv = prepareCompilation(argv, context);
        } catch (InvalidCommandLineOptionException e) {
            System.err.println(e.getMessage());
            System.err.flush();
            return Result.CMDERR;
        }

        try {
            Result compileResult = new Main("RefasterRuleCompiler",
                    new PrintWriter(new OutputStreamWriter(System.err, StandardCharsets.UTF_8))).compile(argv,
                            context);
            System.err.flush();
            return compileResult;
        } catch (InvalidCommandLineOptionException e) {
            System.err.println(e.getMessage());
            System.err.flush();
            return Result.CMDERR;
        }
    }

    private String[] prepareCompilation(String[] argv, Context context) throws InvalidCommandLineOptionException {
        context.put(DiagnosticListener.class, new DiagnosticCollector<JavaFileObject>());
        List<String> newArgs = new ArrayList<>(Arrays.asList(argv));
        Iterator<String> itr = newArgs.iterator();
        String path = null;
        while (itr.hasNext()) {
            if (itr.next().equals("--out")) {
                itr.remove();
                path = itr.next();
                itr.remove();
                break;
            }
        }
        checkArgument(path != null, "No --out specified");

        MaskedClassLoader.preRegisterFileManager(context);

        MultiTaskListener.instance(context)
                .add(new RefasterRuleCompilerAnalyzer(context, FileSystems.getDefault().getPath(path)));

        return Iterables.toArray(newArgs, String.class);
    }
}