net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/Compiler.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v0.5
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v05.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  ******************************************************************************/
  11 package net.sourceforge.phpdt.internal.compiler;
  12
  13 import net.sourceforge.phpdt.core.compiler.*;
  14 import net.sourceforge.phpdt.internal.compiler.env.*;
  15 import net.sourceforge.phpdt.internal.compiler.impl.*;
  16 import net.sourceforge.phpdt.internal.compiler.ast.*;
  17 import net.sourceforge.phpdt.internal.compiler.lookup.*;
  18 import net.sourceforge.phpdt.internal.compiler.parser.*;
  19 import net.sourceforge.phpdt.internal.compiler.problem.*;
  20 import net.sourceforge.phpdt.internal.compiler.util.*;
  21
  22 import java.io.*;
  23 import java.util.*;
  24
  25 public class Compiler implements ITypeRequestor, ProblemSeverities {
  26         public Parser parser;
  27         ICompilerRequestor requestor;
  28         public CompilerOptions options;
  29         public ProblemReporter problemReporter;
  30
  31         // management of unit to be processed
  32         //public CompilationUnitResult currentCompilationUnitResult;
  33         CompilationUnitDeclaration[] unitsToProcess;
  34         int totalUnits; // (totalUnits-1) gives the last unit in unitToProcess
  35
  36         // name lookup
  37         public LookupEnvironment lookupEnvironment;
  38
  39         // ONCE STABILIZED, THESE SHOULD RETURN TO A FINAL FIELD
  40         public static boolean DEBUG = false;
  41         public int parseThreshold = -1;
  42         // number of initial units parsed at once (-1: none)
  43
  44         /*
  45          * Static requestor reserved to listening compilation results in debug mode,
  46          * so as for example to monitor compiler activity independantly from a particular
  47          * builder implementation. It is reset at the end of compilation, and should not
  48          * persist any information after having been reset.
  49          */
  50         public static IDebugRequestor DebugRequestor = null;
  51
  52         /**
  53          * Answer a new compiler using the given name environment and compiler options.
  54          * The environment and options will be in effect for the lifetime of the compiler.
  55          * When the compiler is run, compilation results are sent to the given requestor.
  56          *
  57          *  @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
  58          *      Environment used by the compiler in order to resolve type and package
  59          *      names. The name environment implements the actual connection of the compiler
  60          *      to the outside world (e.g. in batch mode the name environment is performing
  61          *      pure file accesses, reuse previous build state or connection to repositories).
  62          *      Note: the name environment is responsible for implementing the actual classpath
  63          *            rules.
  64          *
  65          *  @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
  66          *      Configurable part for problem handling, allowing the compiler client to
  67          *      specify the rules for handling problems (stop on first error or accumulate
  68          *      them all) and at the same time perform some actions such as opening a dialog
  69          *      in UI when compiling interactively.
  70          *      @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
  71          *
  72          *  @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
  73          *      Component which will receive and persist all compilation results and is intended
  74          *      to consume them as they are produced. Typically, in a batch compiler, it is
  75          *      responsible for writing out the actual .class files to the file system.
  76          *      @see org.eclipse.jdt.internal.compiler.CompilationResult
  77          *
  78          *  @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
  79          *      Factory used inside the compiler to create problem descriptors. It allows the
  80          *      compiler client to supply its own representation of compilation problems in
  81          *      order to avoid object conversions. Note that the factory is not supposed
  82          *      to accumulate the created problems, the compiler will gather them all and hand
  83          *      them back as part of the compilation unit result.
  84          */
  85         public Compiler(
  86                 INameEnvironment environment,
  87                 IErrorHandlingPolicy policy,
  88                 Map settings,
  89                 final ICompilerRequestor requestor,
  90                 IProblemFactory problemFactory) {
  91
  92                 // create a problem handler given a handling policy
  93                 this.options = new CompilerOptions(settings);
  94
  95                 // wrap requestor in DebugRequestor if one is specified
  96                 if(DebugRequestor == null) {
  97                         this.requestor = requestor;
  98                 } else {
  99                         this.requestor = new ICompilerRequestor(){
 100                                 public void acceptResult(CompilationResult result){
 101                                         if (DebugRequestor.isActive()){
 102                                                 DebugRequestor.acceptDebugResult(result);
 103                                         }
 104                                         requestor.acceptResult(result);
 105                                 }
 106                         };
 107                 }
 108                 this.problemReporter =
 109                         new ProblemReporter(policy, this.options, problemFactory);
 110                 this.lookupEnvironment =
 111                         new LookupEnvironment(this, options, problemReporter, environment);
 112                 this.parser =
 113                         new Parser(
 114                                 problemReporter,
 115                                 this.options.parseLiteralExpressionsAsConstants,
 116                                 this.options.assertMode);
 117         }
 118
 119         /**
 120          * Answer a new compiler using the given name environment and compiler options.
 121          * The environment and options will be in effect for the lifetime of the compiler.
 122          * When the compiler is run, compilation results are sent to the given requestor.
 123          *
 124          *  @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
 125          *      Environment used by the compiler in order to resolve type and package
 126          *      names. The name environment implements the actual connection of the compiler
 127          *      to the outside world (e.g. in batch mode the name environment is performing
 128          *      pure file accesses, reuse previous build state or connection to repositories).
 129          *      Note: the name environment is responsible for implementing the actual classpath
 130          *            rules.
 131          *
 132          *  @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
 133          *      Configurable part for problem handling, allowing the compiler client to
 134          *      specify the rules for handling problems (stop on first error or accumulate
 135          *      them all) and at the same time perform some actions such as opening a dialog
 136          *      in UI when compiling interactively.
 137          *      @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
 138          *
 139          *  @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
 140          *      Component which will receive and persist all compilation results and is intended
 141          *      to consume them as they are produced. Typically, in a batch compiler, it is
 142          *      responsible for writing out the actual .class files to the file system.
 143          *      @see org.eclipse.jdt.internal.compiler.CompilationResult
 144          *
 145          *  @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
 146          *      Factory used inside the compiler to create problem descriptors. It allows the
 147          *      compiler client to supply its own representation of compilation problems in
 148          *      order to avoid object conversions. Note that the factory is not supposed
 149          *      to accumulate the created problems, the compiler will gather them all and hand
 150          *      them back as part of the compilation unit result.
 151          *      @param parseLiteralExpressionsAsConstants <code>boolean</code>
 152          *              This parameter is used to optimize the literals or leave them as they are in the source.
 153          *              If you put true, "Hello" + " world" will be converted to "Hello world".
 154          */
 155         public Compiler(
 156                 INameEnvironment environment,
 157                 IErrorHandlingPolicy policy,
 158                 Map settings,
 159                 final ICompilerRequestor requestor,
 160                 IProblemFactory problemFactory,
 161                 boolean parseLiteralExpressionsAsConstants) {
 162
 163                 // create a problem handler given a handling policy
 164                 this.options = new CompilerOptions(settings);
 165
 166                 // wrap requestor in DebugRequestor if one is specified
 167                 if(DebugRequestor == null) {
 168                         this.requestor = requestor;
 169                 } else {
 170                         this.requestor = new ICompilerRequestor(){
 171                                 public void acceptResult(CompilationResult result){
 172                                         if (DebugRequestor.isActive()){
 173                                                 DebugRequestor.acceptDebugResult(result);
 174                                         }
 175                                         requestor.acceptResult(result);
 176                                 }
 177                         };
 178                 }
 179                 this.problemReporter =
 180                         new ProblemReporter(policy, this.options, problemFactory);
 181                 this.lookupEnvironment =
 182                         new LookupEnvironment(this, options, problemReporter, environment);
 183                 this.parser =
 184                         new Parser(
 185                                 problemReporter,
 186                                 parseLiteralExpressionsAsConstants,
 187                                 this.options.assertMode);
 188         }
 189
 190         /**
 191          * Add an additional binary type
 192          */
 193         public void accept(IBinaryType binaryType, PackageBinding packageBinding) {
 194                 lookupEnvironment.createBinaryTypeFrom(binaryType, packageBinding);
 195         }
 196
 197         /**
 198          * Add an additional compilation unit into the loop
 199          *  ->  build compilation unit declarations, their bindings and record their results.
 200          */
 201         public void accept(ICompilationUnit sourceUnit) {
 202                 // Switch the current policy and compilation result for this unit to the requested one.
 203                 CompilationResult unitResult =
 204                         new CompilationResult(sourceUnit, totalUnits, totalUnits, this.options.maxProblemsPerUnit);
 205                 try {
 206                         // diet parsing for large collection of unit
 207                         CompilationUnitDeclaration parsedUnit;
 208                         if (totalUnits < parseThreshold) {
 209                                 parsedUnit = parser.parse(sourceUnit, unitResult);
 210                         } else {
 211                                 parsedUnit = parser.dietParse(sourceUnit, unitResult);
 212                         }
 213
 214                         if (options.verbose) {
 215                                 System.out.println(
 216                                         Util.bind(
 217                                                 "compilation.request" , //$NON-NLS-1$
 218                                                 new String[] {
 219                                                         String.valueOf(totalUnits + 1),
 220                                                         String.valueOf(totalUnits + 1),
 221                                                         new String(sourceUnit.getFileName())}));
 222                         }
 223
 224                         // initial type binding creation
 225                         lookupEnvironment.buildTypeBindings(parsedUnit);
 226                         this.addCompilationUnit(sourceUnit, parsedUnit);
 227
 228                         // binding resolution
 229                         lookupEnvironment.completeTypeBindings(parsedUnit);
 230                 } catch (AbortCompilationUnit e) {
 231                         // at this point, currentCompilationUnitResult may not be sourceUnit, but some other
 232                         // one requested further along to resolve sourceUnit.
 233                         if (unitResult.compilationUnit == sourceUnit) { // only report once
 234                                 requestor.acceptResult(unitResult.tagAsAccepted());
 235                         } else {
 236                                 throw e; // want to abort enclosing request to compile
 237                         }
 238                 }
 239         }
 240
 241         /**
 242          * Add additional source types
 243          */
 244         public void accept(ISourceType[] sourceTypes, PackageBinding packageBinding) {
 245                 problemReporter.abortDueToInternalError(
 246                         Util.bind(
 247                                 "abort.againstSourceModel " , //$NON-NLS-1$
 248                                 String.valueOf(sourceTypes[0].getName()),
 249                                 String.valueOf(sourceTypes[0].getFileName())));
 250         }
 251
 252         protected void addCompilationUnit(
 253                 ICompilationUnit sourceUnit,
 254                 CompilationUnitDeclaration parsedUnit) {
 255
 256                 // append the unit to the list of ones to process later on
 257                 int size = unitsToProcess.length;
 258                 if (totalUnits == size)
 259                         // when growing reposition units starting at position 0
 260                         System.arraycopy(
 261                                 unitsToProcess,
 262                                 0,
 263                                 (unitsToProcess = new CompilationUnitDeclaration[size * 2]),
 264                                 0,
 265                                 totalUnits);
 266                 unitsToProcess[totalUnits++] = parsedUnit;
 267         }
 268
 269         /**
 270          * Add the initial set of compilation units into the loop
 271          *  ->  build compilation unit declarations, their bindings and record their results.
 272          */
 273         protected void beginToCompile(ICompilationUnit[] sourceUnits) {
 274                 int maxUnits = sourceUnits.length;
 275                 totalUnits = 0;
 276                 unitsToProcess = new CompilationUnitDeclaration[maxUnits];
 277
 278                 // Switch the current policy and compilation result for this unit to the requested one.
 279                 for (int i = 0; i < maxUnits; i++) {
 280                         CompilationUnitDeclaration parsedUnit;
 281                         CompilationResult unitResult =
 282                                 new CompilationResult(sourceUnits[i], i, maxUnits, this.options.maxProblemsPerUnit);
 283                         try {
 284                                 // diet parsing for large collection of units
 285                                 if (totalUnits < parseThreshold) {
 286                                         parsedUnit = parser.parse(sourceUnits[i], unitResult);
 287                                 } else {
 288                                         parsedUnit = parser.dietParse(sourceUnits[i], unitResult);
 289                                 }
 290                                 if (options.verbose) {
 291                                         System.out.println(
 292                                                 Util.bind(
 293                                                         "compilation.request" , //$NON-NLS-1$
 294                                                         new String[] {
 295                                                                 String.valueOf(i + 1),
 296                                                                 String.valueOf(maxUnits),
 297                                                                 new String(sourceUnits[i].getFileName())}));
 298                                 }
 299                                 // initial type binding creation
 300                                 lookupEnvironment.buildTypeBindings(parsedUnit);
 301                                 this.addCompilationUnit(sourceUnits[i], parsedUnit);
 302                                 //} catch (AbortCompilationUnit e) {
 303                                 //      requestor.acceptResult(unitResult.tagAsAccepted());
 304                         } finally {
 305                                 sourceUnits[i] = null; // no longer hold onto the unit
 306                         }
 307                 }
 308                 // binding resolution
 309                 lookupEnvironment.completeTypeBindings();
 310         }
 311
 312         /**
 313          * General API
 314          * -> compile each of supplied files
 315          * -> recompile any required types for which we have an incomplete principle structure
 316          */
 317         public void compile(ICompilationUnit[] sourceUnits) {
 318                 CompilationUnitDeclaration unit = null;
 319                 int i = 0;
 320                 try {
 321                         // build and record parsed units
 322
 323                         beginToCompile(sourceUnits);
 324
 325                         // process all units (some more could be injected in the loop by the lookup environment)
 326                         for (; i < totalUnits; i++) {
 327                                 unit = unitsToProcess[i];
 328                                 try {
 329                                         if (options.verbose)
 330                                                 System.out.println(
 331                                                         Util.bind(
 332                                                                 "compilation.process" , //$NON-NLS-1$
 333                                                                 new String[] {
 334                                                                         String.valueOf(i + 1),
 335                                                                         String.valueOf(totalUnits),
 336                                                                         new String(unitsToProcess[i].getFileName())}));
 337                                         process(unit, i);
 338                                 } finally {
 339                                         // cleanup compilation unit result
 340                                         unit.cleanUp();
 341                                         if (options.verbose)
 342                                                 System.out.println(Util.bind("compilation.done", //$NON-NLS-1$
 343                                         new String[] {
 344                                                 String.valueOf(i + 1),
 345                                                 String.valueOf(totalUnits),
 346                                                 new String(unitsToProcess[i].getFileName())}));
 347                                 }
 348                                 unitsToProcess[i] = null; // release reference to processed unit declaration
 349                                 requestor.acceptResult(unit.compilationResult.tagAsAccepted());
 350                         }
 351                 } catch (AbortCompilation e) {
 352                         this.handleInternalException(e, unit);
 353                 } catch (Error e) {
 354                         this.handleInternalException(e, unit, null);
 355                         throw e; // rethrow
 356                 } catch (RuntimeException e) {
 357                         this.handleInternalException(e, unit, null);
 358                         throw e; // rethrow
 359                 } finally {
 360                         this.reset();
 361                 }
 362                 if (options.verbose) {
 363                         if (totalUnits > 1) {
 364                                 System.out.println(
 365                                         Util.bind("compilation.units" , String.valueOf(totalUnits))); //$NON-NLS-1$
 366                         } else {
 367                                 System.out.println(
 368                                         Util.bind("compilation.unit" , String.valueOf(totalUnits))); //$NON-NLS-1$
 369                         }
 370                 }
 371         }
 372
 373         protected void getMethodBodies(CompilationUnitDeclaration unit, int place) {
 374                 //fill the methods bodies in order for the code to be generated
 375
 376                 if (unit.ignoreMethodBodies) {
 377                         unit.ignoreFurtherInvestigation = true;
 378                         return;
 379                         // if initial diet parse did not work, no need to dig into method bodies.
 380                 }
 381
 382                 if (place < parseThreshold)
 383                         return; //work already done ...
 384
 385                 //real parse of the method....
 386                 parser.scanner.setSource(
 387                         unit.compilationResult.compilationUnit.getContents());
 388                 if (unit.types != null) {
 389                         for (int i = unit.types.length; --i >= 0;)
 390                                 unit.types[i].parseMethod(parser, unit);
 391                 }
 392         }
 393
 394         /*
 395          * Compiler crash recovery in case of unexpected runtime exceptions
 396          */
 397         protected void handleInternalException(
 398                 Throwable internalException,
 399                 CompilationUnitDeclaration unit,
 400                 CompilationResult result) {
 401
 402                 /* dump a stack trace to the console */
 403                 internalException.printStackTrace();
 404
 405                 /* find a compilation result */
 406                 if ((unit != null)) // basing result upon the current unit if available
 407                         result = unit.compilationResult; // current unit being processed ?
 408                 if ((result == null) && (unitsToProcess != null) && (totalUnits > 0))
 409                         result = unitsToProcess[totalUnits - 1].compilationResult;
 410                 // last unit in beginToCompile ?
 411
 412                 if (result != null) {
 413                         /* create and record a compilation problem */
 414                         StringWriter stringWriter = new StringWriter();
 415                         PrintWriter writer = new PrintWriter(stringWriter);
 416                         internalException.printStackTrace(writer);
 417                         StringBuffer buffer = stringWriter.getBuffer();
 418
 419                         result
 420                                 .record(
 421                                         problemReporter
 422                                         .createProblem(
 423                                                 result.getFileName(),
 424                                                 IProblem.Unclassified,
 425                                                 new String[] {
 426                                                         Util.bind("compilation.internalError" ) //$NON-NLS-1$
 427                                                                 + "\n"  //$NON-NLS-1$
 428                                                                 + buffer.toString()},
 429                                                 Error, // severity
 430                                                 0, // source start
 431                                                 0, // source end
 432                                                 0, // line number
 433                                                 unit,
 434                                                 result),
 435                                         unit);
 436
 437                         /* hand back the compilation result */
 438                         if (!result.hasBeenAccepted) {
 439                                 requestor.acceptResult(result.tagAsAccepted());
 440                         }
 441                 }
 442         }
 443
 444         /*
 445          * Compiler recovery in case of internal AbortCompilation event
 446          */
 447         protected void handleInternalException(
 448                 AbortCompilation abortException,
 449                 CompilationUnitDeclaration unit) {
 450
 451                 /* special treatment for SilentAbort: silently cancelling the compilation process */
 452                 if (abortException.isSilent) {
 453                         if (abortException.silentException == null) {
 454                                 return;
 455                         } else {
 456                                 throw abortException.silentException;
 457                         }
 458                 }
 459
 460                 /* uncomment following line to see where the abort came from */
 461                 // abortException.printStackTrace();
 462
 463                 // Exception may tell which compilation result it is related, and which problem caused it
 464                 CompilationResult result = abortException.compilationResult;
 465                 if ((result == null) && (unit != null))
 466                         result = unit.compilationResult; // current unit being processed ?
 467                 if ((result == null) && (unitsToProcess != null) && (totalUnits > 0))
 468                         result = unitsToProcess[totalUnits - 1].compilationResult;
 469                 // last unit in beginToCompile ?
 470                 if (result != null && !result.hasBeenAccepted) {
 471                         /* distant problem which could not be reported back there */
 472                         if (abortException.problemId != 0) {
 473                                 result
 474                                         .record(
 475                                                 problemReporter
 476                                                 .createProblem(
 477                                                         result.getFileName(),
 478                                                         abortException.problemId,
 479                                                         abortException.problemArguments,
 480                                                         Error, // severity
 481                                                         0, // source start
 482                                                         0, // source end
 483                                                         0, // line number
 484                                                         unit,
 485                                                         result),
 486                                                 unit);
 487                         } else {
 488                                 /* distant internal exception which could not be reported back there */
 489                                 if (abortException.exception != null) {
 490                                         this.handleInternalException(abortException.exception, null, result);
 491                                         return;
 492                                 }
 493                         }
 494                         /* hand back the compilation result */
 495                         if (!result.hasBeenAccepted) {
 496                                 requestor.acceptResult(result.tagAsAccepted());
 497                         }
 498                 } else {
 499                         /*
 500                         if (abortException.problemId != 0){
 501                                 IProblem problem =
 502                                         problemReporter.createProblem(
 503                                                 "???".toCharArray(),
 504                                                 abortException.problemId,
 505                                                 abortException.problemArguments,
 506                                                 Error, // severity
 507                                                 0, // source start
 508                                                 0, // source end
 509                                                 0); // line number
 510                                 System.out.println(problem.getMessage());
 511                         }
 512                         */
 513                         abortException.printStackTrace();
 514                 }
 515         }
 516
 517         /**
 518          * Process a compilation unit already parsed and build.
 519          */
 520         private void process(CompilationUnitDeclaration unit, int i) {
 521
 522                 getMethodBodies(unit, i);
 523
 524                 // fault in fields & methods
 525                 if (unit.scope != null)
 526                         unit.scope.faultInTypes();
 527
 528                 // verify inherited methods
 529                 if (unit.scope != null)
 530                         unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
 531
 532                 // type checking
 533                 unit.resolve();
 534
 535                 // flow analysis
 536                 unit.analyseCode();
 537
 538                 // code generation
 539                 unit.generateCode();
 540
 541                 // reference info
 542                 if (options.produceReferenceInfo && unit.scope != null)
 543                         unit.scope.storeDependencyInfo();
 544
 545                 // refresh the total number of units known at this stage
 546                 unit.compilationResult.totalUnitsKnown = totalUnits;
 547         }
 548         public void reset() {
 549                 lookupEnvironment.reset();
 550                 parser.scanner.source = null;
 551                 unitsToProcess = null;
 552                 if (DebugRequestor != null) DebugRequestor.reset();
 553         }
 554
 555         /**
 556          * Internal API used to resolve a compilation unit minimally for code assist engine
 557          */
 558         public CompilationUnitDeclaration resolve(ICompilationUnit sourceUnit) {
 559                 CompilationUnitDeclaration unit = null;
 560                 try {
 561                         // build and record parsed units
 562                         parseThreshold = 0; // will request a full parse
 563                         beginToCompile(new ICompilationUnit[] { sourceUnit });
 564                         // process all units (some more could be injected in the loop by the lookup environment)
 565                         unit = unitsToProcess[0];
 566                         getMethodBodies(unit, 0);
 567                         if (unit.scope != null) {
 568                                 // fault in fields & methods
 569                                 unit.scope.faultInTypes();
 570                                 // type checking
 571                                 unit.resolve();
 572                         }
 573                         unitsToProcess[0] = null; // release reference to processed unit declaration
 574                         requestor.acceptResult(unit.compilationResult.tagAsAccepted());
 575                         return unit;
 576                 } catch (AbortCompilation e) {
 577                         this.handleInternalException(e, unit);
 578                         return unit == null ? unitsToProcess[0] : unit;
 579                 } catch (Error e) {
 580                         this.handleInternalException(e, unit, null);
 581                         throw e; // rethrow
 582                 } catch (RuntimeException e) {
 583                         this.handleInternalException(e, unit, null);
 584                         throw e; // rethrow
 585                 } finally {
 586                         // No reset is performed there anymore since,
 587                         // within the CodeAssist (or related tools),
 588                         // the compiler may be called *after* a call
 589                         // to this resolve(...) method. And such a call
 590                         // needs to have a compiler with a non-empty
 591                         // environment.
 592                         // this.reset();
 593                 }
 594         }
 595 }