duke@1: /*
jjg@1210:  * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
duke@1:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@1:  *
duke@1:  * This code is free software; you can redistribute it and/or modify it
duke@1:  * under the terms of the GNU General Public License version 2 only, as
ohair@554:  * published by the Free Software Foundation.  Oracle designates this
duke@1:  * particular file as subject to the "Classpath" exception as provided
ohair@554:  * by Oracle in the LICENSE file that accompanied this code.
duke@1:  *
duke@1:  * This code is distributed in the hope that it will be useful, but WITHOUT
duke@1:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@1:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
duke@1:  * version 2 for more details (a copy is included in the LICENSE file that
duke@1:  * accompanied this code).
duke@1:  *
duke@1:  * You should have received a copy of the GNU General Public License version
duke@1:  * 2 along with this work; if not, write to the Free Software Foundation,
duke@1:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@1:  *
ohair@554:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
ohair@554:  * or visit www.oracle.com if you need additional information or have any
ohair@554:  * questions.
duke@1:  */
duke@1: 
duke@1: package com.sun.tools.javac.api;
duke@1: 
duke@1: import java.io.File;
duke@1: import java.io.IOException;
jjg@111: import java.nio.CharBuffer;
duke@1: import java.util.*;
duke@1: import java.util.concurrent.atomic.AtomicBoolean;
duke@1: 
duke@1: import javax.annotation.processing.Processor;
duke@1: import javax.lang.model.element.Element;
duke@1: import javax.lang.model.element.TypeElement;
duke@1: import javax.lang.model.type.TypeMirror;
duke@1: import javax.tools.*;
duke@1: 
duke@1: import com.sun.source.tree.*;
duke@1: import com.sun.source.util.*;
duke@1: import com.sun.tools.javac.code.*;
duke@1: import com.sun.tools.javac.code.Symbol.*;
duke@1: import com.sun.tools.javac.comp.*;
jjg@50: import com.sun.tools.javac.file.JavacFileManager;
duke@1: import com.sun.tools.javac.main.*;
jjg@1210: import com.sun.tools.javac.main.JavaCompiler;
duke@1: import com.sun.tools.javac.model.*;
duke@1: import com.sun.tools.javac.parser.Parser;
jjg@111: import com.sun.tools.javac.parser.ParserFactory;
duke@1: import com.sun.tools.javac.tree.*;
duke@1: import com.sun.tools.javac.tree.JCTree.*;
duke@1: import com.sun.tools.javac.util.*;
duke@1: import com.sun.tools.javac.util.List;
duke@1: 
duke@1: /**
jjg@582:  * Provides access to functionality specific to the JDK Java Compiler, javac.
duke@1:  *
jjg@581:  * <p><b>This is NOT part of any supported API.
duke@1:  * If you write code that depends on this, you do so at your own
duke@1:  * risk.  This code and its internal interfaces are subject to change
duke@1:  * or deletion without notice.</b></p>
duke@1:  *
duke@1:  * @author Peter von der Ah&eacute;
duke@1:  * @author Jonathan Gibbons
duke@1:  */
jjg@1210: public class JavacTaskImpl extends BasicJavacTask {
duke@1:     private Main compilerMain;
duke@1:     private JavaCompiler compiler;
mcimadamore@136:     private Locale locale;
duke@1:     private String[] args;
jjh@1187:     private String[] classNames;
duke@1:     private List<JavaFileObject> fileObjects;
duke@1:     private Map<JavaFileObject, JCCompilationUnit> notYetEntered;
duke@1:     private ListBuffer<Env<AttrContext>> genList;
jjg@1413:     private final AtomicBoolean used = new AtomicBoolean();
duke@1:     private Iterable<? extends Processor> processors;
duke@1: 
jjg@1097:     private Main.Result result = null;
duke@1: 
jjg@946:     JavacTaskImpl(Main compilerMain,
duke@1:                 String[] args,
jjh@1187:                 String[] classNames,
duke@1:                 Context context,
duke@1:                 List<JavaFileObject> fileObjects) {
jjg@1210:         super(null, false);
duke@1:         this.compilerMain = compilerMain;
duke@1:         this.args = args;
jjh@1187:         this.classNames = classNames;
duke@1:         this.context = context;
duke@1:         this.fileObjects = fileObjects;
mcimadamore@136:         setLocale(Locale.getDefault());
duke@1:         // null checks
duke@1:         compilerMain.getClass();
duke@1:         args.getClass();
duke@1:         fileObjects.getClass();
duke@1:     }
duke@1: 
jjg@946:     JavacTaskImpl(Main compilerMain,
jjg@1413:                 Iterable<String> args,
duke@1:                 Context context,
duke@1:                 Iterable<String> classes,
duke@1:                 Iterable<? extends JavaFileObject> fileObjects) {
jjg@1413:         this(compilerMain, toArray(args), toArray(classes), context, toList(fileObjects));
duke@1:     }
duke@1: 
jjh@1187:     static private String[] toArray(Iterable<String> iter) {
duke@1:         ListBuffer<String> result = new ListBuffer<String>();
jjh@1187:         if (iter != null)
jjh@1187:             for (String s : iter)
jjh@1187:                 result.append(s);
duke@1:         return result.toArray(new String[result.length()]);
duke@1:     }
duke@1: 
duke@1:     static private List<JavaFileObject> toList(Iterable<? extends JavaFileObject> fileObjects) {
duke@1:         if (fileObjects == null)
duke@1:             return List.nil();
duke@1:         ListBuffer<JavaFileObject> result = new ListBuffer<JavaFileObject>();
duke@1:         for (JavaFileObject fo : fileObjects)
duke@1:             result.append(fo);
duke@1:         return result.toList();
duke@1:     }
duke@1: 
duke@1:     public Boolean call() {
duke@1:         if (!used.getAndSet(true)) {
jjg@930:             initContext();
jjg@308:             notYetEntered = new HashMap<JavaFileObject, JCCompilationUnit>();
jjg@946:             compilerMain.setAPIMode(true);
jjh@1187:             result = compilerMain.compile(args, classNames, context, fileObjects, processors);
jjg@930:             cleanup();
jjg@1097:             return result.isOK();
duke@1:         } else {
duke@1:             throw new IllegalStateException("multiple calls to method 'call'");
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     public void setProcessors(Iterable<? extends Processor> processors) {
duke@1:         processors.getClass(); // null check
duke@1:         // not mt-safe
duke@1:         if (used.get())
duke@1:             throw new IllegalStateException();
duke@1:         this.processors = processors;
duke@1:     }
duke@1: 
duke@1:     public void setLocale(Locale locale) {
duke@1:         if (used.get())
duke@1:             throw new IllegalStateException();
mcimadamore@136:         this.locale = locale;
duke@1:     }
duke@1: 
duke@1:     private void prepareCompiler() throws IOException {
jjg@930:         if (used.getAndSet(true)) {
jjg@930:             if (compiler == null)
jjg@930:                 throw new IllegalStateException();
jjg@930:         } else {
jjg@930:             initContext();
jjg@1569:             compilerMain.log = Log.instance(context);
duke@1:             compilerMain.setOptions(Options.instance(context));
jjg@1055:             compilerMain.filenames = new LinkedHashSet<File>();
jjh@1187:             Collection<File> filenames = compilerMain.processArgs(CommandLine.parse(args), classNames);
jjg@1569:             if (filenames != null && !filenames.isEmpty())
jjg@1055:                 throw new IllegalArgumentException("Malformed arguments " + toString(filenames, " "));
duke@1:             compiler = JavaCompiler.instance(context);
duke@1:             compiler.keepComments = true;
duke@1:             compiler.genEndPos = true;
duke@1:             // NOTE: this value will be updated after annotation processing
duke@1:             compiler.initProcessAnnotations(processors);
duke@1:             notYetEntered = new HashMap<JavaFileObject, JCCompilationUnit>();
duke@1:             for (JavaFileObject file: fileObjects)
duke@1:                 notYetEntered.put(file, null);
duke@1:             genList = new ListBuffer<Env<AttrContext>>();
duke@1:             // endContext will be called when all classes have been generated
duke@1:             // TODO: should handle the case after each phase if errors have occurred
duke@1:             args = null;
jjh@1187:             classNames = null;
duke@1:         }
duke@1:     }
duke@1: 
jjg@1055:     <T> String toString(Iterable<T> items, String sep) {
jjg@1055:         String currSep = "";
jjg@1055:         StringBuilder sb = new StringBuilder();
jjg@1055:         for (T item: items) {
jjg@1055:             sb.append(currSep);
jjg@1055:             sb.append(item.toString());
jjg@1055:             currSep = sep;
jjg@1055:         }
jjg@1055:         return sb.toString();
jjg@1055:     }
jjg@1055: 
jjg@930:     private void initContext() {
jjg@1210:         context.put(JavacTask.class, this);
mcimadamore@136:         //initialize compiler's default locale
jjg@944:         context.put(Locale.class, locale);
duke@1:     }
duke@1: 
jjg@930:     void cleanup() {
jjg@930:         if (compiler != null)
jjg@930:             compiler.close();
jjg@930:         compiler = null;
jjg@930:         compilerMain = null;
jjg@930:         args = null;
jjh@1187:         classNames = null;
jjg@930:         context = null;
jjg@930:         fileObjects = null;
jjg@930:         notYetEntered = null;
duke@1:     }
duke@1: 
duke@1:     /**
duke@1:      * Construct a JavaFileObject from the given file.
duke@1:      *
duke@1:      * <p><b>TODO: this method is useless here</b></p>
duke@1:      *
duke@1:      * @param file a file
duke@1:      * @return a JavaFileObject from the standard file manager.
duke@1:      */
duke@1:     public JavaFileObject asJavaFileObject(File file) {
duke@1:         JavacFileManager fm = (JavacFileManager)context.get(JavaFileManager.class);
duke@1:         return fm.getRegularFile(file);
duke@1:     }
duke@1: 
duke@1:     /**
duke@1:      * Parse the specified files returning a list of abstract syntax trees.
duke@1:      *
duke@1:      * @throws java.io.IOException TODO
duke@1:      * @return a list of abstract syntax trees
duke@1:      */
duke@1:     public Iterable<? extends CompilationUnitTree> parse() throws IOException {
duke@1:         try {
duke@1:             prepareCompiler();
duke@1:             List<JCCompilationUnit> units = compiler.parseFiles(fileObjects);
duke@1:             for (JCCompilationUnit unit: units) {
duke@1:                 JavaFileObject file = unit.getSourceFile();
duke@1:                 if (notYetEntered.containsKey(file))
duke@1:                     notYetEntered.put(file, unit);
duke@1:             }
duke@1:             return units;
duke@1:         }
duke@1:         finally {
duke@1:             parsed = true;
duke@1:             if (compiler != null && compiler.log != null)
duke@1:                 compiler.log.flush();
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     private boolean parsed = false;
duke@1: 
duke@1:     /**
duke@1:      * Translate all the abstract syntax trees to elements.
duke@1:      *
duke@1:      * @throws IOException TODO
duke@1:      * @return a list of elements corresponding to the top level
duke@1:      * classes in the abstract syntax trees
duke@1:      */
duke@1:     public Iterable<? extends TypeElement> enter() throws IOException {
duke@1:         return enter(null);
duke@1:     }
duke@1: 
duke@1:     /**
duke@1:      * Translate the given abstract syntax trees to elements.
duke@1:      *
duke@1:      * @param trees a list of abstract syntax trees.
duke@1:      * @throws java.io.IOException TODO
duke@1:      * @return a list of elements corresponding to the top level
duke@1:      * classes in the abstract syntax trees
duke@1:      */
duke@1:     public Iterable<? extends TypeElement> enter(Iterable<? extends CompilationUnitTree> trees)
duke@1:         throws IOException
duke@1:     {
jjg@1090:         if (trees == null && notYetEntered != null && notYetEntered.isEmpty())
jjg@1090:             return List.nil();
jjg@1090: 
duke@1:         prepareCompiler();
duke@1: 
duke@1:         ListBuffer<JCCompilationUnit> roots = null;
duke@1: 
duke@1:         if (trees == null) {
duke@1:             // If there are still files which were specified to be compiled
duke@1:             // (i.e. in fileObjects) but which have not yet been entered,
duke@1:             // then we make sure they have been parsed and add them to the
duke@1:             // list to be entered.
duke@1:             if (notYetEntered.size() > 0) {
duke@1:                 if (!parsed)
duke@1:                     parse(); // TODO would be nice to specify files needed to be parsed
duke@1:                 for (JavaFileObject file: fileObjects) {
duke@1:                     JCCompilationUnit unit = notYetEntered.remove(file);
duke@1:                     if (unit != null) {
duke@1:                         if (roots == null)
duke@1:                             roots = new ListBuffer<JCCompilationUnit>();
duke@1:                         roots.append(unit);
duke@1:                     }
duke@1:                 }
duke@1:                 notYetEntered.clear();
duke@1:             }
duke@1:         }
duke@1:         else {
duke@1:             for (CompilationUnitTree cu : trees) {
duke@1:                 if (cu instanceof JCCompilationUnit) {
duke@1:                     if (roots == null)
duke@1:                         roots = new ListBuffer<JCCompilationUnit>();
duke@1:                     roots.append((JCCompilationUnit)cu);
duke@1:                     notYetEntered.remove(cu.getSourceFile());
duke@1:                 }
duke@1:                 else
duke@1:                     throw new IllegalArgumentException(cu.toString());
duke@1:             }
duke@1:         }
duke@1: 
duke@1:         if (roots == null)
duke@1:             return List.nil();
duke@1: 
duke@1:         try {
duke@1:             List<JCCompilationUnit> units = compiler.enterTrees(roots.toList());
duke@1: 
duke@1:             if (notYetEntered.isEmpty())
duke@1:                 compiler = compiler.processAnnotations(units);
duke@1: 
duke@1:             ListBuffer<TypeElement> elements = new ListBuffer<TypeElement>();
duke@1:             for (JCCompilationUnit unit : units) {
jjg@695:                 for (JCTree node : unit.defs) {
jjg@1127:                     if (node.hasTag(JCTree.Tag.CLASSDEF)) {
jjg@695:                         JCClassDecl cdef = (JCClassDecl) node;
jjg@695:                         if (cdef.sym != null) // maybe null if errors in anno processing
jjg@695:                             elements.append(cdef.sym);
jjg@695:                     }
jjg@695:                 }
duke@1:             }
duke@1:             return elements.toList();
duke@1:         }
duke@1:         finally {
duke@1:             compiler.log.flush();
duke@1:         }
duke@1:     }
duke@1: 
duke@1:     /**
duke@1:      * Complete all analysis.
duke@1:      * @throws IOException TODO
duke@1:      */
duke@1:     @Override
duke@1:     public Iterable<? extends Element> analyze() throws IOException {
duke@1:         return analyze(null);
duke@1:     }
duke@1: 
duke@1:     /**
duke@1:      * Complete all analysis on the given classes.
duke@1:      * This can be used to ensure that all compile time errors are reported.
duke@1:      * The classes must have previously been returned from {@link #enter}.
duke@1:      * If null is specified, all outstanding classes will be analyzed.
duke@1:      *
duke@1:      * @param classes a list of class elements
duke@1:      */
duke@1:     // This implementation requires that we open up privileges on JavaCompiler.
duke@1:     // An alternative implementation would be to move this code to JavaCompiler and
duke@1:     // wrap it here
duke@1:     public Iterable<? extends Element> analyze(Iterable<? extends TypeElement> classes) throws IOException {
duke@1:         enter(null);  // ensure all classes have been entered
duke@1: 
duke@1:         final ListBuffer<Element> results = new ListBuffer<Element>();
duke@1:         try {
duke@1:             if (classes == null) {
duke@1:                 handleFlowResults(compiler.flow(compiler.attribute(compiler.todo)), results);
duke@1:             } else {
duke@1:                 Filter f = new Filter() {
duke@1:                     public void process(Env<AttrContext> env) {
duke@1:                         handleFlowResults(compiler.flow(compiler.attribute(env)), results);
duke@1:                     }
duke@1:                 };
duke@1:                 f.run(compiler.todo, classes);
duke@1:             }
duke@1:         } finally {
duke@1:             compiler.log.flush();
duke@1:         }
duke@1:         return results;
duke@1:     }
duke@1:     // where
jjg@70:         private void handleFlowResults(Queue<Env<AttrContext>> queue, ListBuffer<Element> elems) {
jjg@70:             for (Env<AttrContext> env: queue) {
duke@1:                 switch (env.tree.getTag()) {
jjg@1127:                     case CLASSDEF:
duke@1:                         JCClassDecl cdef = (JCClassDecl) env.tree;
duke@1:                         if (cdef.sym != null)
duke@1:                             elems.append(cdef.sym);
duke@1:                         break;
jjg@1127:                     case TOPLEVEL:
duke@1:                         JCCompilationUnit unit = (JCCompilationUnit) env.tree;
duke@1:                         if (unit.packge != null)
duke@1:                             elems.append(unit.packge);
duke@1:                         break;
duke@1:                 }
duke@1:             }
jjg@70:             genList.addAll(queue);
duke@1:         }
duke@1: 
duke@1: 
duke@1:     /**
duke@1:      * Generate code.
duke@1:      * @throws IOException TODO
duke@1:      */
duke@1:     @Override
duke@1:     public Iterable<? extends JavaFileObject> generate() throws IOException {
duke@1:         return generate(null);
duke@1:     }
duke@1: 
duke@1:     /**
duke@1:      * Generate code corresponding to the given classes.
duke@1:      * The classes must have previously been returned from {@link #enter}.
duke@1:      * If there are classes outstanding to be analyzed, that will be done before
duke@1:      * any classes are generated.
duke@1:      * If null is specified, code will be generated for all outstanding classes.
duke@1:      *
duke@1:      * @param classes a list of class elements
duke@1:      */
duke@1:     public Iterable<? extends JavaFileObject> generate(Iterable<? extends TypeElement> classes) throws IOException {
duke@1:         final ListBuffer<JavaFileObject> results = new ListBuffer<JavaFileObject>();
duke@1:         try {
duke@1:             analyze(null);  // ensure all classes have been parsed, entered, and analyzed
duke@1: 
duke@1:             if (classes == null) {
jjg@70:                 compiler.generate(compiler.desugar(genList), results);
duke@1:                 genList.clear();
duke@1:             }
duke@1:             else {
duke@1:                 Filter f = new Filter() {
duke@1:                         public void process(Env<AttrContext> env) {
jjg@70:                             compiler.generate(compiler.desugar(ListBuffer.of(env)), results);
duke@1:                         }
duke@1:                     };
duke@1:                 f.run(genList, classes);
duke@1:             }
duke@1:             if (genList.isEmpty()) {
duke@1:                 compiler.reportDeferredDiagnostics();
jjg@930:                 cleanup();
duke@1:             }
duke@1:         }
duke@1:         finally {
jjg@930:             if (compiler != null)
jjg@930:                 compiler.log.flush();
duke@1:         }
duke@1:         return results;
duke@1:     }
duke@1: 
duke@1:     public TypeMirror getTypeMirror(Iterable<? extends Tree> path) {
duke@1:         // TODO: Should complete attribution if necessary
duke@1:         Tree last = null;
duke@1:         for (Tree node : path)
duke@1:             last = node;
duke@1:         return ((JCTree)last).type;
duke@1:     }
duke@1: 
duke@1:     public JavacElements getElements() {
duke@1:         if (context == null)
duke@1:             throw new IllegalStateException();
duke@1:         return JavacElements.instance(context);
duke@1:     }
duke@1: 
duke@1:     public JavacTypes getTypes() {
duke@1:         if (context == null)
duke@1:             throw new IllegalStateException();
duke@1:         return JavacTypes.instance(context);
duke@1:     }
duke@1: 
duke@1:     public Iterable<? extends Tree> pathFor(CompilationUnitTree unit, Tree node) {
duke@1:         return TreeInfo.pathFor((JCTree) node, (JCTree.JCCompilationUnit) unit).reverse();
duke@1:     }
duke@1: 
duke@1:     abstract class Filter {
jjg@119:         void run(Queue<Env<AttrContext>> list, Iterable<? extends TypeElement> classes) {
duke@1:             Set<TypeElement> set = new HashSet<TypeElement>();
duke@1:             for (TypeElement item: classes)
duke@1:                 set.add(item);
duke@1: 
jjg@119:             ListBuffer<Env<AttrContext>> defer = ListBuffer.<Env<AttrContext>>lb();
jjg@119:             while (list.peek() != null) {
jjg@119:                 Env<AttrContext> env = list.remove();
duke@1:                 ClassSymbol csym = env.enclClass.sym;
duke@1:                 if (csym != null && set.contains(csym.outermostClass()))
duke@1:                     process(env);
duke@1:                 else
jjg@119:                     defer = defer.append(env);
duke@1:             }
duke@1: 
jjg@119:             list.addAll(defer);
duke@1:         }
duke@1: 
duke@1:         abstract void process(Env<AttrContext> env);
duke@1:     }
duke@1: 
duke@1:     /**
jjg@581:      * For internal use only.  This method will be
duke@1:      * removed without warning.
duke@1:      */
duke@1:     public Type parseType(String expr, TypeElement scope) {
duke@1:         if (expr == null || expr.equals(""))
duke@1:             throw new IllegalArgumentException();
duke@1:         compiler = JavaCompiler.instance(context);
duke@1:         JavaFileObject prev = compiler.log.useSource(null);
jjg@111:         ParserFactory parserFactory = ParserFactory.instance(context);
duke@1:         Attr attr = Attr.instance(context);
duke@1:         try {
jjg@111:             CharBuffer buf = CharBuffer.wrap((expr+"\u0000").toCharArray(), 0, expr.length());
jjg@111:             Parser parser = parserFactory.newParser(buf, false, false, false);
jjg@111:             JCTree tree = parser.parseType();
duke@1:             return attr.attribType(tree, (Symbol.TypeSymbol)scope);
duke@1:         } finally {
duke@1:             compiler.log.useSource(prev);
duke@1:         }
duke@1:     }
duke@1: 
duke@1: }