1 /*
2 * Copyright (c) 2005, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.tools.javac.api;
27
28 import java.io.IOException;
29 import java.nio.CharBuffer;
30 import java.util.*;
31 import java.util.concurrent.Callable;
32 import java.util.concurrent.atomic.AtomicBoolean;
33
34 import javax.annotation.processing.Processor;
35 import javax.lang.model.element.Element;
36 import javax.lang.model.element.TypeElement;
37 import javax.tools.*;
38
39 import com.sun.source.tree.*;
40 import com.sun.tools.javac.code.*;
41 import com.sun.tools.javac.code.Symbol.ClassSymbol;
42 import com.sun.tools.javac.comp.*;
43 import com.sun.tools.javac.file.BaseFileManager;
44 import com.sun.tools.javac.main.*;
45 import com.sun.tools.javac.main.JavaCompiler;
46 import com.sun.tools.javac.parser.Parser;
47 import com.sun.tools.javac.parser.ParserFactory;
48 import com.sun.tools.javac.processing.AnnotationProcessingError;
49 import com.sun.tools.javac.tree.*;
50 import com.sun.tools.javac.tree.JCTree.JCClassDecl;
51 import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
52 import com.sun.tools.javac.tree.JCTree.JCModuleDecl;
53 import com.sun.tools.javac.tree.JCTree.Tag;
54 import com.sun.tools.javac.util.*;
55 import com.sun.tools.javac.util.DefinedBy.Api;
56 import com.sun.tools.javac.util.List;
57 import com.sun.tools.javac.util.Log.PrefixKind;
58 import com.sun.tools.javac.util.Log.WriterKind;
59
60 /**
61 * Provides access to functionality specific to the JDK Java Compiler, javac.
62 *
63 * <p><b>This is NOT part of any supported API.
64 * If you write code that depends on this, you do so at your own
65 * risk. This code and its internal interfaces are subject to change
66 * or deletion without notice.</b></p>
67 *
68 * @author Peter von der Ahé
69 * @author Jonathan Gibbons
70 */
71 public class JavacTaskImpl extends BasicJavacTask {
72 private final Arguments args;
73 private JavaCompiler compiler;
74 private JavaFileManager fileManager;
75 private Locale locale;
76 private Map<JavaFileObject, JCCompilationUnit> notYetEntered;
77 private ListBuffer<Env<AttrContext>> genList;
78 private final AtomicBoolean used = new AtomicBoolean();
79 private Iterable<? extends Processor> processors;
80 private ListBuffer<String> addModules = new ListBuffer<>();
81
82 protected JavacTaskImpl(Context context) {
83 super(context, true);
84 args = Arguments.instance(context);
85 fileManager = context.get(JavaFileManager.class);
86 }
87
88 @Override @DefinedBy(Api.COMPILER)
89 public Boolean call() {
90 return doCall().isOK();
91 }
92
93 /* Internal version of call exposing Main.Result. */
94 public Main.Result doCall() {
95 try {
96 return handleExceptions(() -> {
97 prepareCompiler(false);
98 if (compiler.errorCount() > 0)
99 return Main.Result.ERROR;
100 compiler.compile(args.getFileObjects(), args.getClassNames(), processors, addModules);
101 return (compiler.errorCount() > 0) ? Main.Result.ERROR : Main.Result.OK; // FIXME?
102 }, Main.Result.SYSERR, Main.Result.ABNORMAL);
103 } finally {
104 try {
105 cleanup();
106 } catch (ClientCodeException e) {
107 throw new RuntimeException(e.getCause());
108 }
109 }
110 }
111
112 @Override @DefinedBy(Api.COMPILER)
113 public void addModules(Iterable<String> moduleNames) {
114 Objects.requireNonNull(moduleNames);
115 // not mt-safe
116 if (used.get())
117 throw new IllegalStateException();
118 for (String m : moduleNames) {
119 Objects.requireNonNull(m);
120 addModules.add(m);
121 }
122 }
123
124 @Override @DefinedBy(Api.COMPILER)
125 public void setProcessors(Iterable<? extends Processor> processors) {
126 Objects.requireNonNull(processors);
127 // not mt-safe
128 if (used.get())
129 throw new IllegalStateException();
130 this.processors = processors;
131 }
132
133 @Override @DefinedBy(Api.COMPILER)
134 public void setLocale(Locale locale) {
135 if (used.get())
136 throw new IllegalStateException();
137 this.locale = locale;
138 }
139
140 private <T> T handleExceptions(Callable<T> c, T sysErrorResult, T abnormalErrorResult) {
141 try {
142 return c.call();
143 } catch (FatalError ex) {
144 Log log = Log.instance(context);
145 Options options = Options.instance(context);
146 log.printRawLines(ex.getMessage());
147 if (ex.getCause() != null && options.isSet("dev")) {
148 ex.getCause().printStackTrace(log.getWriter(WriterKind.NOTICE));
149 }
150 return sysErrorResult;
151 } catch (AnnotationProcessingError | ClientCodeException e) {
152 // AnnotationProcessingError is thrown from JavacProcessingEnvironment,
153 // to forward errors thrown from an annotation processor
154 // ClientCodeException is thrown from ClientCodeWrapper,
155 // to forward errors thrown from user-supplied code for Compiler API
156 // as specified by javax.tools.JavaCompiler#getTask
157 // and javax.tools.JavaCompiler.CompilationTask#call
158 throw new RuntimeException(e.getCause());
159 } catch (PropagatedException e) {
160 throw e.getCause();
161 } catch (IllegalStateException e) {
162 throw e;
163 } catch (Exception | Error ex) {
164 // Nasty. If we've already reported an error, compensate
165 // for buggy compiler error recovery by swallowing thrown
166 // exceptions.
167 if (compiler == null || compiler.errorCount() == 0
168 || Options.instance(context).isSet("dev")) {
169 Log log = Log.instance(context);
170 log.printLines(PrefixKind.JAVAC, "msg.bug", JavaCompiler.version());
171 ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
172 }
173 return abnormalErrorResult;
174 }
175 }
176
177 private void prepareCompiler(boolean forParse) {
178 if (used.getAndSet(true)) {
179 if (compiler == null)
180 throw new PropagatedException(new IllegalStateException());
181 } else {
182 args.validate();
183
184 //initialize compiler's default locale
185 context.put(Locale.class, locale);
186
187 // hack
188 JavacMessages messages = context.get(JavacMessages.messagesKey);
189 if (messages != null && !messages.getCurrentLocale().equals(locale))
190 messages.setCurrentLocale(locale);
191
192 initPlugins(args.getPluginOpts());
193 initDocLint(args.getDocLintOpts());
194
195 // init JavaCompiler and queues
196 compiler = JavaCompiler.instance(context);
197 compiler.keepComments = true;
198 compiler.genEndPos = true;
199 notYetEntered = new HashMap<>();
200 if (forParse) {
201 compiler.initProcessAnnotations(processors, args.getFileObjects(), args.getClassNames());
202 for (JavaFileObject file: args.getFileObjects())
203 notYetEntered.put(file, null);
204 genList = new ListBuffer<>();
205 }
206 }
207 }
208
209 <T> String toString(Iterable<T> items, String sep) {
210 String currSep = "";
211 StringBuilder sb = new StringBuilder();
212 for (T item: items) {
213 sb.append(currSep);
214 sb.append(item.toString());
215 currSep = sep;
216 }
217 return sb.toString();
218 }
219
220 void cleanup() {
221 if (compiler != null)
222 compiler.close();
223 if (fileManager instanceof BaseFileManager && ((BaseFileManager) fileManager).autoClose) {
224 try {
225 fileManager.close();
226 } catch (IOException ignore) {
227 }
228 }
229 compiler = null;
230 context = null;
231 notYetEntered = null;
232 }
233
234 @Override @DefinedBy(Api.COMPILER_TREE)
235 public Iterable<? extends CompilationUnitTree> parse() {
236 return handleExceptions(this::parseInternal, List.nil(), List.nil());
237 }
238
239 private Iterable<? extends CompilationUnitTree> parseInternal() {
240 try {
241 prepareCompiler(true);
242 List<JCCompilationUnit> units = compiler.parseFiles(args.getFileObjects());
243 for (JCCompilationUnit unit: units) {
244 JavaFileObject file = unit.getSourceFile();
245 if (notYetEntered.containsKey(file))
246 notYetEntered.put(file, unit);
247 }
248 return units;
249 }
250 finally {
251 parsed = true;
252 if (compiler != null && compiler.log != null)
253 compiler.log.flush();
254 }
255 }
256
257 private boolean parsed = false;
258
259 /**
260 * Translate all the abstract syntax trees to elements.
261 *
262 * @return a list of elements corresponding to the top level
263 * classes in the abstract syntax trees
264 */
265 public Iterable<? extends Element> enter() {
266 return enter(null);
267 }
268
269 /**
270 * Translate the given abstract syntax trees to elements.
271 *
272 * @param trees a list of abstract syntax trees.
273 * @return a list of elements corresponding to the top level
274 * classes in the abstract syntax trees
275 */
276 public Iterable<? extends Element> enter(Iterable<? extends CompilationUnitTree> trees)
277 {
278 if (trees == null && notYetEntered != null && notYetEntered.isEmpty())
279 return List.nil();
280
281 boolean wasInitialized = compiler != null;
282
283 prepareCompiler(true);
284
285 ListBuffer<JCCompilationUnit> roots = null;
286
287 if (trees == null) {
288 // If there are still files which were specified to be compiled
289 // (i.e. in fileObjects) but which have not yet been entered,
290 // then we make sure they have been parsed and add them to the
291 // list to be entered.
292 if (notYetEntered.size() > 0) {
293 if (!parsed)
294 parseInternal(); // TODO would be nice to specify files needed to be parsed
295 for (JavaFileObject file: args.getFileObjects()) {
296 JCCompilationUnit unit = notYetEntered.remove(file);
297 if (unit != null) {
298 if (roots == null)
299 roots = new ListBuffer<>();
300 roots.append(unit);
301 }
302 }
303 notYetEntered.clear();
304 }
305 }
306 else {
307 for (CompilationUnitTree cu : trees) {
308 if (cu instanceof JCCompilationUnit) {
309 if (roots == null)
310 roots = new ListBuffer<>();
311 roots.append((JCCompilationUnit)cu);
312 notYetEntered.remove(cu.getSourceFile());
313 }
314 else
315 throw new IllegalArgumentException(cu.toString());
316 }
317 }
318
319 if (roots == null) {
320 if (trees == null && !wasInitialized) {
321 compiler.initModules(List.nil());
322 }
323 return List.nil();
324 }
325
326 List<JCCompilationUnit> units = compiler.initModules(roots.toList());
327
328 try {
329 units = compiler.enterTrees(units);
330
331 if (notYetEntered.isEmpty())
332 compiler.processAnnotations(units);
333
334 ListBuffer<Element> elements = new ListBuffer<>();
335 for (JCCompilationUnit unit : units) {
336 boolean isPkgInfo = unit.sourcefile.isNameCompatible("package-info",
337 JavaFileObject.Kind.SOURCE);
338 if (isPkgInfo) {
339 elements.append(unit.packge);
340 } else {
341 for (JCTree node : unit.defs) {
342 if (node.hasTag(JCTree.Tag.CLASSDEF)) {
343 JCClassDecl cdef = (JCClassDecl) node;
344 if (cdef.sym != null) // maybe null if errors in anno processing
345 elements.append(cdef.sym);
346 } else if (node.hasTag(JCTree.Tag.MODULEDEF)) {
347 JCModuleDecl mdef = (JCModuleDecl) node;
348 if (mdef.sym != null)
349 elements.append(mdef.sym);
350 }
351 }
352 }
353 }
354 return elements.toList();
355 }
356 finally {
357 compiler.log.flush();
358 }
359 }
360
361 @Override @DefinedBy(Api.COMPILER_TREE)
362 public Iterable<? extends Element> analyze() {
363 return handleExceptions(() -> analyze(null), List.nil(), List.nil());
364 }
365
366 /**
367 * Complete all analysis on the given classes.
368 * This can be used to ensure that all compile time errors are reported.
369 * The classes must have previously been returned from {@link #enter}.
370 * If null is specified, all outstanding classes will be analyzed.
371 *
372 * @param classes a list of class elements
373 * @return the elements that were analyzed
374 */
375 // This implementation requires that we open up privileges on JavaCompiler.
376 // An alternative implementation would be to move this code to JavaCompiler and
377 // wrap it here
378 public Iterable<? extends Element> analyze(Iterable<? extends Element> classes) {
379 enter(null); // ensure all classes have been entered
380
381 final ListBuffer<Element> results = new ListBuffer<>();
382 try {
383 if (classes == null) {
384 handleFlowResults(compiler.flow(compiler.attribute(compiler.todo)), results);
385 } else {
386 Filter f = new Filter() {
387 @Override
388 public void process(Env<AttrContext> env) {
389 handleFlowResults(compiler.flow(compiler.attribute(env)), results);
390 }
391 };
392 f.run(compiler.todo, classes);
393 }
394 } finally {
395 compiler.log.flush();
396 }
397 return results;
398 }
399 // where
400 private void handleFlowResults(Queue<Env<AttrContext>> queue, ListBuffer<Element> elems) {
401 for (Env<AttrContext> env: queue) {
402 switch (env.tree.getTag()) {
403 case CLASSDEF:
404 JCClassDecl cdef = (JCClassDecl) env.tree;
405 if (cdef.sym != null)
406 elems.append(cdef.sym);
407 break;
408 case MODULEDEF:
409 JCModuleDecl mod = (JCModuleDecl) env.tree;
410 if (mod.sym != null)
411 elems.append(mod.sym);
412 break;
413 case PACKAGEDEF:
414 JCCompilationUnit unit = env.toplevel;
415 if (unit.packge != null)
416 elems.append(unit.packge);
417 break;
418 }
419 }
420 genList.addAll(queue);
421 }
422
423 @Override @DefinedBy(Api.COMPILER_TREE)
424 public Iterable<? extends JavaFileObject> generate() {
425 return handleExceptions(() -> generate(null), List.nil(), List.nil());
426 }
427
428 /**
429 * Generate code corresponding to the given classes.
430 * The classes must have previously been returned from {@link #enter}.
431 * If there are classes outstanding to be analyzed, that will be done before
432 * any classes are generated.
433 * If null is specified, code will be generated for all outstanding classes.
434 *
435 * @param classes a list of class elements
436 * @return the files that were generated
437 */
438 public Iterable<? extends JavaFileObject> generate(Iterable<? extends Element> classes) {
439 final ListBuffer<JavaFileObject> results = new ListBuffer<>();
440 try {
441 analyze(null); // ensure all classes have been parsed, entered, and analyzed
442
443 if (classes == null) {
444 compiler.generate(compiler.desugar(genList), results);
445 genList.clear();
446 }
447 else {
448 Filter f = new Filter() {
449 @Override
450 public void process(Env<AttrContext> env) {
451 compiler.generate(compiler.desugar(ListBuffer.of(env)), results);
452 }
453 };
454 f.run(genList, classes);
455 }
456 if (genList.isEmpty()) {
457 compiler.reportDeferredDiagnostics();
458 cleanup();
459 }
460 }
461 finally {
462 if (compiler != null)
463 compiler.log.flush();
464 }
465 return results;
466 }
467
468 public Iterable<? extends Tree> pathFor(CompilationUnitTree unit, Tree node) {
469 return TreeInfo.pathFor((JCTree) node, (JCTree.JCCompilationUnit) unit).reverse();
470 }
471
472 public void ensureEntered() {
473 args.allowEmpty();
474 enter(null);
475 }
476
477 abstract class Filter {
478 void run(Queue<Env<AttrContext>> list, Iterable<? extends Element> elements) {
479 Set<Element> set = new HashSet<>();
480 for (Element item: elements) {
481 set.add(item);
482 }
483
484 ListBuffer<Env<AttrContext>> defer = new ListBuffer<>();
485 while (list.peek() != null) {
486 Env<AttrContext> env = list.remove();
487 Symbol test = null;
488
489 if (env.tree.hasTag(Tag.MODULEDEF)) {
490 test = ((JCModuleDecl) env.tree).sym;
491 } else if (env.tree.hasTag(Tag.PACKAGEDEF)) {
492 test = env.toplevel.packge;
493 } else {
494 ClassSymbol csym = env.enclClass.sym;
495 if (csym != null)
496 test = csym.outermostClass();
497 }
498 if (test != null && set.contains(test))
499 process(env);
500 else
501 defer = defer.append(env);
502 }
503
504 list.addAll(defer);
505 }
506
507 abstract void process(Env<AttrContext> env);
508 }
509
510 /**
511 * For internal use only. This method will be
512 * removed without warning.
513 * @param expr the type expression to be analyzed
514 * @param scope the scope in which to analyze the type expression
515 * @return the type
516 * @throws IllegalArgumentException if the type expression of null or empty
517 */
518 public Type parseType(String expr, TypeElement scope) {
519 if (expr == null || expr.equals(""))
520 throw new IllegalArgumentException();
521 compiler = JavaCompiler.instance(context);
522 JavaFileObject prev = compiler.log.useSource(null);
523 ParserFactory parserFactory = ParserFactory.instance(context);
524 Attr attr = Attr.instance(context);
525 try {
526 CharBuffer buf = CharBuffer.wrap((expr+"\u0000").toCharArray(), 0, expr.length());
527 Parser parser = parserFactory.newParser(buf, false, false, false);
528 JCTree tree = parser.parseType();
529 return attr.attribType(tree, (Symbol.TypeSymbol)scope);
530 } finally {
531 compiler.log.useSource(prev);
532 }
533 }
534
535 }