Attachment #33456 for bug #99620

Lines 169-175 Link Here

(-)dom/org/eclipse/jdt/core/dom/CompilationUnitResolver.java (-1 / +1 lines)
169	new CompilationResult(sourceUnit, index++, maxUnits, this.options.maxProblemsPerUnit);	169	new CompilationResult(sourceUnit, index++, maxUnits, this.options.maxProblemsPerUnit);
170	try {	170	try {
171	if (options.verbose) {	171	if (options.verbose) {
172	System.out.println(	172	this.out.println(
173	Messages.bind(Messages.compilation_request,	173	Messages.bind(Messages.compilation_request,
174	new String[] {	174	new String[] {
175	String.valueOf(index++ + 1),	175	String.valueOf(index++ + 1),

Lines 966-971 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/Main.java (-2 / +8 lines)
966	public String destinationPath;	966	public String destinationPath;
967	public String[] encodings;	967	public String[] encodings;
968	public Logger logger;	968	public Logger logger;
		969	PrintWriter out;
		970	// need to pass the compiler messages output to the delegate compiler
		971	// do not user directly (use logger)
		972	// TODO (maxime) this is used in one instance - check reason with olivier
969	public int exportedClassFilesCounter;	973	public int exportedClassFilesCounter;
970	public String[] filenames;	974	public String[] filenames;
971	public boolean generatePackagesStructure;	975	public boolean generatePackagesStructure;
Lines 1000-1005 Link Here
1000		1004
1001	public Main(PrintWriter outWriter, PrintWriter errWriter, boolean systemExitWhenFinished, Map customDefaultOptions) {	1005	public Main(PrintWriter outWriter, PrintWriter errWriter, boolean systemExitWhenFinished, Map customDefaultOptions) {
1002	this.logger = new Logger(outWriter, errWriter);	1006	this.logger = new Logger(outWriter, errWriter);
		1007	this.out = outWriter;
1003	this.systemExitWhenFinished = systemExitWhenFinished;	1008	this.systemExitWhenFinished = systemExitWhenFinished;
1004	this.options = new CompilerOptions().getMap();	1009	this.options = new CompilerOptions().getMap();
1005	if (customDefaultOptions != null) {	1010	if (customDefaultOptions != null) {
Lines 2770-2776 Link Here
2770	String relativeStringName = new String(relativeName);	2775	String relativeStringName = new String(relativeName);
2771	try {	2776	try {
2772	if (this.compilerOptions.verbose)	2777	if (this.compilerOptions.verbose)
2773	System.out.println(	2778	this.out.println(
2774	Messages.bind(	2779	Messages.bind(
2775	Messages.compilation_write,	2780	Messages.compilation_write,
2776	new String[] {	2781	new String[] {
Lines 2810-2816 Link Here
2810	getHandlingPolicy(),	2815	getHandlingPolicy(),
2811	this.options,	2816	this.options,
2812	getBatchRequestor(),	2817	getBatchRequestor(),
2813	getProblemFactory());	2818	getProblemFactory(),
		2819	this.out);
2814	this.compilerOptions = batchCompiler.options;	2820	this.compilerOptions = batchCompiler.options;
2815		2821
2816	// set the non-externally configurable options.	2822	// set the non-externally configurable options.




	public ICompilerRequestor requestor;
	public CompilerOptions options;
	public ProblemReporter problemReporter;
	protected PrintWriter out; // output for messages that are not sent to problemReporter

	// management of unit to be processed
	//public CompilationUnitResult currentCompilationUnitResult;

	 *      them back as part of the compilation unit result.
	 */
	public Compiler(
			INameEnvironment environment,
			IErrorHandlingPolicy policy,
			Map settings,
			final ICompilerRequestor requestor,
			IProblemFactory problemFactory) {
		this(environment, policy, settings,	requestor, problemFactory, 
				null, false, false, false, false); // all defaults
	}
	
	/**
	 * Answer a new compiler using the given name environment and compiler options.
	 * The environment and options will be in effect for the lifetime of the compiler.
	 * When the compiler is run, compilation results are sent to the given requestor.
	 *
	 *  @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
	 *      Environment used by the compiler in order to resolve type and package
	 *      names. The name environment implements the actual connection of the compiler
	 *      to the outside world (e.g. in batch mode the name environment is performing
	 *      pure file accesses, reuse previous build state or connection to repositories).
	 *      Note: the name environment is responsible for implementing the actual classpath
	 *            rules.
	 *
	 *  @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
	 *      Configurable part for problem handling, allowing the compiler client to
	 *      specify the rules for handling problems (stop on first error or accumulate
	 *      them all) and at the same time perform some actions such as opening a dialog
	 *      in UI when compiling interactively.
	 *      @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
	 *      
	 *  @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
	 *      Component which will receive and persist all compilation results and is intended
	 *      to consume them as they are produced. Typically, in a batch compiler, it is 
	 *      responsible for writing out the actual .class files to the file system.
	 *      @see org.eclipse.jdt.internal.compiler.CompilationResult
	 *
	 *  @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
	 *      Factory used inside the compiler to create problem descriptors. It allows the
	 *      compiler client to supply its own representation of compilation problems in
	 *      order to avoid object conversions. Note that the factory is not supposed
	 *      to accumulate the created problems, the compiler will gather them all and hand
	 *      them back as part of the compilation unit result.
	 *
	 *  @param out java.io.PrintWriter
	 *      Used by the compiler to output messages which are not related to problems,
	 *      e.g. the information issued in verbose mode. If null, defaults to System.out 
	 *      with automatic flushing. 
	 */
	public Compiler(
			INameEnvironment environment,
			IErrorHandlingPolicy policy,
			Map settings,
			final ICompilerRequestor requestor,
			IProblemFactory problemFactory,
			PrintWriter out) {
		this(environment, policy, settings,	requestor, problemFactory, out, 
				false, false, false, false); // all defaults
	}
	
	/**

	 *      order to avoid object conversions. Note that the factory is not supposed
	 *      to accumulate the created problems, the compiler will gather them all and hand
	 *      them back as part of the compilation unit result.
	 *
	 *	@param parseLiteralExpressionsAsConstants <code>boolean</code>
	 *		This parameter is used to optimize the literals or leave them as they are in the source.
	 * 		If you put true, "Hello" + " world" will be converted to "Hello world".
	 *
	 *	@param storeAnnotations <code>boolean</code>
	 *		This parameter is used to tell the compiler to store annotations on 
	 *		type bindings, or not.
	 *
	 *	@param statementsRecovery <code>boolean</code>
	 *		This parameter is used to tell the compiler to perform syntax error
	 *      recovery on statements, or not. 
	 */
	public Compiler(
			INameEnvironment environment,
			IErrorHandlingPolicy policy,
			Map settings,
			final ICompilerRequestor requestor,
			IProblemFactory problemFactory,
			boolean parseLiteralExpressionsAsConstants,
			boolean storeAnnotations,
			boolean statementsRecovery) {
		this(environment, policy, settings,	requestor, problemFactory, 
				null, // default 
				parseLiteralExpressionsAsConstants, storeAnnotations, statementsRecovery, true);
	}

	/**
	 * Answer a new compiler using the given name environment and compiler options.
	 * The environment and options will be in effect for the lifetime of the compiler.
	 * When the compiler is run, compilation results are sent to the given requestor.
	 *
	 *  @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
	 *      Environment used by the compiler in order to resolve type and package
	 *      names. The name environment implements the actual connection of the compiler
	 *      to the outside world (e.g. in batch mode the name environment is performing
	 *      pure file accesses, reuse previous build state or connection to repositories).
	 *      Note: the name environment is responsible for implementing the actual classpath
	 *            rules.
	 *
	 *  @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
	 *      Configurable part for problem handling, allowing the compiler client to
	 *      specify the rules for handling problems (stop on first error or accumulate
	 *      them all) and at the same time perform some actions such as opening a dialog
	 *      in UI when compiling interactively.
	 *      @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
	 *      
	 *  @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
	 *      Component which will receive and persist all compilation results and is intended
	 *      to consume them as they are produced. Typically, in a batch compiler, it is 
	 *      responsible for writing out the actual .class files to the file system.
	 *      @see org.eclipse.jdt.internal.compiler.CompilationResult
	 *
	 *  @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
	 *      Factory used inside the compiler to create problem descriptors. It allows the
	 *      compiler client to supply its own representation of compilation problems in
	 *      order to avoid object conversions. Note that the factory is not supposed
	 *      to accumulate the created problems, the compiler will gather them all and hand
	 *      them back as part of the compilation unit result.
	 *
	 *  @param out java.io.PrintWriter
	 *      Used by the compiler to output messages which are not related to problems,
	 *      e.g. the information issued in verbose mode. If null, defaults to System.out 
	 *      with automatic flushing. 
	 *
	 *	@param parseLiteralExpressionsAsConstants <code>boolean</code>
	 *		This parameter is used to optimize the literals or leave them as they are in the source.
	 * 		If you put true, "Hello" + " world" will be converted to "Hello world".
	 *
	 *	@param storeAnnotations <code>boolean</code>
	 *		This parameter is used to tell the compiler to store annotations on 
	 *		type bindings, or not.
	 *
	 *	@param statementsRecovery <code>boolean</code>
	 *		This parameter is used to tell the compiler to perform syntax error
	 *      recovery on statements, or not. 
	 *
	 *	@param flag <code>boolean</code>
	 *		Set to true if and only if the other boolean parameters are significant.
	 */
	private Compiler(
			INameEnvironment environment,
			IErrorHandlingPolicy policy,
			Map settings,
			final ICompilerRequestor requestor,
			IProblemFactory problemFactory,
			PrintWriter out,
			boolean parseLiteralExpressionsAsConstants,
			boolean storeAnnotations,
			boolean statementsRecovery,
			boolean flag) {

		// create a problem handler given a handling policy
		this.options = new CompilerOptions(settings);
		if (flag) { // boolean parameters are significant, pass them down
			this.options.parseLiteralExpressionsAsConstants = parseLiteralExpressionsAsConstants;
			this.options.storeAnnotations = storeAnnotations;
			this.options.performStatementsRecovery =
				statementsRecovery &&
				this.options.performStatementsRecovery;// TODO temporary code to take into account the temporary JavaCore options
		}
		
		// wrap requestor in DebugRequestor if one is specified
		if(DebugRequestor == null) {

		}
		this.problemReporter = new ProblemReporter(policy, this.options, problemFactory);
		this.lookupEnvironment = new LookupEnvironment(this, this.options, problemReporter, environment);
		this.out = out == null ? new PrintWriter(System.out, true) : out;
		initializeParser();
	}
	

	 */
	public void accept(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) {
		if (this.options.verbose) {
			this.out.println(
				Messages.bind(Messages.compilation_loadBinary, new String(binaryType.getName())));
//			new Exception("TRACE BINARY").printStackTrace(System.out);
//		    System.out.println();

		try {
			if (options.verbose) {
				String count = String.valueOf(totalUnits + 1);
				this.out.println(
					Messages.bind(Messages.compilation_request,
						new String[] {
							count,

				new CompilationResult(sourceUnits[i], i, maxUnits, this.options.maxProblemsPerUnit);
			try {
				if (options.verbose) {
					this.out.println(
						Messages.bind(Messages.compilation_request,
						new String[] {
							String.valueOf(i + 1),

				unit = unitsToProcess[i];
				try {
					if (options.verbose)
						this.out.println(
							Messages.bind(Messages.compilation_process,
							new String[] {
								String.valueOf(i + 1),

				unitsToProcess[i] = null; // release reference to processed unit declaration
				requestor.acceptResult(unit.compilationResult.tagAsAccepted());
				if (options.verbose)
					this.out.println(
						Messages.bind(Messages.compilation_done,
						new String[] {
							String.valueOf(i + 1),

		}
		if (options.verbose) {
			if (this.totalUnits > 1) {
				this.out.println(
					Messages.bind(Messages.compilation_units, String.valueOf(this.totalUnits))); 
			} else {
				this.out.println(
					Messages.bind(Messages.compilation_unit, String.valueOf(this.totalUnits))); 
			}
		}




			result);
}
// test the tester - runConformTest
public void test007(){
	this.runConformTest(
		new String[] {
			"X.java",

        + " -1.5 -g -preserveAllLocals"
        + " -bootclasspath " + JRE_HOME_DIR + "/lib/rt.jar"
        + " -cp " + JRE_HOME_DIR + "/lib/jce.jar"
        + " -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
        + " -verbose -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
        "[parsing    ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[reading    java/lang/Object.class]\n" + 
		"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[reading    java/util/List.class]\n" + 
		"[reading    java/lang/SuppressWarnings.class]\n" + 
		"[reading    java/lang/String.class]\n" + 
		"[writing    X.class - #1]\n" + 
		"[completed  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[1 unit compiled]\n" + 
		"[1 .class file generated]\n", 
        "", // changed with bug 123522: now the SuppressWarning upon the first type 
        	// influences warnings on unused imports
        true);
}
// test the tester - runNegativeTest
public void test008(){
	this.runNegativeTest(
		new String[] {
			"X.java",

        + " -1.5 -g -preserveAllLocals"
        + " -bootclasspath " + JRE_HOME_DIR + "/lib/rt.jar"
        + " -cp " + JRE_HOME_DIR + "/lib/jce.jar"
        + " -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
        "", 
        "----------\n" + 
        "1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---" + File.separator + "X.java\n" + 
        " (at line 11)\n" + 

}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=92398 -- a case that works, another that does not
// revisit this test case depending on https://bugs.eclipse.org/bugs/show_bug.cgi?id=95349
public void test009(){
	this.runNegativeTest(
		new String[] {
			"X.java",

        + " -1.5 -g -preserveAllLocals"
        + " -cp \"" + OUTPUT_DIR + "[+OK2" + File.pathSeparator + "~Warn" 
        	+ File.pathSeparator + "-KO]\""
        + " -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
        "", 
		"----------\n" + 
		"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
		" (at line 5)\n" + 
		"	Warn warn;\n" + 
		"	^^^^\n" + 
		"Discouraged access: The type Warn is not accessible due to restriction on classpath entry ---OUTPUT_DIR_PLACEHOLDER---\n" + 
		"----------\n" + 
		"2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
		" (at line 6)\n" + 
		"	KO ko;\n" + 
		"	^^\n" + 
		"Access restriction: The type KO is not accessible due to restriction on classpath entry ---OUTPUT_DIR_PLACEHOLDER---\n" + 
		"----------\n" + 
		"3. ERROR in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
		" (at line 7)\n" + 
		"	Zork z;\n" + 
		"	^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n" + 
		"3 problems (1 error, 2 warnings)",
        "----------\n" + 
        "3 problems (1 error, 2 warnings)",
        true);
}
// command line - no user classpath nor bootclasspath
public void test010(){
	this.runConformTest(
		new String[] {
			"X.java",

        + " -1.5 -g -preserveAllLocals"
        + " -verbose -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal"
        + " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
        "[parsing    ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[reading    java/lang/Object.class]\n" + 
		"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[reading    java/util/List.class]\n" + 
		"[reading    java/lang/SuppressWarnings.class]\n" + 
		"[reading    java/lang/String.class]\n" + 
		"[writing    X.class - #1]\n" + 
		"[completed  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
		"[1 unit compiled]\n" + 
		"[1 .class file generated]\n", 
        "", 
        true);
}
// command line - unusual classpath (ends with ';', still OK)
public void test011(){

        true);
}
// command line - help
public void test012(){
	final String expectedOutput =
        "{0}\n" + 
		" \n" + 
		" Usage: <options> <source files | directories>\n" + 
		" If directories are specified, then their source contents are compiled.\n" + 
		" Possible options are listed below. Options enabled by default are prefixed with ''+''\n" + 
		" \n" + 
		" Classpath options:\n" + 
		"    -cp -classpath <directories and zip/jar files separated by :>\n" + 
		"                       specify location for application classes and sources. Each\n" + 
		"                       directory or file can specify access rules for types between\n" + 
		"                       ''['' and '']'' (e.g. [-X] to forbid access to type X, [~X] to\n" + 
		"                       discourage access to type X, [+p/X:-p/*] to forbid access to all\n" + 
		"                       types in package p but allow access to p/X)\n" + 
		"    -bootclasspath <directories and zip/jar files separated by :>\n" + 
		"                       specify location for system classes. Each directory or file can\n" + 
		"                       specify access rules for types between ''['' and '']''\n" + 
		"    -sourcepath <directories separated by :>\n" + 
		"                       specify location for application sources. Each directory can\n" + 
		"                       specify access rules for types between ''['' and '']''\n" + 
		"    -extdirs <directories separated by :>\n" + 
		"                       specify location for extension zip/jar files\n" + 
		"    -d <dir>           destination directory (if omitted, no directory is created)\n" + 
		"    -d none            generate no .class files\n" + 
		"    -encoding <enc>    specify custom encoding for all sources. Each file/directory can override it\n" + 
		"                       when suffixed with ''[''<enc>'']'' (e.g. X.java[utf8])\n" + 
		" \n" + 
		" Compliance options:\n" + 
		"    -1.3               use 1.3 compliance level (implicit -source 1.3 -target 1.1)\n" + 
		"    -1.4             + use 1.4 compliance level (implicit -source 1.3 -target 1.2)\n" + 
		"    -1.5               use 1.5 compliance level (implicit -source 1.5 -target 1.5)\n" + 
		"    -1.6               use 1.6 compliance level (implicit -source 1.6 -target 1.6)\n" + 
		"    -source <version>  set source level: 1.3 to 1.6 (or 6 or 6.0)\n" + 
		"    -target <version>  set classfile target level: 1.1 to 1.6 (or 6 or 6.0)\n" + 
		" \n" + 
		" Warning options:\n" + 
		"    -deprecation     + deprecation outside deprecated code\n" + 
		"    -nowarn            disable all warnings\n" + 
		"    -warn:none         disable all warnings\n" + 
		"    -warn:<warnings separated by ,>    enable exactly the listed warnings\n" + 
		"    -warn:+<warnings separated by ,>   enable additional warnings\n" + 
		"    -warn:-<warnings separated by ,>   disable specific warnings\n" + 
		"      allDeprecation       deprecation including inside deprecated code\n" + 
		"      allJavadoc           invalid or missing javadoc\n" + 
		"      assertIdentifier   + ''assert'' used as identifier\n" + 
		"      boxing               autoboxing conversion\n" + 
		"      charConcat         + char[] in String concat\n" + 
		"      conditionAssign      possible accidental boolean assignment\n" + 
		"      constructorName    + method with constructor name\n" + 
		"      dep-ann              missing @Deprecated annotation\n" + 
		"      deprecation        + deprecation outside deprecated code\n" + 
		"      discouraged        + use of types matching a discouraged access rule\n" + 
		"      emptyBlock           undocumented empty block\n" + 
		"      enumSwitch           incomplete enum switch\n" + 
		"      fieldHiding          field hiding another variable\n" + 
		"      finalBound           type parameter with final bound\n" + 
		"      finally            + finally block not completing normally\n" + 
		"      forbidden          + use of types matching a forbidden access rule\n" + 
		"      hiding               macro for fieldHiding, localHiding, typeHiding and maskedCatchBlock\n" + 
		"      incomplete-switch    same as enumSwitch\n" + 
		"      indirectStatic       indirect reference to static member\n" + 
		"      intfAnnotation     + annotation type used as super interface\n" + 
		"      intfNonInherited   + interface non-inherited method compatibility\n" + 
		"      javadoc              invalid javadoc\n" + 
		"      localHiding          local variable hiding another variable\n" + 
		"      maskedCatchBlock   + hidden catch block\n" + 
		"      nls                  string literal lacking non-nls tag //$NON-NLS-<n>$\n" + 
		"      noEffectAssign     + assignment without effect\n" + 
		"      null                 missing or redundant null check\n" + 
		"      over-ann             missing @Override annotation\n" + 
		"      paramAssign          assignment to a parameter\n" + 
		"      pkgDefaultMethod   + attempt to override package-default method\n" + 
		"      raw                  usage of raw type\n" + 
		"      semicolon            unnecessary semicolon, empty statement\n" + 
		"      serial             + missing serialVersionUID\n" + 
		"      specialParamHiding   constructor or setter parameter hiding another field\n" + 
		"      static-access        macro for indirectStatic and staticReceiver\n" + 
		"      staticReceiver     + non-static reference to static member\n" + 
		"      suppress           + enable @SuppressWarnings\n" + 
		"      synthetic-access     same as syntheticAccess\n" + 
		"      syntheticAccess      synthetic access for innerclass\n" + 
		"      tasks(<tags separated by |>) tasks identified by tags inside comments\n" + 
		"      typeHiding         + type parameter hiding another type\n" + 
		"      unchecked          + unchecked type operation\n" + 
		"      unnecessaryElse      unnecessary else clause\n" + 
		"      unqualified-field-access same as unQualifiedField\n" + 
		"      unqualifiedField     unqualified reference to field\n" + 
		"      unused               macro for unusedArgument, unusedImport, unusedLabel,\n" + 
		"                               unusedLocal, unusedPrivate and unusedThrown\n" + 
		"      unusedArgument       unread method parameter\n" + 
		"      unusedImport       + unused import declaration\n" + 
		"      unusedLabel        + unused label\n" + 
		"      unusedLocal        + unread local variable\n" + 
		"      unusedPrivate      + unused private member declaration\n" + 
		"      unusedThrown         unused declared thrown exception\n" + 
		"      uselessTypeCheck     unnecessary cast/instanceof operation\n" + 
		"      varargsCast        + varargs argument need explicit cast\n" + 
		"      warningToken       + unhandled warning token in @SuppressWarnings\n" + 
		" \n" + 
		" Debug options:\n" + 
		"    -g[:lines,vars,source] custom debug info\n" + 
		"    -g:lines,source  + both lines table and source debug info\n" + 
		"    -g                 all debug info\n" + 
		"    -g:none            no debug info\n" + 
		"    -preserveAllLocals preserve unused local vars for debug purpose\n" + 
		" \n" + 
		" Ignored options:\n" + 
		"    -J<option>         pass option to virtual machine (ignored)\n" + 
		"    -X<option>         specify non-standard option (ignored)\n" + 
		"    -X                 print non-standard options and exit (ignored)\n" + 
		"    -O                 optimize for execution time (ignored)\n" + 
		" \n" + 
		" Advanced options:\n" + 
		"    @<file>            read command line arguments from file\n" + 
		"    -maxProblems <n>   max number of problems per compilation unit (100 by default)\n" + 
		"    -log <file>        log to a file. If the file extension is ''.xml'', then the log\n" + 
		"                       will be a xml file.\n" + 
		"    -proceedOnError    do not stop at first error, dumping class files with problem methods\n" + 
		"    -verbose           enable verbose output\n" + 
		"    -referenceInfo     compute reference info\n" + 
		"    -progress          show progress (only in -log mode)\n" + 
		"    -time              display speed information \n" + 
		"    -noExit            do not call System.exit(n) at end of compilation (n==0 if no error)\n" + 
		"    -repeat <n>        repeat compilation process <n> times for perf analysis\n" + 
		"    -inlineJSR         inline JSR bytecode (implicit if target >= 1.5)\n" + 
		"    -enableJavadoc     consider references in javadoc\n" + 
		" \n" + 
		"    -? -help           print this help message\n" + 
		"    -v -version        print compiler version\n" + 
		"    -showversion       print compiler version and continue\n" + 
		"\n";

	this.runConformTest(
		new String[0],
        " -help -referenceInfo",
		MessageFormat.format(expectedOutput, new String[] {
				Main.bind("misc.version", new String[] {
					Main.bind("compiler.name"),
					Main.bind("compiler.version"),
					Main.bind("compiler.copyright")
				}),
				// File.pathSeparator
		}),
        "", true);
}

	// command line - xml log contents https://bugs.eclipse.org/bugs/show_bug.cgi?id=93904
	public void test013() {
		String logFileName = OUTPUT_DIR + File.separator + "log.xml";
		this.runNegativeTest(new String[] { 
				"X.java",

		String logContents = Util.fileContent(logFileName);
		String expectedLogContents = 
			"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + 
			"<!DOCTYPE compiler PUBLIC \"-//Eclipse.org//DTD Eclipse JDT 3.2.001 Compiler//EN\" \"http://www.eclipse.org/jdt/core/compiler_32_001.dtd\">\n" + 
			"<compiler name=\"{1}\" copyright=\"{2}\" version=\"{3}\">\n" + 
			"	<command_line>\n" + 
			"		<argument value=\"---OUTPUT_DIR_PLACEHOLDER---{0}X.java\"/>\n" + 
			"		<argument value=\"-1.5\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.discouragedReference\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.emptyStatement\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.enumIdentifier\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.fatalOptionalError\" value=\"enabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.fieldHiding\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.finalParameterBound\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally\" value=\"warning\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.indirectStaticAccess\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadoc\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTags\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility\" value=\"public\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.localVariableHiding\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.methodWithConstructorName\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation\" value=\"ignore\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility\" value=\"public\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTags\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility\" value=\"public\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.missingSerialVersion\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.noEffectAssignment\" value=\"warning\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.nullReference\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.parameterAssignment\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.rawTypeReference\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.specialParameterHidingField\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.staticAccessReceiver\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.suppressWarnings\" value=\"enabled\"/>\n" + 

			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedImport\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedLabel\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedLocal\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameter\" value=\"ignore\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete\" value=\"disabled\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.unusedPrivateMember\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast\" value=\"warning\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.source\" value=\"1.5\"/>\n" + 
			"		<option key=\"org.eclipse.jdt.core.compiler.taskCaseSensitive\" value=\"enabled\"/>\n" + 

			"		<problem_summary problems=\"1\" errors=\"1\" warnings=\"0\" tasks=\"0\"/>\n" + 
			"	</stats>\n" + 
			"</compiler>\n";
		String normalizedExpectedLogContents =
				MessageFormat.format(
						expectedLogContents,
						new String[] {
								File.separator,
								Main.bind("compiler.name"),
								Main.bind("compiler.copyright"),
								Main.bind("compiler.version")
						});
		String normalizedLogContents =
				xmlLogsNormalizer.normalized(logContents);
		boolean compareOK = normalizedExpectedLogContents.equals(
				normalizedLogContents);
		if (!compareOK) {
			System.out.println(getClass().getName() + '#' + getName());
			System.out.println(

				  + "\n--------- (cut and paste:) ----------\n"
					+ Util.displayString(xmlLogsNormalizer.normalized(logContents))
				  + "\n------------- [END LOG] -------------\n");
			assertEquals("Unexpected log contents", 
					normalizedExpectedLogContents, normalizedLogContents);
		}
		assertTrue("unexpected log contents", compareOK);
	}

	// command line - txt log contents https://bugs.eclipse.org/bugs/show_bug.cgi?id=93904

		}
		assertTrue("unexpected log contents", compareOK);
	}
public void test016(){
		this.runConformTest(
			new String[] {
					"X.java",

	        + " -cp ." + File.pathSeparator + File.pathSeparator + File.pathSeparator + "\"" + OUTPUT_DIR + "\""
	        + " -verbose -proceedOnError -referenceInfo"
	        + " -d \"" + OUTPUT_DIR + "\"",
			"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
			"[reading    java/lang/Object.class]\n" + 
			"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
			"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/OK1.java - #2/2]\n" + 
			"[writing    X.class - #1]\n" + 
			"[completed  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/2]\n" + 
			"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/OK1.java - #2/2]\n" + 
			"[writing    OK1.class - #2]\n" + 
			"[completed  ---OUTPUT_DIR_PLACEHOLDER---/OK1.java - #2/2]\n" + 
			"[2 units compiled]\n" + 
			"[2 .class files generated]\n",
	        "",
	        true);
	}
public void test017(){
		this.runConformTest(
			new String[] {
					"X.java",

	        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
	        + " -1.5 -g -preserveAllLocals"
	        + " -cp dummmy_dir" + File.pathSeparator + "dummy.jar" + File.pathSeparator + File.pathSeparator + "\"" + OUTPUT_DIR + "\"" 
	        + " -proceedOnError -referenceInfo" 
	        + " -d \"" + OUTPUT_DIR + "\"",
	        "",
	        "incorrect classpath: dummmy_dir\n",
	        "incorrect classpath: dummy.jar\n" + 
	        "incorrect classpath: dummy.jar\n",
	        true);
	}
// we tolerate inexisting jars on the classpath
// TODO (maxime) check and document
public void _test017b(){
	this.runConformTest(
		new String[] {
				"X.java",
				"/** */\n" + 
				"public class X {\n" + 
				"	OK1 ok1;\n" + 
				"}",
				"OK1.java",
				"/** */\n" + 
				"public class OK1 {\n" + 
				"	// empty\n" + 
				"}"
		},
        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
        + " -1.5 -g -preserveAllLocals"
        + " -cp dummy.jar" + File.pathSeparator + File.pathSeparator + "\"" + OUTPUT_DIR + "\"" 
        + " -verbose -proceedOnError -referenceInfo" 
        + " -d \"" + OUTPUT_DIR + "\"",
        "[2 .class files generated]\n",
        "incorrect classpath: dummmy.jar\n",
        true);
}
// we tolerate empty classpath entries
// TODO (maxime) check and document
public void _test017c(){
	this.runConformTest(
		new String[] {
				"X.java",
				"/** */\n" + 
				"public class X {\n" + 
				"	OK1 ok1;\n" + 
				"}",
				"OK1.java",
				"/** */\n" + 
				"public class OK1 {\n" + 
				"	// empty\n" + 
				"}"
		},
        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
        + " -1.5 -g -preserveAllLocals"
        + " -cp " + File.pathSeparator + File.pathSeparator + "\"" + OUTPUT_DIR + "\"" 
        + " -verbose -proceedOnError -referenceInfo" 
        + " -d \"" + OUTPUT_DIR + "\"",
        "[2 .class files generated]\n",
        "incorrect classpath\n",
        true);
}
// command line - unusual classpath (empty, but using current directory, still OK provided 
//	that we execute from the appropriate directory); since there is no notion
// of current directory for this tests suite, the test is not executed
// TODO (maxime) enforce working directory
	public void _test018(){
		this.runConformTest(
			new String[] {

	        "",
	        true);
	}
public void test019(){
		this.runNegativeTest(
			new String[] {
				"X.java",

	        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
	        + " -1.5 -g -preserveAllLocals" 
	        + " -cp \"" + OUTPUT_DIR + "[+OK2" + File.pathSeparator + "~Warn" + File.pathSeparator + "-KO]\""
	        + " -warn:+deprecation,syntheticAccess,uselessTypeCheck,unsafe,finalBound,unusedLocal" 
	        + " -proceedOnError -referenceInfo"
	        + " -d \"" + OUTPUT_DIR + "\"", 
	        "", 
			"----------\n" + 
			"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
			" (at line 5)\n" + 
			"	Warn warn;\n" + 
			"	^^^^\n" + 
			"Discouraged access: The type Warn is not accessible due to restriction on classpath entry ---OUTPUT_DIR_PLACEHOLDER---\n" + 
			"----------\n" + 
			"2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
			" (at line 6)\n" + 
			"	KO ko;\n" + 
			"	^^\n" + 
			"Access restriction: The type KO is not accessible due to restriction on classpath entry ---OUTPUT_DIR_PLACEHOLDER---\n" + 
			"----------\n" + 
			"3. ERROR in ---OUTPUT_DIR_PLACEHOLDER---/X.java\n" + 
			" (at line 7)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n" + 
			"3 problems (1 error, 2 warnings)",
	        "----------\n" + 
	        "3 problems (1 error, 2 warnings)",
	        true);
	}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - skip options -O -Jxxx and -Xxxx, multiple times if needed
	public void test020(){
		this.runConformTest(
			new String[] {
					"X.java",

	        + " -1.5 -g -preserveAllLocals"
	        + " -verbose -proceedOnError -referenceInfo"
	        + " -d \"" + OUTPUT_DIR + "\" -O -Xxxx -O -Jxyz -Xtyu -Jyu",
			"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
			"[reading    java/lang/Object.class]\n" + 
			"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
			"[writing    X.class - #1]\n" + 
			"[completed  ---OUTPUT_DIR_PLACEHOLDER---/X.java - #1/1]\n" + 
			"[1 unit compiled]\n" + 
			"[1 .class file generated]\n",
	        "",
	        true);
	}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - -sourcepath finds additional source files
	public void test021(){
		this.runConformTest(
			new String[] {
					"src1/X.java",

	        + " -1.5 -g -preserveAllLocals"
	        + " -verbose -proceedOnError -referenceInfo"
	        + " -d \"" + OUTPUT_DIR + "\" ",
			"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/1]\n" + 
			"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
			"[reading    java/lang/Object.class]\n" + 
			"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
			"[writing    Y.class - #1]\n" + 
			"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
			"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
			"[writing    X.class - #2]\n" + 
			"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
			"[2 units compiled]\n" + 
			"[2 .class files generated]\n",
	        "",
	        true);
	}

		        true);
		}
//	 https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - explicit empty -extdirs removes extensions
		public void test024(){
			this.runNegativeTest(
				new String[] {
						"X.java",

		        "\"" + OUTPUT_DIR +  File.separator + "X.java\""
				+ " -extdirs \"\"" 
		        + " -1.5 -g -preserveAllLocals"
		        + " -proceedOnError -referenceInfo"
		        + " -d \"" + OUTPUT_DIR + "\" ",
		        "",
		        "----------\n" + 
		        "1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---" + File.separator + "X.java\n" + 
		        " (at line 3)\n" + 

		        true);
		}
//	 https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - cumulative -extdirs extends the classpath
		public void test025(){
			this.runConformTest(
				new String[] {
						"src1/X.java",

		        + " -1.5 -g -preserveAllLocals"
		        + " -verbose -proceedOnError -referenceInfo"
		        + " -d \"" + OUTPUT_DIR + "\" ",
				"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/1]\n" + 
				"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[reading    java/lang/Object.class]\n" + 
				"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
				"[writing    Y.class - #1]\n" + 
				"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
				"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[reading    sun/net/spi/nameservice/dns/DNSNameService.class]\n" + 
				"[writing    X.class - #2]\n" + 
				"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[2 units compiled]\n" + 
				"[2 .class files generated]\n",
		        "",
		        true);
		}
//	 https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - -extdirs extends the classpath before -classpath
		public void test026(){
			this.runConformTest(
				new String[] {
						"src1/X.java",

		        + " -1.5 -g -preserveAllLocals"
		        + " -verbose -proceedOnError -referenceInfo"
		        + " -d \"" + OUTPUT_DIR + "\" ",
				"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/1]\n" + 
				"[parsing    ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[reading    java/lang/Object.class]\n" + 
				"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
				"[writing    Y.class - #1]\n" + 
				"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src2/Y.java - #1/2]\n" + 
				"[analyzing  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[writing    X.class - #2]\n" + 
				"[completed  ---OUTPUT_DIR_PLACEHOLDER---/src1/X.java - #2/2]\n" + 
				"[2 units compiled]\n" + 
				"[2 .class files generated]\n",
				"",
		        true);
		}

Return to bug 99620

Lines 27-32 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/Compiler.java (-47 / +158 lines)
27	public ICompilerRequestor requestor;	27	public ICompilerRequestor requestor;
28	public CompilerOptions options;	28	public CompilerOptions options;
29	public ProblemReporter problemReporter;	29	public ProblemReporter problemReporter;
		30	protected PrintWriter out; // output for messages that are not sent to problemReporter
30		31
31	// management of unit to be processed	32	// management of unit to be processed
32	//public CompilationUnitResult currentCompilationUnitResult;	33	//public CompilationUnitResult currentCompilationUnitResult;
Lines 83-115 Link Here
83	* them back as part of the compilation unit result.	84	* them back as part of the compilation unit result.
84	*/	85	*/
85	public Compiler(	86	public Compiler(
86	INameEnvironment environment,	87	INameEnvironment environment,
87	IErrorHandlingPolicy policy,	88	IErrorHandlingPolicy policy,
88	Map settings,	89	Map settings,
89	final ICompilerRequestor requestor,	90	final ICompilerRequestor requestor,
90	IProblemFactory problemFactory) {	91	IProblemFactory problemFactory) {
91		92	this(environment, policy, settings, requestor, problemFactory,
92	// create a problem handler given a handling policy	93	null, false, false, false, false); // all defaults
93	this.options = new CompilerOptions(settings);	94	}
94		95
95	// wrap requestor in DebugRequestor if one is specified	96	/**
96	if(DebugRequestor == null) {	97	* Answer a new compiler using the given name environment and compiler options.
97	this.requestor = requestor;	98	* The environment and options will be in effect for the lifetime of the compiler.
98	} else {	99	* When the compiler is run, compilation results are sent to the given requestor.
99	this.requestor = new ICompilerRequestor(){	100	*
100	public void acceptResult(CompilationResult result){	101	* @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
101	if (DebugRequestor.isActive()){	102	* Environment used by the compiler in order to resolve type and package
102	DebugRequestor.acceptDebugResult(result);	103	* names. The name environment implements the actual connection of the compiler
103	}	104	* to the outside world (e.g. in batch mode the name environment is performing
104	requestor.acceptResult(result);	105	* pure file accesses, reuse previous build state or connection to repositories).
105	}	106	* Note: the name environment is responsible for implementing the actual classpath
106	};	107	* rules.
107	}	108	*
108	this.problemReporter =	109	* @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
109	new ProblemReporter(policy, this.options, problemFactory);	110	* Configurable part for problem handling, allowing the compiler client to
110	this.lookupEnvironment =	111	* specify the rules for handling problems (stop on first error or accumulate
111	new LookupEnvironment(this, this.options, this.problemReporter, environment);	112	* them all) and at the same time perform some actions such as opening a dialog
112	initializeParser();	113	* in UI when compiling interactively.
		114	* @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
		115	*
		116	* @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
		117	* Component which will receive and persist all compilation results and is intended
		118	* to consume them as they are produced. Typically, in a batch compiler, it is
		119	* responsible for writing out the actual .class files to the file system.
		120	* @see org.eclipse.jdt.internal.compiler.CompilationResult
		121	*
		122	* @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
		123	* Factory used inside the compiler to create problem descriptors. It allows the
		124	* compiler client to supply its own representation of compilation problems in
		125	* order to avoid object conversions. Note that the factory is not supposed
		126	* to accumulate the created problems, the compiler will gather them all and hand
		127	* them back as part of the compilation unit result.
		128	*
		129	* @param out java.io.PrintWriter
		130	* Used by the compiler to output messages which are not related to problems,
		131	* e.g. the information issued in verbose mode. If null, defaults to System.out
		132	* with automatic flushing.
		133	*/
		134	public Compiler(
		135	INameEnvironment environment,
		136	IErrorHandlingPolicy policy,
		137	Map settings,
		138	final ICompilerRequestor requestor,
		139	IProblemFactory problemFactory,
		140	PrintWriter out) {
		141	this(environment, policy, settings, requestor, problemFactory, out,
		142	false, false, false, false); // all defaults
113	}	143	}
114		144
115	/**	145	/**
Lines 144-170 Link Here
144	* order to avoid object conversions. Note that the factory is not supposed	174	* order to avoid object conversions. Note that the factory is not supposed
145	* to accumulate the created problems, the compiler will gather them all and hand	175	* to accumulate the created problems, the compiler will gather them all and hand
146	* them back as part of the compilation unit result.	176	* them back as part of the compilation unit result.
		177	*
147	* @param parseLiteralExpressionsAsConstants <code>boolean</code>	178	* @param parseLiteralExpressionsAsConstants <code>boolean</code>
148	* This parameter is used to optimize the literals or leave them as they are in the source.	179	* This parameter is used to optimize the literals or leave them as they are in the source.
149	* If you put true, "Hello" + " world" will be converted to "Hello world".	180	* If you put true, "Hello" + " world" will be converted to "Hello world".
		181	*
		182	* @param storeAnnotations <code>boolean</code>
		183	* This parameter is used to tell the compiler to store annotations on
		184	* type bindings, or not.
		185	*
		186	* @param statementsRecovery <code>boolean</code>
		187	* This parameter is used to tell the compiler to perform syntax error
		188	* recovery on statements, or not.
150	*/	189	*/
151	public Compiler(	190	public Compiler(
152	INameEnvironment environment,	191	INameEnvironment environment,
153	IErrorHandlingPolicy policy,	192	IErrorHandlingPolicy policy,
154	Map settings,	193	Map settings,
155	final ICompilerRequestor requestor,	194	final ICompilerRequestor requestor,
156	IProblemFactory problemFactory,	195	IProblemFactory problemFactory,
157	boolean parseLiteralExpressionsAsConstants,	196	boolean parseLiteralExpressionsAsConstants,
158	boolean storeAnnotations,	197	boolean storeAnnotations,
159	boolean statementsRecovery) {	198	boolean statementsRecovery) {
		199	this(environment, policy, settings, requestor, problemFactory,
		200	null, // default
		201	parseLiteralExpressionsAsConstants, storeAnnotations, statementsRecovery, true);
		202	}
		203
		204	/**
		205	* Answer a new compiler using the given name environment and compiler options.
		206	* The environment and options will be in effect for the lifetime of the compiler.
		207	* When the compiler is run, compilation results are sent to the given requestor.
		208	*
		209	* @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
		210	* Environment used by the compiler in order to resolve type and package
		211	* names. The name environment implements the actual connection of the compiler
		212	* to the outside world (e.g. in batch mode the name environment is performing
		213	* pure file accesses, reuse previous build state or connection to repositories).
		214	* Note: the name environment is responsible for implementing the actual classpath
		215	* rules.
		216	*
		217	* @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
		218	* Configurable part for problem handling, allowing the compiler client to
		219	* specify the rules for handling problems (stop on first error or accumulate
		220	* them all) and at the same time perform some actions such as opening a dialog
		221	* in UI when compiling interactively.
		222	* @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
		223	*
		224	* @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
		225	* Component which will receive and persist all compilation results and is intended
		226	* to consume them as they are produced. Typically, in a batch compiler, it is
		227	* responsible for writing out the actual .class files to the file system.
		228	* @see org.eclipse.jdt.internal.compiler.CompilationResult
		229	*
		230	* @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
		231	* Factory used inside the compiler to create problem descriptors. It allows the
		232	* compiler client to supply its own representation of compilation problems in
		233	* order to avoid object conversions. Note that the factory is not supposed
		234	* to accumulate the created problems, the compiler will gather them all and hand
		235	* them back as part of the compilation unit result.
		236	*
		237	* @param out java.io.PrintWriter
		238	* Used by the compiler to output messages which are not related to problems,
		239	* e.g. the information issued in verbose mode. If null, defaults to System.out
		240	* with automatic flushing.
		241	*
		242	* @param parseLiteralExpressionsAsConstants <code>boolean</code>
		243	* This parameter is used to optimize the literals or leave them as they are in the source.
		244	* If you put true, "Hello" + " world" will be converted to "Hello world".
		245	*
		246	* @param storeAnnotations <code>boolean</code>
		247	* This parameter is used to tell the compiler to store annotations on
		248	* type bindings, or not.
		249	*
		250	* @param statementsRecovery <code>boolean</code>
		251	* This parameter is used to tell the compiler to perform syntax error
		252	* recovery on statements, or not.
		253	*
		254	* @param flag <code>boolean</code>
		255	* Set to true if and only if the other boolean parameters are significant.
		256	*/
		257	private Compiler(
		258	INameEnvironment environment,
		259	IErrorHandlingPolicy policy,
		260	Map settings,
		261	final ICompilerRequestor requestor,
		262	IProblemFactory problemFactory,
263	PrintWriter out,
264	boolean parseLiteralExpressionsAsConstants,
265	boolean storeAnnotations,
266	boolean statementsRecovery,
267	boolean flag) {
160		268
161	// create a problem handler given a handling policy	269	// create a problem handler given a handling policy
162	this.options = new CompilerOptions(settings);	270	this.options = new CompilerOptions(settings);
163	this.options.parseLiteralExpressionsAsConstants = parseLiteralExpressionsAsConstants;	271	if (flag) { // boolean parameters are significant, pass them down
164	this.options.storeAnnotations = storeAnnotations;	272	this.options.parseLiteralExpressionsAsConstants = parseLiteralExpressionsAsConstants;
165	this.options.performStatementsRecovery =	273	this.options.storeAnnotations = storeAnnotations;
166	statementsRecovery &&	274	this.options.performStatementsRecovery =
167	this.options.performStatementsRecovery;// TODO temporary code to take into account the temporary JavaCore options	275	statementsRecovery &&
		276	this.options.performStatementsRecovery;// TODO temporary code to take into account the temporary JavaCore options
		277	}
168		278
169	// wrap requestor in DebugRequestor if one is specified	279	// wrap requestor in DebugRequestor if one is specified
170	if(DebugRequestor == null) {	280	if(DebugRequestor == null) {
Lines 181-186 Link Here
181	}	291	}
182	this.problemReporter = new ProblemReporter(policy, this.options, problemFactory);	292	this.problemReporter = new ProblemReporter(policy, this.options, problemFactory);
183	this.lookupEnvironment = new LookupEnvironment(this, this.options, problemReporter, environment);	293	this.lookupEnvironment = new LookupEnvironment(this, this.options, problemReporter, environment);
		294	this.out = out == null ? new PrintWriter(System.out, true) : out;
184	initializeParser();	295	initializeParser();
185	}	296	}
186		297
Lines 189-195 Link Here
189	*/	300	*/
190	public void accept(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) {	301	public void accept(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) {
191	if (this.options.verbose) {	302	if (this.options.verbose) {
192	System.out.println(	303	this.out.println(
193	Messages.bind(Messages.compilation_loadBinary, new String(binaryType.getName())));	304	Messages.bind(Messages.compilation_loadBinary, new String(binaryType.getName())));
194	// new Exception("TRACE BINARY").printStackTrace(System.out);	305	// new Exception("TRACE BINARY").printStackTrace(System.out);
195	// System.out.println();	306	// System.out.println();
Lines 208-214 Link Here
208	try {	319	try {
209	if (options.verbose) {	320	if (options.verbose) {
210	String count = String.valueOf(totalUnits + 1);	321	String count = String.valueOf(totalUnits + 1);
211	System.out.println(	322	this.out.println(
212	Messages.bind(Messages.compilation_request,	323	Messages.bind(Messages.compilation_request,
213	new String[] {	324	new String[] {
214	count,	325	count,
Lines 281-287 Link Here
281	new CompilationResult(sourceUnits[i], i, maxUnits, this.options.maxProblemsPerUnit);	392	new CompilationResult(sourceUnits[i], i, maxUnits, this.options.maxProblemsPerUnit);
282	try {	393	try {
283	if (options.verbose) {	394	if (options.verbose) {
284	System.out.println(	395	this.out.println(
285	Messages.bind(Messages.compilation_request,	396	Messages.bind(Messages.compilation_request,
286	new String[] {	397	new String[] {
287	String.valueOf(i + 1),	398	String.valueOf(i + 1),
Lines 326-332 Link Here
326	unit = unitsToProcess[i];	437	unit = unitsToProcess[i];
327	try {	438	try {
328	if (options.verbose)	439	if (options.verbose)
329	System.out.println(	440	this.out.println(
330	Messages.bind(Messages.compilation_process,	441	Messages.bind(Messages.compilation_process,
331	new String[] {	442	new String[] {
332	String.valueOf(i + 1),	443	String.valueOf(i + 1),
Lines 341-347 Link Here
341	unitsToProcess[i] = null; // release reference to processed unit declaration	452	unitsToProcess[i] = null; // release reference to processed unit declaration
342	requestor.acceptResult(unit.compilationResult.tagAsAccepted());	453	requestor.acceptResult(unit.compilationResult.tagAsAccepted());
343	if (options.verbose)	454	if (options.verbose)
344	System.out.println(	455	this.out.println(
345	Messages.bind(Messages.compilation_done,	456	Messages.bind(Messages.compilation_done,
346	new String[] {	457	new String[] {
347	String.valueOf(i + 1),	458	String.valueOf(i + 1),
Lines 362-371 Link Here
362	}	473	}
363	if (options.verbose) {	474	if (options.verbose) {
364	if (this.totalUnits > 1) {	475	if (this.totalUnits > 1) {
365	System.out.println(	476	this.out.println(
366	Messages.bind(Messages.compilation_units, String.valueOf(this.totalUnits)));	477	Messages.bind(Messages.compilation_units, String.valueOf(this.totalUnits)));
367	} else {	478	} else {
368	System.out.println(	479	this.out.println(
369	Messages.bind(Messages.compilation_unit, String.valueOf(this.totalUnits)));	480	Messages.bind(Messages.compilation_unit, String.valueOf(this.totalUnits)));
370	}	481	}
371	}	482	}