src/main/java/com/android/tools/r8/BaseCommand.java - r8 - Git at Google

 // Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8;

 import com.android.tools.r8.errors.CompilationError;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.origin.PathOrigin;
 import com.android.tools.r8.utils.AbortException;
 import com.android.tools.r8.utils.AndroidApp;
 import com.android.tools.r8.utils.Box;
 import com.android.tools.r8.utils.ExceptionDiagnostic;
 import com.android.tools.r8.utils.ExceptionUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.StringDiagnostic;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;

 /**
  * Base class for commands and command builders for applications/tools which take an Android
  * application sources (and optional main-dex list) as input.
  *
  * <p>For concrete builders, see for example {@link D8Command.Builder} and {@link
  * R8Command.Builder}.
  */
 @Keep
 public abstract class BaseCommand {

   private final boolean printHelp;
   private final boolean printVersion;

   private final AndroidApp app;

   BaseCommand(boolean printHelp, boolean printVersion) {
     this.printHelp = printHelp;
     this.printVersion = printVersion;
     // All other fields are initialized with stub/invalid values.
     this.app = null;
   }

   BaseCommand(AndroidApp app) {
     assert app != null;
     this.app = app;
     // Print options are not set.
     printHelp = false;
     printVersion = false;
   }

   public boolean isPrintHelp() {
     return printHelp;
   }

   public boolean isPrintVersion() {
     return printVersion;
   }

   // Internal access to the input resources.
   AndroidApp getInputApp() {
     return app;
   }

   // Internal access to the internal options.
   abstract InternalOptions getInternalOptions();

   abstract static class InputFileOrigin extends PathOrigin {
     private final String inputType;

     public InputFileOrigin(String inputType, Path file) {
       super(file);
       this.inputType = inputType;
     }

     @Override
     public String part() {
       return inputType + " '" + super.part() + "'";
     }
   }

   private static class ProgramInputOrigin extends InputFileOrigin {

     public ProgramInputOrigin(Path file) {
       super("program input", file);
     }
   }

   private static class LibraryInputOrigin extends InputFileOrigin {

     public LibraryInputOrigin(Path file) {
       super("library input", file);
     }
   }

   /**
    * Base builder for commands.
    *
    * @param <C> Command the builder is building, e.g., {@link R8Command} or {@link D8Command}.
    * @param <B> Concrete builder extending this base, e.g., {@link R8Command.Builder} or {@link
    *     D8Command.Builder}.
    */
   @Keep
   public abstract static class Builder<C extends BaseCommand, B extends Builder<C, B>> {

     private final Reporter reporter;
     private boolean printHelp = false;
     private boolean printVersion = false;
     private final AndroidApp.Builder app;

     List<Path> programFiles = new ArrayList<>();

     Builder() {
       this(AndroidApp.builder());
     }

     Builder(DiagnosticsHandler handler) {
       this(AndroidApp.builder(new Reporter(handler)));
     }

     Builder(AndroidApp.Builder builder) {
       this.app = builder;
       this.reporter = builder.getReporter();
     }

     abstract B self();

     /**
      * Build the final command.
      *
      * <p>Building the command will complete the validation of builders state and build the final
      * command. If any errors occur during validation or building the errors are reported to the
      * associated diagnostics handler and a {@link CompilationFailedException} exception is thrown.
      */
     public final C build() throws CompilationFailedException {
       Box<C> box = new Box<>(null);
       ExceptionUtils.withCompilationHandler(
           reporter,
           () -> {
             validate();
             box.set(makeCommand());
             reporter.failIfPendingErrors();
           });
       return box.get();
     }

     // Helper to construct the actual command. Called as part of {@link build()}.
     abstract C makeCommand();

     // Internal accessor for the application resources.
     AndroidApp.Builder getAppBuilder() {
       return app;
     }

     /** Add program file resources. */
     public B addProgramFiles(Path... files) {
       addProgramFiles(Arrays.asList(files));
       return self();
     }

     Reporter getReporter() {
       return reporter;
     }

     /** Add program file resources. */
     public B addProgramFiles(Collection<Path> files) {
       guard(
           () -> {
             for (Path path : files) {
               try {
                 app.addProgramFile(path);
                 programFiles.add(path);
               } catch (CompilationError e) {
                 error(new ProgramInputOrigin(path), e);
               }
             }
           });
       return self();
     }

     /** Add a resource provider for program resources. */
     public B addProgramResourceProvider(ProgramResourceProvider programProvider) {
       app.addProgramResourceProvider(programProvider);
       return self();
     }

     /** Add library file resource provider. */
     public B addLibraryResourceProvider(ClassFileResourceProvider provider) {
       guard(() -> getAppBuilder().addLibraryResourceProvider(provider));
       return self();
     }

     /** Add library file resources. */
     public B addLibraryFiles(Path... files) {
       addLibraryFiles(Arrays.asList(files));
       return self();
     }

     /** Add library file resources. */
     public B addLibraryFiles(Collection<Path> files) {
       guard(
           () -> {
             for (Path path : files) {
               try {
                 app.addLibraryFile(path);
               } catch (CompilationError e) {
                 error(new LibraryInputOrigin(path), e);
               }
             }
           });
       return self();
     }

     /** Add classpath file resources. */
     public B addClasspathFiles(Path... files) {
       guard(() -> Arrays.stream(files).forEach(this::addClasspathFile));
       return self();
     }

     /** Add classpath file resources. */
     public B addClasspathFiles(Collection<Path> files) {
       guard(() -> files.forEach(this::addClasspathFile));
       return self();
     }

     private void addClasspathFile(Path file) {
       guard(() -> getAppBuilder().addClasspathFile(file));
     }

     /** Add classfile resources provider for class-path resources. */
     public B addClasspathResourceProvider(ClassFileResourceProvider provider) {
       guard(() -> getAppBuilder().addClasspathResourceProvider(provider));
       return self();
     }

     /** Add Java-bytecode program-data. */
     public B addClassProgramData(byte[] data, Origin origin) {
       guard(() -> app.addClassProgramData(data, origin));
       return self();
     }

     /** Add Java-bytecode program-data. */
     B addDexProgramData(byte[] data, Origin origin) {
       guard(() -> app.addDexProgramData(data, origin));
       return self();
     }

     /**
      * Add main-dex list files.
      *
      * Each line in each of the files specifies one class to keep in the primary dex file
      * (<code>classes.dex</code>).
      *
      * A class is specified using the following format: "com/example/MyClass.class". That is
      * "/" as separator between package components, and a trailing ".class".
      */
     public B addMainDexListFiles(Path... files) {
       guard(() -> {
         try {
           app.addMainDexListFiles(files);
         } catch (NoSuchFileException e) {
           reporter.error(new StringDiagnostic(
               "Main-dex-list file does not exist", new PathOrigin(Paths.get(e.getFile()))));
         }
       });
       return self();
     }

     /**
      * Add main-dex list files.
      *
      * @see #addMainDexListFiles(Path...)
      */
     public B addMainDexListFiles(Collection<Path> files) {
       guard(() -> {
         try {
           app.addMainDexListFiles(files);
         } catch (NoSuchFileException e) {
           reporter.error(new StringDiagnostic(
               "Main-dex-ist file does not exist", new PathOrigin(Paths.get(e.getFile()))));
         }
       });
       return self();
     }

     /**
      * Add main-dex classes.
      *
      * <p>Add classes to keep in the primary dex file (<code>classes.dex</code>).
      *
      * <p>NOTE: The name of the classes is specified using the Java fully qualified names format
      * (e.g. "com.example.MyClass$A"), and <i>not</i> the format used by the main-dex list file.
      */
     public B addMainDexClasses(String... classes) {
       guard(() -> app.addMainDexClasses(classes));
       return self();
     }

     /**
      * Add main-dex classes.
      *
      * Add classes to keep in the primary dex file (<code>classes.dex</code>).
      *
      * NOTE: The name of the classes is specified using the Java fully qualified names format
      * (e.g. "com.example.MyClass"), and <i>not</i> the format used by the main-dex list file.
      */
     public B addMainDexClasses(Collection<String> classes) {
       guard(() -> app.addMainDexClasses(classes));
       return self();
     }

     /** True if the print-help flag is enabled. */
     public boolean isPrintHelp() {
       return printHelp;
     }

     /** Set the value of the print-help flag. */
     public B setPrintHelp(boolean printHelp) {
       this.printHelp = printHelp;
       return self();
     }

     /** True if the print-version flag is enabled. */
     public boolean isPrintVersion() {
       return printVersion;
     }

     /** Set the value of the print-version flag. */
     public B setPrintVersion(boolean printVersion) {
       this.printVersion = printVersion;
       return self();
     }

     /** Signal an error. */
     public void error(Diagnostic diagnostic) {
       reporter.error(diagnostic);
     }

     /**
      * Signal an error and throw {@link AbortException}.
      *
      * @throws AbortException always.
      */
     public RuntimeException fatalError(Diagnostic diagnostic) {
       return reporter.fatalError(diagnostic);
     }

     // Internal helper for compat tools to make them ignore DEX code in input archives.
     void setIgnoreDexInArchive(boolean value) {
       guard(() -> app.setIgnoreDexInArchive(value));
     }

     // Helper that validates the command content. Called as part of {@link build()}.
     void validate() {}

     // Helper to signify an error.
     void error(Origin origin, Throwable throwable) {
       reporter.error(new ExceptionDiagnostic(throwable, origin));
     }

     // Helper to guard and handle exceptions.
     void guard(Runnable action) {
       try {
         action.run();
       } catch (CompilationError e) {
         reporter.error(e.toStringDiagnostic());
       } catch (AbortException e) {
         // Error was reported and exception will be thrown by build.
       }
     }

   }
 }
	// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.
	package com.android.tools.r8;

	import com.android.tools.r8.errors.CompilationError;
	import com.android.tools.r8.origin.Origin;
	import com.android.tools.r8.origin.PathOrigin;
	import com.android.tools.r8.utils.AbortException;
	import com.android.tools.r8.utils.AndroidApp;
	import com.android.tools.r8.utils.Box;
	import com.android.tools.r8.utils.ExceptionDiagnostic;
	import com.android.tools.r8.utils.ExceptionUtils;
	import com.android.tools.r8.utils.InternalOptions;
	import com.android.tools.r8.utils.Reporter;
	import com.android.tools.r8.utils.StringDiagnostic;
	import java.nio.file.NoSuchFileException;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.List;

	/**
	* Base class for commands and command builders for applications/tools which take an Android
	* application sources (and optional main-dex list) as input.
	*
	* <p>For concrete builders, see for example {@link D8Command.Builder} and {@link
	* R8Command.Builder}.
	*/
	@Keep
	public abstract class BaseCommand {

	private final boolean printHelp;
	private final boolean printVersion;

	private final AndroidApp app;

	BaseCommand(boolean printHelp, boolean printVersion) {
	this.printHelp = printHelp;
	this.printVersion = printVersion;
	// All other fields are initialized with stub/invalid values.
	this.app = null;
	}

	BaseCommand(AndroidApp app) {
	assert app != null;
	this.app = app;
	// Print options are not set.
	printHelp = false;
	printVersion = false;
	}

	public boolean isPrintHelp() {
	return printHelp;
	}

	public boolean isPrintVersion() {
	return printVersion;
	}

	// Internal access to the input resources.
	AndroidApp getInputApp() {
	return app;
	}

	// Internal access to the internal options.
	abstract InternalOptions getInternalOptions();

	abstract static class InputFileOrigin extends PathOrigin {
	private final String inputType;

	public InputFileOrigin(String inputType, Path file) {
	super(file);
	this.inputType = inputType;
	}

	@Override
	public String part() {
	return inputType + " '" + super.part() + "'";
	}
	}

	private static class ProgramInputOrigin extends InputFileOrigin {

	public ProgramInputOrigin(Path file) {
	super("program input", file);
	}
	}

	private static class LibraryInputOrigin extends InputFileOrigin {

	public LibraryInputOrigin(Path file) {
	super("library input", file);
	}
	}

	/**
	* Base builder for commands.
	*
	* @param <C> Command the builder is building, e.g., {@link R8Command} or {@link D8Command}.
	* @param <B> Concrete builder extending this base, e.g., {@link R8Command.Builder} or {@link
	* D8Command.Builder}.
	*/
	@Keep
	public abstract static class Builder<C extends BaseCommand, B extends Builder<C, B>> {

	private final Reporter reporter;
	private boolean printHelp = false;
	private boolean printVersion = false;
	private final AndroidApp.Builder app;

	List<Path> programFiles = new ArrayList<>();

	Builder() {
	this(AndroidApp.builder());
	}

	Builder(DiagnosticsHandler handler) {
	this(AndroidApp.builder(new Reporter(handler)));
	}

	Builder(AndroidApp.Builder builder) {
	this.app = builder;
	this.reporter = builder.getReporter();
	}

	abstract B self();

	/**
	* Build the final command.
	*
	* <p>Building the command will complete the validation of builders state and build the final
	* command. If any errors occur during validation or building the errors are reported to the
	* associated diagnostics handler and a {@link CompilationFailedException} exception is thrown.
	*/
	public final C build() throws CompilationFailedException {
	Box<C> box = new Box<>(null);
	ExceptionUtils.withCompilationHandler(
	reporter,
	() -> {
	validate();
	box.set(makeCommand());
	reporter.failIfPendingErrors();
	});
	return box.get();
	}

	// Helper to construct the actual command. Called as part of {@link build()}.
	abstract C makeCommand();

	// Internal accessor for the application resources.
	AndroidApp.Builder getAppBuilder() {
	return app;
	}

	/** Add program file resources. */
	public B addProgramFiles(Path... files) {
	addProgramFiles(Arrays.asList(files));
	return self();
	}

	Reporter getReporter() {
	return reporter;
	}

	/** Add program file resources. */
	public B addProgramFiles(Collection<Path> files) {
	guard(
	() -> {
	for (Path path : files) {
	try {
	app.addProgramFile(path);
	programFiles.add(path);
	} catch (CompilationError e) {
	error(new ProgramInputOrigin(path), e);
	}
	}
	});
	return self();
	}

	/** Add a resource provider for program resources. */
	public B addProgramResourceProvider(ProgramResourceProvider programProvider) {
	app.addProgramResourceProvider(programProvider);
	return self();
	}

	/** Add library file resource provider. */
	public B addLibraryResourceProvider(ClassFileResourceProvider provider) {
	guard(() -> getAppBuilder().addLibraryResourceProvider(provider));
	return self();
	}

	/** Add library file resources. */
	public B addLibraryFiles(Path... files) {
	addLibraryFiles(Arrays.asList(files));
	return self();
	}

	/** Add library file resources. */
	public B addLibraryFiles(Collection<Path> files) {
	guard(
	() -> {
	for (Path path : files) {
	try {
	app.addLibraryFile(path);
	} catch (CompilationError e) {
	error(new LibraryInputOrigin(path), e);
	}
	}
	});
	return self();
	}

	/** Add classpath file resources. */
	public B addClasspathFiles(Path... files) {
	guard(() -> Arrays.stream(files).forEach(this::addClasspathFile));
	return self();
	}

	/** Add classpath file resources. */
	public B addClasspathFiles(Collection<Path> files) {
	guard(() -> files.forEach(this::addClasspathFile));
	return self();
	}

	private void addClasspathFile(Path file) {
	guard(() -> getAppBuilder().addClasspathFile(file));
	}

	/** Add classfile resources provider for class-path resources. */
	public B addClasspathResourceProvider(ClassFileResourceProvider provider) {
	guard(() -> getAppBuilder().addClasspathResourceProvider(provider));
	return self();
	}

	/** Add Java-bytecode program-data. */
	public B addClassProgramData(byte[] data, Origin origin) {
	guard(() -> app.addClassProgramData(data, origin));
	return self();
	}

	/** Add Java-bytecode program-data. */
	B addDexProgramData(byte[] data, Origin origin) {
	guard(() -> app.addDexProgramData(data, origin));
	return self();
	}

	/**
	* Add main-dex list files.
	*
	* Each line in each of the files specifies one class to keep in the primary dex file
	* (<code>classes.dex</code>).
	*
	* A class is specified using the following format: "com/example/MyClass.class". That is
	* "/" as separator between package components, and a trailing ".class".
	*/
	public B addMainDexListFiles(Path... files) {
	guard(() -> {
	try {
	app.addMainDexListFiles(files);
	} catch (NoSuchFileException e) {
	reporter.error(new StringDiagnostic(
	"Main-dex-list file does not exist", new PathOrigin(Paths.get(e.getFile()))));
	}
	});
	return self();
	}

	/**
	* Add main-dex list files.
	*
	* @see #addMainDexListFiles(Path...)
	*/
	public B addMainDexListFiles(Collection<Path> files) {
	guard(() -> {
	try {
	app.addMainDexListFiles(files);
	} catch (NoSuchFileException e) {
	reporter.error(new StringDiagnostic(
	"Main-dex-ist file does not exist", new PathOrigin(Paths.get(e.getFile()))));
	}
	});
	return self();
	}

	/**
	* Add main-dex classes.
	*
	* <p>Add classes to keep in the primary dex file (<code>classes.dex</code>).
	*
	* <p>NOTE: The name of the classes is specified using the Java fully qualified names format
	* (e.g. "com.example.MyClass$A"), and <i>not</i> the format used by the main-dex list file.
	*/
	public B addMainDexClasses(String... classes) {
	guard(() -> app.addMainDexClasses(classes));
	return self();
	}

	/**
	* Add main-dex classes.
	*
	* Add classes to keep in the primary dex file (<code>classes.dex</code>).
	*
	* NOTE: The name of the classes is specified using the Java fully qualified names format
	* (e.g. "com.example.MyClass"), and <i>not</i> the format used by the main-dex list file.
	*/
	public B addMainDexClasses(Collection<String> classes) {
	guard(() -> app.addMainDexClasses(classes));
	return self();
	}

	/** True if the print-help flag is enabled. */
	public boolean isPrintHelp() {
	return printHelp;
	}

	/** Set the value of the print-help flag. */
	public B setPrintHelp(boolean printHelp) {
	this.printHelp = printHelp;
	return self();
	}

	/** True if the print-version flag is enabled. */
	public boolean isPrintVersion() {
	return printVersion;
	}

	/** Set the value of the print-version flag. */
	public B setPrintVersion(boolean printVersion) {
	this.printVersion = printVersion;
	return self();
	}

	/** Signal an error. */
	public void error(Diagnostic diagnostic) {
	reporter.error(diagnostic);
	}

	/**
	* Signal an error and throw {@link AbortException}.
	*
	* @throws AbortException always.
	*/
	public RuntimeException fatalError(Diagnostic diagnostic) {
	return reporter.fatalError(diagnostic);
	}

	// Internal helper for compat tools to make them ignore DEX code in input archives.
	void setIgnoreDexInArchive(boolean value) {
	guard(() -> app.setIgnoreDexInArchive(value));
	}

	// Helper that validates the command content. Called as part of {@link build()}.
	void validate() {}

	// Helper to signify an error.
	void error(Origin origin, Throwable throwable) {
	reporter.error(new ExceptionDiagnostic(throwable, origin));
	}

	// Helper to guard and handle exceptions.
	void guard(Runnable action) {
	try {
	action.run();
	} catch (CompilationError e) {
	reporter.error(e.toStringDiagnostic());
	} catch (AbortException e) {
	// Error was reported and exception will be thrown by build.
	}
	}

	}
	}