Wed, 20 Jun 2012 13:23:26 -0700
7174143: encapsulate doc comment table
Reviewed-by: ksrini, mcimadamore
1 /*
2 * Copyright (c) 2005, 2012, 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 */
26 package com.sun.tools.javac.processing;
28 import java.io.Closeable;
29 import java.io.File;
30 import java.io.PrintWriter;
31 import java.io.StringWriter;
32 import java.net.MalformedURLException;
33 import java.net.URL;
34 import java.util.*;
35 import java.util.regex.*;
37 import javax.annotation.processing.*;
38 import javax.lang.model.SourceVersion;
39 import javax.lang.model.element.AnnotationMirror;
40 import javax.lang.model.element.Element;
41 import javax.lang.model.element.PackageElement;
42 import javax.lang.model.element.TypeElement;
43 import javax.lang.model.util.*;
44 import javax.tools.DiagnosticListener;
45 import javax.tools.JavaFileManager;
46 import javax.tools.JavaFileObject;
47 import javax.tools.StandardJavaFileManager;
48 import static javax.tools.StandardLocation.*;
50 import com.sun.source.util.JavacTask;
51 import com.sun.source.util.TaskEvent;
52 import com.sun.tools.javac.api.JavacTaskImpl;
53 import com.sun.tools.javac.api.JavacTrees;
54 import com.sun.tools.javac.api.MultiTaskListener;
55 import com.sun.tools.javac.code.*;
56 import com.sun.tools.javac.code.Symbol.*;
57 import com.sun.tools.javac.file.FSInfo;
58 import com.sun.tools.javac.file.JavacFileManager;
59 import com.sun.tools.javac.jvm.*;
60 import com.sun.tools.javac.jvm.ClassReader.BadClassFile;
61 import com.sun.tools.javac.main.JavaCompiler;
62 import com.sun.tools.javac.main.JavaCompiler.CompileState;
63 import com.sun.tools.javac.model.JavacElements;
64 import com.sun.tools.javac.model.JavacTypes;
65 import com.sun.tools.javac.parser.*;
66 import com.sun.tools.javac.tree.*;
67 import com.sun.tools.javac.tree.JCTree.*;
68 import com.sun.tools.javac.util.Abort;
69 import com.sun.tools.javac.util.Assert;
70 import com.sun.tools.javac.util.ClientCodeException;
71 import com.sun.tools.javac.util.Context;
72 import com.sun.tools.javac.util.Convert;
73 import com.sun.tools.javac.util.JCDiagnostic;
74 import com.sun.tools.javac.util.JavacMessages;
75 import com.sun.tools.javac.util.List;
76 import com.sun.tools.javac.util.Log;
77 import com.sun.tools.javac.util.Name;
78 import com.sun.tools.javac.util.Names;
79 import com.sun.tools.javac.util.Options;
80 import static com.sun.tools.javac.code.Lint.LintCategory.PROCESSING;
81 import static com.sun.tools.javac.main.Option.*;
82 import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*;
84 /**
85 * Objects of this class hold and manage the state needed to support
86 * annotation processing.
87 *
88 * <p><b>This is NOT part of any supported API.
89 * If you write code that depends on this, you do so at your own risk.
90 * This code and its internal interfaces are subject to change or
91 * deletion without notice.</b>
92 */
93 public class JavacProcessingEnvironment implements ProcessingEnvironment, Closeable {
94 Options options;
96 private final boolean printProcessorInfo;
97 private final boolean printRounds;
98 private final boolean verbose;
99 private final boolean lint;
100 private final boolean procOnly;
101 private final boolean fatalErrors;
102 private final boolean werror;
103 private final boolean showResolveErrors;
104 private boolean foundTypeProcessors;
106 private final JavacFiler filer;
107 private final JavacMessager messager;
108 private final JavacElements elementUtils;
109 private final JavacTypes typeUtils;
111 /**
112 * Holds relevant state history of which processors have been
113 * used.
114 */
115 private DiscoveredProcessors discoveredProcs;
117 /**
118 * Map of processor-specific options.
119 */
120 private final Map<String, String> processorOptions;
122 /**
123 */
124 private final Set<String> unmatchedProcessorOptions;
126 /**
127 * Annotations implicitly processed and claimed by javac.
128 */
129 private final Set<String> platformAnnotations;
131 /**
132 * Set of packages given on command line.
133 */
134 private Set<PackageSymbol> specifiedPackages = Collections.emptySet();
136 /** The log to be used for error reporting.
137 */
138 Log log;
140 /** Diagnostic factory.
141 */
142 JCDiagnostic.Factory diags;
144 /**
145 * Source level of the compile.
146 */
147 Source source;
149 private ClassLoader processorClassLoader;
151 /**
152 * JavacMessages object used for localization
153 */
154 private JavacMessages messages;
156 private MultiTaskListener taskListener;
158 private Context context;
160 public JavacProcessingEnvironment(Context context, Iterable<? extends Processor> processors) {
161 this.context = context;
162 log = Log.instance(context);
163 source = Source.instance(context);
164 diags = JCDiagnostic.Factory.instance(context);
165 options = Options.instance(context);
166 printProcessorInfo = options.isSet(XPRINTPROCESSORINFO);
167 printRounds = options.isSet(XPRINTROUNDS);
168 verbose = options.isSet(VERBOSE);
169 lint = Lint.instance(context).isEnabled(PROCESSING);
170 procOnly = options.isSet(PROC, "only") || options.isSet(XPRINT);
171 fatalErrors = options.isSet("fatalEnterError");
172 showResolveErrors = options.isSet("showResolveErrors");
173 werror = options.isSet(WERROR);
174 platformAnnotations = initPlatformAnnotations();
175 foundTypeProcessors = false;
177 // Initialize services before any processors are initialized
178 // in case processors use them.
179 filer = new JavacFiler(context);
180 messager = new JavacMessager(context, this);
181 elementUtils = JavacElements.instance(context);
182 typeUtils = JavacTypes.instance(context);
183 processorOptions = initProcessorOptions(context);
184 unmatchedProcessorOptions = initUnmatchedProcessorOptions();
185 messages = JavacMessages.instance(context);
186 taskListener = MultiTaskListener.instance(context);
187 initProcessorIterator(context, processors);
188 }
190 private Set<String> initPlatformAnnotations() {
191 Set<String> platformAnnotations = new HashSet<String>();
192 platformAnnotations.add("java.lang.Deprecated");
193 platformAnnotations.add("java.lang.Override");
194 platformAnnotations.add("java.lang.SuppressWarnings");
195 platformAnnotations.add("java.lang.annotation.Documented");
196 platformAnnotations.add("java.lang.annotation.Inherited");
197 platformAnnotations.add("java.lang.annotation.Retention");
198 platformAnnotations.add("java.lang.annotation.Target");
199 return Collections.unmodifiableSet(platformAnnotations);
200 }
202 private void initProcessorIterator(Context context, Iterable<? extends Processor> processors) {
203 Log log = Log.instance(context);
204 Iterator<? extends Processor> processorIterator;
206 if (options.isSet(XPRINT)) {
207 try {
208 Processor processor = PrintingProcessor.class.newInstance();
209 processorIterator = List.of(processor).iterator();
210 } catch (Throwable t) {
211 AssertionError assertError =
212 new AssertionError("Problem instantiating PrintingProcessor.");
213 assertError.initCause(t);
214 throw assertError;
215 }
216 } else if (processors != null) {
217 processorIterator = processors.iterator();
218 } else {
219 String processorNames = options.get(PROCESSOR);
220 JavaFileManager fileManager = context.get(JavaFileManager.class);
221 try {
222 // If processorpath is not explicitly set, use the classpath.
223 processorClassLoader = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
224 ? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH)
225 : fileManager.getClassLoader(CLASS_PATH);
227 if (processorClassLoader != null && processorClassLoader instanceof Closeable) {
228 JavaCompiler compiler = JavaCompiler.instance(context);
229 compiler.closeables = compiler.closeables.prepend((Closeable) processorClassLoader);
230 }
232 /*
233 * If the "-processor" option is used, search the appropriate
234 * path for the named class. Otherwise, use a service
235 * provider mechanism to create the processor iterator.
236 */
237 if (processorNames != null) {
238 processorIterator = new NameProcessIterator(processorNames, processorClassLoader, log);
239 } else {
240 processorIterator = new ServiceIterator(processorClassLoader, log);
241 }
242 } catch (SecurityException e) {
243 /*
244 * A security exception will occur if we can't create a classloader.
245 * Ignore the exception if, with hindsight, we didn't need it anyway
246 * (i.e. no processor was specified either explicitly, or implicitly,
247 * in service configuration file.) Otherwise, we cannot continue.
248 */
249 processorIterator = handleServiceLoaderUnavailability("proc.cant.create.loader", e);
250 }
251 }
252 discoveredProcs = new DiscoveredProcessors(processorIterator);
253 }
255 /**
256 * Returns an empty processor iterator if no processors are on the
257 * relevant path, otherwise if processors are present, logs an
258 * error. Called when a service loader is unavailable for some
259 * reason, either because a service loader class cannot be found
260 * or because a security policy prevents class loaders from being
261 * created.
262 *
263 * @param key The resource key to use to log an error message
264 * @param e If non-null, pass this exception to Abort
265 */
266 private Iterator<Processor> handleServiceLoaderUnavailability(String key, Exception e) {
267 JavaFileManager fileManager = context.get(JavaFileManager.class);
269 if (fileManager instanceof JavacFileManager) {
270 StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager;
271 Iterable<? extends File> workingPath = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
272 ? standardFileManager.getLocation(ANNOTATION_PROCESSOR_PATH)
273 : standardFileManager.getLocation(CLASS_PATH);
275 if (needClassLoader(options.get(PROCESSOR), workingPath) )
276 handleException(key, e);
278 } else {
279 handleException(key, e);
280 }
282 java.util.List<Processor> pl = Collections.emptyList();
283 return pl.iterator();
284 }
286 /**
287 * Handle a security exception thrown during initializing the
288 * Processor iterator.
289 */
290 private void handleException(String key, Exception e) {
291 if (e != null) {
292 log.error(key, e.getLocalizedMessage());
293 throw new Abort(e);
294 } else {
295 log.error(key);
296 throw new Abort();
297 }
298 }
300 /**
301 * Use a service loader appropriate for the platform to provide an
302 * iterator over annotations processors; fails if a loader is
303 * needed but unavailable.
304 */
305 private class ServiceIterator implements Iterator<Processor> {
306 private Iterator<Processor> iterator;
307 private Log log;
308 private ServiceLoader<Processor> loader;
310 ServiceIterator(ClassLoader classLoader, Log log) {
311 this.log = log;
312 try {
313 try {
314 loader = ServiceLoader.load(Processor.class, classLoader);
315 this.iterator = loader.iterator();
316 } catch (Exception e) {
317 // Fail softly if a loader is not actually needed.
318 this.iterator = handleServiceLoaderUnavailability("proc.no.service", null);
319 }
320 } catch (Throwable t) {
321 log.error("proc.service.problem");
322 throw new Abort(t);
323 }
324 }
326 public boolean hasNext() {
327 try {
328 return iterator.hasNext();
329 } catch(ServiceConfigurationError sce) {
330 log.error("proc.bad.config.file", sce.getLocalizedMessage());
331 throw new Abort(sce);
332 } catch (Throwable t) {
333 throw new Abort(t);
334 }
335 }
337 public Processor next() {
338 try {
339 return iterator.next();
340 } catch (ServiceConfigurationError sce) {
341 log.error("proc.bad.config.file", sce.getLocalizedMessage());
342 throw new Abort(sce);
343 } catch (Throwable t) {
344 throw new Abort(t);
345 }
346 }
348 public void remove() {
349 throw new UnsupportedOperationException();
350 }
352 public void close() {
353 if (loader != null) {
354 try {
355 loader.reload();
356 } catch(Exception e) {
357 ; // Ignore problems during a call to reload.
358 }
359 }
360 }
361 }
364 private static class NameProcessIterator implements Iterator<Processor> {
365 Processor nextProc = null;
366 Iterator<String> names;
367 ClassLoader processorCL;
368 Log log;
370 NameProcessIterator(String names, ClassLoader processorCL, Log log) {
371 this.names = Arrays.asList(names.split(",")).iterator();
372 this.processorCL = processorCL;
373 this.log = log;
374 }
376 public boolean hasNext() {
377 if (nextProc != null)
378 return true;
379 else {
380 if (!names.hasNext())
381 return false;
382 else {
383 String processorName = names.next();
385 Processor processor;
386 try {
387 try {
388 processor =
389 (Processor) (processorCL.loadClass(processorName).newInstance());
390 } catch (ClassNotFoundException cnfe) {
391 log.error("proc.processor.not.found", processorName);
392 return false;
393 } catch (ClassCastException cce) {
394 log.error("proc.processor.wrong.type", processorName);
395 return false;
396 } catch (Exception e ) {
397 log.error("proc.processor.cant.instantiate", processorName);
398 return false;
399 }
400 } catch(ClientCodeException e) {
401 throw e;
402 } catch(Throwable t) {
403 throw new AnnotationProcessingError(t);
404 }
405 nextProc = processor;
406 return true;
407 }
409 }
410 }
412 public Processor next() {
413 if (hasNext()) {
414 Processor p = nextProc;
415 nextProc = null;
416 return p;
417 } else
418 throw new NoSuchElementException();
419 }
421 public void remove () {
422 throw new UnsupportedOperationException();
423 }
424 }
426 public boolean atLeastOneProcessor() {
427 return discoveredProcs.iterator().hasNext();
428 }
430 private Map<String, String> initProcessorOptions(Context context) {
431 Options options = Options.instance(context);
432 Set<String> keySet = options.keySet();
433 Map<String, String> tempOptions = new LinkedHashMap<String, String>();
435 for(String key : keySet) {
436 if (key.startsWith("-A") && key.length() > 2) {
437 int sepIndex = key.indexOf('=');
438 String candidateKey = null;
439 String candidateValue = null;
441 if (sepIndex == -1)
442 candidateKey = key.substring(2);
443 else if (sepIndex >= 3) {
444 candidateKey = key.substring(2, sepIndex);
445 candidateValue = (sepIndex < key.length()-1)?
446 key.substring(sepIndex+1) : null;
447 }
448 tempOptions.put(candidateKey, candidateValue);
449 }
450 }
452 return Collections.unmodifiableMap(tempOptions);
453 }
455 private Set<String> initUnmatchedProcessorOptions() {
456 Set<String> unmatchedProcessorOptions = new HashSet<String>();
457 unmatchedProcessorOptions.addAll(processorOptions.keySet());
458 return unmatchedProcessorOptions;
459 }
461 /**
462 * State about how a processor has been used by the tool. If a
463 * processor has been used on a prior round, its process method is
464 * called on all subsequent rounds, perhaps with an empty set of
465 * annotations to process. The {@code annotatedSupported} method
466 * caches the supported annotation information from the first (and
467 * only) getSupportedAnnotationTypes call to the processor.
468 */
469 static class ProcessorState {
470 public Processor processor;
471 public boolean contributed;
472 private ArrayList<Pattern> supportedAnnotationPatterns;
473 private ArrayList<String> supportedOptionNames;
475 ProcessorState(Processor p, Log log, Source source, ProcessingEnvironment env) {
476 processor = p;
477 contributed = false;
479 try {
480 processor.init(env);
482 checkSourceVersionCompatibility(source, log);
484 supportedAnnotationPatterns = new ArrayList<Pattern>();
485 for (String importString : processor.getSupportedAnnotationTypes()) {
486 supportedAnnotationPatterns.add(importStringToPattern(importString,
487 processor,
488 log));
489 }
491 supportedOptionNames = new ArrayList<String>();
492 for (String optionName : processor.getSupportedOptions() ) {
493 if (checkOptionName(optionName, log))
494 supportedOptionNames.add(optionName);
495 }
497 } catch (ClientCodeException e) {
498 throw e;
499 } catch (Throwable t) {
500 throw new AnnotationProcessingError(t);
501 }
502 }
504 /**
505 * Checks whether or not a processor's source version is
506 * compatible with the compilation source version. The
507 * processor's source version needs to be greater than or
508 * equal to the source version of the compile.
509 */
510 private void checkSourceVersionCompatibility(Source source, Log log) {
511 SourceVersion procSourceVersion = processor.getSupportedSourceVersion();
513 if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 ) {
514 log.warning("proc.processor.incompatible.source.version",
515 procSourceVersion,
516 processor.getClass().getName(),
517 source.name);
518 }
519 }
521 private boolean checkOptionName(String optionName, Log log) {
522 boolean valid = isValidOptionName(optionName);
523 if (!valid)
524 log.error("proc.processor.bad.option.name",
525 optionName,
526 processor.getClass().getName());
527 return valid;
528 }
530 public boolean annotationSupported(String annotationName) {
531 for(Pattern p: supportedAnnotationPatterns) {
532 if (p.matcher(annotationName).matches())
533 return true;
534 }
535 return false;
536 }
538 /**
539 * Remove options that are matched by this processor.
540 */
541 public void removeSupportedOptions(Set<String> unmatchedProcessorOptions) {
542 unmatchedProcessorOptions.removeAll(supportedOptionNames);
543 }
544 }
546 // TODO: These two classes can probably be rewritten better...
547 /**
548 * This class holds information about the processors that have
549 * been discoverd so far as well as the means to discover more, if
550 * necessary. A single iterator should be used per round of
551 * annotation processing. The iterator first visits already
552 * discovered processors then fails over to the service provider
553 * mechanism if additional queries are made.
554 */
555 class DiscoveredProcessors implements Iterable<ProcessorState> {
557 class ProcessorStateIterator implements Iterator<ProcessorState> {
558 DiscoveredProcessors psi;
559 Iterator<ProcessorState> innerIter;
560 boolean onProcInterator;
562 ProcessorStateIterator(DiscoveredProcessors psi) {
563 this.psi = psi;
564 this.innerIter = psi.procStateList.iterator();
565 this.onProcInterator = false;
566 }
568 public ProcessorState next() {
569 if (!onProcInterator) {
570 if (innerIter.hasNext())
571 return innerIter.next();
572 else
573 onProcInterator = true;
574 }
576 if (psi.processorIterator.hasNext()) {
577 ProcessorState ps = new ProcessorState(psi.processorIterator.next(),
578 log, source, JavacProcessingEnvironment.this);
579 psi.procStateList.add(ps);
580 return ps;
581 } else
582 throw new NoSuchElementException();
583 }
585 public boolean hasNext() {
586 if (onProcInterator)
587 return psi.processorIterator.hasNext();
588 else
589 return innerIter.hasNext() || psi.processorIterator.hasNext();
590 }
592 public void remove () {
593 throw new UnsupportedOperationException();
594 }
596 /**
597 * Run all remaining processors on the procStateList that
598 * have not already run this round with an empty set of
599 * annotations.
600 */
601 public void runContributingProcs(RoundEnvironment re) {
602 if (!onProcInterator) {
603 Set<TypeElement> emptyTypeElements = Collections.emptySet();
604 while(innerIter.hasNext()) {
605 ProcessorState ps = innerIter.next();
606 if (ps.contributed)
607 callProcessor(ps.processor, emptyTypeElements, re);
608 }
609 }
610 }
611 }
613 Iterator<? extends Processor> processorIterator;
614 ArrayList<ProcessorState> procStateList;
616 public ProcessorStateIterator iterator() {
617 return new ProcessorStateIterator(this);
618 }
620 DiscoveredProcessors(Iterator<? extends Processor> processorIterator) {
621 this.processorIterator = processorIterator;
622 this.procStateList = new ArrayList<ProcessorState>();
623 }
625 /**
626 * Free jar files, etc. if using a service loader.
627 */
628 public void close() {
629 if (processorIterator != null &&
630 processorIterator instanceof ServiceIterator) {
631 ((ServiceIterator) processorIterator).close();
632 }
633 }
634 }
636 private void discoverAndRunProcs(Context context,
637 Set<TypeElement> annotationsPresent,
638 List<ClassSymbol> topLevelClasses,
639 List<PackageSymbol> packageInfoFiles) {
640 Map<String, TypeElement> unmatchedAnnotations =
641 new HashMap<String, TypeElement>(annotationsPresent.size());
643 for(TypeElement a : annotationsPresent) {
644 unmatchedAnnotations.put(a.getQualifiedName().toString(),
645 a);
646 }
648 // Give "*" processors a chance to match
649 if (unmatchedAnnotations.size() == 0)
650 unmatchedAnnotations.put("", null);
652 DiscoveredProcessors.ProcessorStateIterator psi = discoveredProcs.iterator();
653 // TODO: Create proper argument values; need past round
654 // information to fill in this constructor. Note that the 1
655 // st round of processing could be the last round if there
656 // were parse errors on the initial source files; however, we
657 // are not doing processing in that case.
659 Set<Element> rootElements = new LinkedHashSet<Element>();
660 rootElements.addAll(topLevelClasses);
661 rootElements.addAll(packageInfoFiles);
662 rootElements = Collections.unmodifiableSet(rootElements);
664 RoundEnvironment renv = new JavacRoundEnvironment(false,
665 false,
666 rootElements,
667 JavacProcessingEnvironment.this);
669 while(unmatchedAnnotations.size() > 0 && psi.hasNext() ) {
670 ProcessorState ps = psi.next();
671 Set<String> matchedNames = new HashSet<String>();
672 Set<TypeElement> typeElements = new LinkedHashSet<TypeElement>();
674 for (Map.Entry<String, TypeElement> entry: unmatchedAnnotations.entrySet()) {
675 String unmatchedAnnotationName = entry.getKey();
676 if (ps.annotationSupported(unmatchedAnnotationName) ) {
677 matchedNames.add(unmatchedAnnotationName);
678 TypeElement te = entry.getValue();
679 if (te != null)
680 typeElements.add(te);
681 }
682 }
684 if (matchedNames.size() > 0 || ps.contributed) {
685 boolean processingResult = callProcessor(ps.processor, typeElements, renv);
686 ps.contributed = true;
687 ps.removeSupportedOptions(unmatchedProcessorOptions);
689 if (printProcessorInfo || verbose) {
690 log.printLines("x.print.processor.info",
691 ps.processor.getClass().getName(),
692 matchedNames.toString(),
693 processingResult);
694 }
696 if (processingResult) {
697 unmatchedAnnotations.keySet().removeAll(matchedNames);
698 }
700 }
701 }
702 unmatchedAnnotations.remove("");
704 if (lint && unmatchedAnnotations.size() > 0) {
705 // Remove annotations processed by javac
706 unmatchedAnnotations.keySet().removeAll(platformAnnotations);
707 if (unmatchedAnnotations.size() > 0) {
708 log = Log.instance(context);
709 log.warning("proc.annotations.without.processors",
710 unmatchedAnnotations.keySet());
711 }
712 }
714 // Run contributing processors that haven't run yet
715 psi.runContributingProcs(renv);
717 // Debugging
718 if (options.isSet("displayFilerState"))
719 filer.displayState();
720 }
722 /**
723 * Computes the set of annotations on the symbol in question.
724 * Leave class public for external testing purposes.
725 */
726 public static class ComputeAnnotationSet extends
727 ElementScanner8<Set<TypeElement>, Set<TypeElement>> {
728 final Elements elements;
730 public ComputeAnnotationSet(Elements elements) {
731 super();
732 this.elements = elements;
733 }
735 @Override
736 public Set<TypeElement> visitPackage(PackageElement e, Set<TypeElement> p) {
737 // Don't scan enclosed elements of a package
738 return p;
739 }
741 @Override
742 public Set<TypeElement> scan(Element e, Set<TypeElement> p) {
743 for (AnnotationMirror annotationMirror :
744 elements.getAllAnnotationMirrors(e) ) {
745 Element e2 = annotationMirror.getAnnotationType().asElement();
746 p.add((TypeElement) e2);
747 }
748 return super.scan(e, p);
749 }
750 }
752 private boolean callProcessor(Processor proc,
753 Set<? extends TypeElement> tes,
754 RoundEnvironment renv) {
755 try {
756 return proc.process(tes, renv);
757 } catch (BadClassFile ex) {
758 log.error("proc.cant.access.1", ex.sym, ex.getDetailValue());
759 return false;
760 } catch (CompletionFailure ex) {
761 StringWriter out = new StringWriter();
762 ex.printStackTrace(new PrintWriter(out));
763 log.error("proc.cant.access", ex.sym, ex.getDetailValue(), out.toString());
764 return false;
765 } catch (ClientCodeException e) {
766 throw e;
767 } catch (Throwable t) {
768 throw new AnnotationProcessingError(t);
769 }
770 }
772 /**
773 * Helper object for a single round of annotation processing.
774 */
775 class Round {
776 /** The round number. */
777 final int number;
778 /** The context for the round. */
779 final Context context;
780 /** The compiler for the round. */
781 final JavaCompiler compiler;
782 /** The log for the round. */
783 final Log log;
785 /** The ASTs to be compiled. */
786 List<JCCompilationUnit> roots;
787 /** The classes to be compiler that have were generated. */
788 Map<String, JavaFileObject> genClassFiles;
790 /** The set of annotations to be processed this round. */
791 Set<TypeElement> annotationsPresent;
792 /** The set of top level classes to be processed this round. */
793 List<ClassSymbol> topLevelClasses;
794 /** The set of package-info files to be processed this round. */
795 List<PackageSymbol> packageInfoFiles;
797 /** The number of Messager errors generated in this round. */
798 int nMessagerErrors;
800 /** Create a round (common code). */
801 private Round(Context context, int number, int priorErrors, int priorWarnings) {
802 this.context = context;
803 this.number = number;
805 compiler = JavaCompiler.instance(context);
806 log = Log.instance(context);
807 log.nerrors = priorErrors;
808 log.nwarnings += priorWarnings;
809 log.deferDiagnostics = true;
811 // the following is for the benefit of JavacProcessingEnvironment.getContext()
812 JavacProcessingEnvironment.this.context = context;
814 // the following will be populated as needed
815 topLevelClasses = List.nil();
816 packageInfoFiles = List.nil();
817 }
819 /** Create the first round. */
820 Round(Context context, List<JCCompilationUnit> roots, List<ClassSymbol> classSymbols) {
821 this(context, 1, 0, 0);
822 this.roots = roots;
823 genClassFiles = new HashMap<String,JavaFileObject>();
825 compiler.todo.clear(); // free the compiler's resources
827 // The reverse() in the following line is to maintain behavioural
828 // compatibility with the previous revision of the code. Strictly speaking,
829 // it should not be necessary, but a javah golden file test fails without it.
830 topLevelClasses =
831 getTopLevelClasses(roots).prependList(classSymbols.reverse());
833 packageInfoFiles = getPackageInfoFiles(roots);
835 findAnnotationsPresent();
836 }
838 /** Create a new round. */
839 private Round(Round prev,
840 Set<JavaFileObject> newSourceFiles, Map<String,JavaFileObject> newClassFiles) {
841 this(prev.nextContext(),
842 prev.number+1,
843 prev.nMessagerErrors,
844 prev.compiler.log.nwarnings);
845 this.genClassFiles = prev.genClassFiles;
847 List<JCCompilationUnit> parsedFiles = compiler.parseFiles(newSourceFiles);
848 roots = cleanTrees(prev.roots).appendList(parsedFiles);
850 // Check for errors after parsing
851 if (unrecoverableError())
852 return;
854 enterClassFiles(genClassFiles);
855 List<ClassSymbol> newClasses = enterClassFiles(newClassFiles);
856 genClassFiles.putAll(newClassFiles);
857 enterTrees(roots);
859 if (unrecoverableError())
860 return;
862 topLevelClasses = join(
863 getTopLevelClasses(parsedFiles),
864 getTopLevelClassesFromClasses(newClasses));
866 packageInfoFiles = join(
867 getPackageInfoFiles(parsedFiles),
868 getPackageInfoFilesFromClasses(newClasses));
870 findAnnotationsPresent();
871 }
873 /** Create the next round to be used. */
874 Round next(Set<JavaFileObject> newSourceFiles, Map<String, JavaFileObject> newClassFiles) {
875 try {
876 return new Round(this, newSourceFiles, newClassFiles);
877 } finally {
878 compiler.close(false);
879 }
880 }
882 /** Create the compiler to be used for the final compilation. */
883 JavaCompiler finalCompiler(boolean errorStatus) {
884 try {
885 JavaCompiler c = JavaCompiler.instance(nextContext());
886 c.log.nwarnings += compiler.log.nwarnings;
887 if (errorStatus) {
888 c.log.nerrors += compiler.log.nerrors;
889 }
890 return c;
891 } finally {
892 compiler.close(false);
893 }
894 }
896 /** Return the number of errors found so far in this round.
897 * This may include uncoverable errors, such as parse errors,
898 * and transient errors, such as missing symbols. */
899 int errorCount() {
900 return compiler.errorCount();
901 }
903 /** Return the number of warnings found so far in this round. */
904 int warningCount() {
905 return compiler.warningCount();
906 }
908 /** Return whether or not an unrecoverable error has occurred. */
909 boolean unrecoverableError() {
910 if (messager.errorRaised())
911 return true;
913 for (JCDiagnostic d: log.deferredDiagnostics) {
914 switch (d.getKind()) {
915 case WARNING:
916 if (werror)
917 return true;
918 break;
920 case ERROR:
921 if (fatalErrors || !d.isFlagSet(RECOVERABLE))
922 return true;
923 break;
924 }
925 }
927 return false;
928 }
930 /** Find the set of annotations present in the set of top level
931 * classes and package info files to be processed this round. */
932 void findAnnotationsPresent() {
933 ComputeAnnotationSet annotationComputer = new ComputeAnnotationSet(elementUtils);
934 // Use annotation processing to compute the set of annotations present
935 annotationsPresent = new LinkedHashSet<TypeElement>();
936 for (ClassSymbol classSym : topLevelClasses)
937 annotationComputer.scan(classSym, annotationsPresent);
938 for (PackageSymbol pkgSym : packageInfoFiles)
939 annotationComputer.scan(pkgSym, annotationsPresent);
940 }
942 /** Enter a set of generated class files. */
943 private List<ClassSymbol> enterClassFiles(Map<String, JavaFileObject> classFiles) {
944 ClassReader reader = ClassReader.instance(context);
945 Names names = Names.instance(context);
946 List<ClassSymbol> list = List.nil();
948 for (Map.Entry<String,JavaFileObject> entry : classFiles.entrySet()) {
949 Name name = names.fromString(entry.getKey());
950 JavaFileObject file = entry.getValue();
951 if (file.getKind() != JavaFileObject.Kind.CLASS)
952 throw new AssertionError(file);
953 ClassSymbol cs;
954 if (isPkgInfo(file, JavaFileObject.Kind.CLASS)) {
955 Name packageName = Convert.packagePart(name);
956 PackageSymbol p = reader.enterPackage(packageName);
957 if (p.package_info == null)
958 p.package_info = reader.enterClass(Convert.shortName(name), p);
959 cs = p.package_info;
960 if (cs.classfile == null)
961 cs.classfile = file;
962 } else
963 cs = reader.enterClass(name, file);
964 list = list.prepend(cs);
965 }
966 return list.reverse();
967 }
969 /** Enter a set of syntax trees. */
970 private void enterTrees(List<JCCompilationUnit> roots) {
971 compiler.enterTrees(roots);
972 }
974 /** Run a processing round. */
975 void run(boolean lastRound, boolean errorStatus) {
976 printRoundInfo(lastRound);
978 if (!taskListener.isEmpty())
979 taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
981 try {
982 if (lastRound) {
983 filer.setLastRound(true);
984 Set<Element> emptyRootElements = Collections.emptySet(); // immutable
985 RoundEnvironment renv = new JavacRoundEnvironment(true,
986 errorStatus,
987 emptyRootElements,
988 JavacProcessingEnvironment.this);
989 discoveredProcs.iterator().runContributingProcs(renv);
990 } else {
991 discoverAndRunProcs(context, annotationsPresent, topLevelClasses, packageInfoFiles);
992 }
993 } finally {
994 if (!taskListener.isEmpty())
995 taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND));
996 }
998 nMessagerErrors = messager.errorCount();
999 }
1001 void showDiagnostics(boolean showAll) {
1002 Set<JCDiagnostic.Kind> kinds = EnumSet.allOf(JCDiagnostic.Kind.class);
1003 if (!showAll) {
1004 // suppress errors, which are all presumed to be transient resolve errors
1005 kinds.remove(JCDiagnostic.Kind.ERROR);
1006 }
1007 log.reportDeferredDiagnostics(kinds);
1008 }
1010 /** Print info about this round. */
1011 private void printRoundInfo(boolean lastRound) {
1012 if (printRounds || verbose) {
1013 List<ClassSymbol> tlc = lastRound ? List.<ClassSymbol>nil() : topLevelClasses;
1014 Set<TypeElement> ap = lastRound ? Collections.<TypeElement>emptySet() : annotationsPresent;
1015 log.printLines("x.print.rounds",
1016 number,
1017 "{" + tlc.toString(", ") + "}",
1018 ap,
1019 lastRound);
1020 }
1021 }
1023 /** Get the context for the next round of processing.
1024 * Important values are propogated from round to round;
1025 * other values are implicitly reset.
1026 */
1027 private Context nextContext() {
1028 Context next = new Context(context);
1030 Options options = Options.instance(context);
1031 Assert.checkNonNull(options);
1032 next.put(Options.optionsKey, options);
1034 Locale locale = context.get(Locale.class);
1035 if (locale != null)
1036 next.put(Locale.class, locale);
1038 Assert.checkNonNull(messages);
1039 next.put(JavacMessages.messagesKey, messages);
1041 final boolean shareNames = true;
1042 if (shareNames) {
1043 Names names = Names.instance(context);
1044 Assert.checkNonNull(names);
1045 next.put(Names.namesKey, names);
1046 }
1048 DiagnosticListener<?> dl = context.get(DiagnosticListener.class);
1049 if (dl != null)
1050 next.put(DiagnosticListener.class, dl);
1052 MultiTaskListener mtl = context.get(MultiTaskListener.taskListenerKey);
1053 if (mtl != null)
1054 next.put(MultiTaskListener.taskListenerKey, mtl);
1056 FSInfo fsInfo = context.get(FSInfo.class);
1057 if (fsInfo != null)
1058 next.put(FSInfo.class, fsInfo);
1060 JavaFileManager jfm = context.get(JavaFileManager.class);
1061 Assert.checkNonNull(jfm);
1062 next.put(JavaFileManager.class, jfm);
1063 if (jfm instanceof JavacFileManager) {
1064 ((JavacFileManager)jfm).setContext(next);
1065 }
1067 Names names = Names.instance(context);
1068 Assert.checkNonNull(names);
1069 next.put(Names.namesKey, names);
1071 Tokens tokens = Tokens.instance(context);
1072 Assert.checkNonNull(tokens);
1073 next.put(Tokens.tokensKey, tokens);
1075 // propogate the log's writers directly, instead of going through context
1076 Log.instance(next).setWriters(log);
1078 JavaCompiler oldCompiler = JavaCompiler.instance(context);
1079 JavaCompiler nextCompiler = JavaCompiler.instance(next);
1080 nextCompiler.initRound(oldCompiler);
1082 filer.newRound(next);
1083 messager.newRound(next);
1084 elementUtils.setContext(next);
1085 typeUtils.setContext(next);
1087 JavacTaskImpl task = (JavacTaskImpl) context.get(JavacTask.class);
1088 if (task != null) {
1089 next.put(JavacTask.class, task);
1090 task.updateContext(next);
1091 }
1093 JavacTrees trees = context.get(JavacTrees.class);
1094 if (trees != null) {
1095 next.put(JavacTrees.class, trees);
1096 trees.updateContext(next);
1097 }
1099 context.clear();
1100 return next;
1101 }
1102 }
1105 // TODO: internal catch clauses?; catch and rethrow an annotation
1106 // processing error
1107 public JavaCompiler doProcessing(Context context,
1108 List<JCCompilationUnit> roots,
1109 List<ClassSymbol> classSymbols,
1110 Iterable<? extends PackageSymbol> pckSymbols) {
1111 log = Log.instance(context);
1113 Set<PackageSymbol> specifiedPackages = new LinkedHashSet<PackageSymbol>();
1114 for (PackageSymbol psym : pckSymbols)
1115 specifiedPackages.add(psym);
1116 this.specifiedPackages = Collections.unmodifiableSet(specifiedPackages);
1118 Round round = new Round(context, roots, classSymbols);
1120 boolean errorStatus;
1121 boolean moreToDo;
1122 do {
1123 // Run processors for round n
1124 round.run(false, false);
1126 // Processors for round n have run to completion.
1127 // Check for errors and whether there is more work to do.
1128 errorStatus = round.unrecoverableError();
1129 moreToDo = moreToDo();
1131 round.showDiagnostics(errorStatus || showResolveErrors);
1133 // Set up next round.
1134 // Copy mutable collections returned from filer.
1135 round = round.next(
1136 new LinkedHashSet<JavaFileObject>(filer.getGeneratedSourceFileObjects()),
1137 new LinkedHashMap<String,JavaFileObject>(filer.getGeneratedClasses()));
1139 // Check for errors during setup.
1140 if (round.unrecoverableError())
1141 errorStatus = true;
1143 } while (moreToDo && !errorStatus);
1145 // run last round
1146 round.run(true, errorStatus);
1147 round.showDiagnostics(true);
1149 filer.warnIfUnclosedFiles();
1150 warnIfUnmatchedOptions();
1152 /*
1153 * If an annotation processor raises an error in a round,
1154 * that round runs to completion and one last round occurs.
1155 * The last round may also occur because no more source or
1156 * class files have been generated. Therefore, if an error
1157 * was raised on either of the last *two* rounds, the compile
1158 * should exit with a nonzero exit code. The current value of
1159 * errorStatus holds whether or not an error was raised on the
1160 * second to last round; errorRaised() gives the error status
1161 * of the last round.
1162 */
1163 if (messager.errorRaised()
1164 || werror && round.warningCount() > 0 && round.errorCount() > 0)
1165 errorStatus = true;
1167 Set<JavaFileObject> newSourceFiles =
1168 new LinkedHashSet<JavaFileObject>(filer.getGeneratedSourceFileObjects());
1169 roots = cleanTrees(round.roots);
1171 JavaCompiler compiler = round.finalCompiler(errorStatus);
1173 if (newSourceFiles.size() > 0)
1174 roots = roots.appendList(compiler.parseFiles(newSourceFiles));
1176 errorStatus = errorStatus || (compiler.errorCount() > 0);
1178 // Free resources
1179 this.close();
1181 if (!taskListener.isEmpty())
1182 taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING));
1184 if (errorStatus) {
1185 if (compiler.errorCount() == 0)
1186 compiler.log.nerrors++;
1187 return compiler;
1188 }
1190 if (procOnly && !foundTypeProcessors) {
1191 compiler.todo.clear();
1192 } else {
1193 if (procOnly && foundTypeProcessors)
1194 compiler.shouldStopPolicy = CompileState.FLOW;
1196 compiler.enterTrees(roots);
1197 }
1199 return compiler;
1200 }
1202 private void warnIfUnmatchedOptions() {
1203 if (!unmatchedProcessorOptions.isEmpty()) {
1204 log.warning("proc.unmatched.processor.options", unmatchedProcessorOptions.toString());
1205 }
1206 }
1208 /**
1209 * Free resources related to annotation processing.
1210 */
1211 public void close() {
1212 filer.close();
1213 if (discoveredProcs != null) // Make calling close idempotent
1214 discoveredProcs.close();
1215 discoveredProcs = null;
1216 }
1218 private List<ClassSymbol> getTopLevelClasses(List<? extends JCCompilationUnit> units) {
1219 List<ClassSymbol> classes = List.nil();
1220 for (JCCompilationUnit unit : units) {
1221 for (JCTree node : unit.defs) {
1222 if (node.hasTag(JCTree.Tag.CLASSDEF)) {
1223 ClassSymbol sym = ((JCClassDecl) node).sym;
1224 Assert.checkNonNull(sym);
1225 classes = classes.prepend(sym);
1226 }
1227 }
1228 }
1229 return classes.reverse();
1230 }
1232 private List<ClassSymbol> getTopLevelClassesFromClasses(List<? extends ClassSymbol> syms) {
1233 List<ClassSymbol> classes = List.nil();
1234 for (ClassSymbol sym : syms) {
1235 if (!isPkgInfo(sym)) {
1236 classes = classes.prepend(sym);
1237 }
1238 }
1239 return classes.reverse();
1240 }
1242 private List<PackageSymbol> getPackageInfoFiles(List<? extends JCCompilationUnit> units) {
1243 List<PackageSymbol> packages = List.nil();
1244 for (JCCompilationUnit unit : units) {
1245 if (isPkgInfo(unit.sourcefile, JavaFileObject.Kind.SOURCE)) {
1246 packages = packages.prepend(unit.packge);
1247 }
1248 }
1249 return packages.reverse();
1250 }
1252 private List<PackageSymbol> getPackageInfoFilesFromClasses(List<? extends ClassSymbol> syms) {
1253 List<PackageSymbol> packages = List.nil();
1254 for (ClassSymbol sym : syms) {
1255 if (isPkgInfo(sym)) {
1256 packages = packages.prepend((PackageSymbol) sym.owner);
1257 }
1258 }
1259 return packages.reverse();
1260 }
1262 // avoid unchecked warning from use of varargs
1263 private static <T> List<T> join(List<T> list1, List<T> list2) {
1264 return list1.appendList(list2);
1265 }
1267 private boolean isPkgInfo(JavaFileObject fo, JavaFileObject.Kind kind) {
1268 return fo.isNameCompatible("package-info", kind);
1269 }
1271 private boolean isPkgInfo(ClassSymbol sym) {
1272 return isPkgInfo(sym.classfile, JavaFileObject.Kind.CLASS) && (sym.packge().package_info == sym);
1273 }
1275 /*
1276 * Called retroactively to determine if a class loader was required,
1277 * after we have failed to create one.
1278 */
1279 private boolean needClassLoader(String procNames, Iterable<? extends File> workingpath) {
1280 if (procNames != null)
1281 return true;
1283 String procPath;
1284 URL[] urls = new URL[1];
1285 for(File pathElement : workingpath) {
1286 try {
1287 urls[0] = pathElement.toURI().toURL();
1288 if (ServiceProxy.hasService(Processor.class, urls))
1289 return true;
1290 } catch (MalformedURLException ex) {
1291 throw new AssertionError(ex);
1292 }
1293 catch (ServiceProxy.ServiceConfigurationError e) {
1294 log.error("proc.bad.config.file", e.getLocalizedMessage());
1295 return true;
1296 }
1297 }
1299 return false;
1300 }
1302 private static <T extends JCTree> List<T> cleanTrees(List<T> nodes) {
1303 for (T node : nodes)
1304 treeCleaner.scan(node);
1305 return nodes;
1306 }
1308 private static TreeScanner treeCleaner = new TreeScanner() {
1309 public void scan(JCTree node) {
1310 super.scan(node);
1311 if (node != null)
1312 node.type = null;
1313 }
1314 public void visitTopLevel(JCCompilationUnit node) {
1315 node.packge = null;
1316 super.visitTopLevel(node);
1317 }
1318 public void visitClassDef(JCClassDecl node) {
1319 node.sym = null;
1320 super.visitClassDef(node);
1321 }
1322 public void visitMethodDef(JCMethodDecl node) {
1323 node.sym = null;
1324 super.visitMethodDef(node);
1325 }
1326 public void visitVarDef(JCVariableDecl node) {
1327 node.sym = null;
1328 super.visitVarDef(node);
1329 }
1330 public void visitNewClass(JCNewClass node) {
1331 node.constructor = null;
1332 super.visitNewClass(node);
1333 }
1334 public void visitAssignop(JCAssignOp node) {
1335 node.operator = null;
1336 super.visitAssignop(node);
1337 }
1338 public void visitUnary(JCUnary node) {
1339 node.operator = null;
1340 super.visitUnary(node);
1341 }
1342 public void visitBinary(JCBinary node) {
1343 node.operator = null;
1344 super.visitBinary(node);
1345 }
1346 public void visitSelect(JCFieldAccess node) {
1347 node.sym = null;
1348 super.visitSelect(node);
1349 }
1350 public void visitIdent(JCIdent node) {
1351 node.sym = null;
1352 super.visitIdent(node);
1353 }
1354 };
1357 private boolean moreToDo() {
1358 return filer.newFiles();
1359 }
1361 /**
1362 * {@inheritdoc}
1363 *
1364 * Command line options suitable for presenting to annotation
1365 * processors. "-Afoo=bar" should be "-Afoo" => "bar".
1366 */
1367 public Map<String,String> getOptions() {
1368 return processorOptions;
1369 }
1371 public Messager getMessager() {
1372 return messager;
1373 }
1375 public Filer getFiler() {
1376 return filer;
1377 }
1379 public JavacElements getElementUtils() {
1380 return elementUtils;
1381 }
1383 public JavacTypes getTypeUtils() {
1384 return typeUtils;
1385 }
1387 public SourceVersion getSourceVersion() {
1388 return Source.toSourceVersion(source);
1389 }
1391 public Locale getLocale() {
1392 return messages.getCurrentLocale();
1393 }
1395 public Set<Symbol.PackageSymbol> getSpecifiedPackages() {
1396 return specifiedPackages;
1397 }
1399 private static final Pattern allMatches = Pattern.compile(".*");
1400 public static final Pattern noMatches = Pattern.compile("(\\P{all})+");
1402 /**
1403 * Convert import-style string for supported annotations into a
1404 * regex matching that string. If the string is a valid
1405 * import-style string, return a regex that won't match anything.
1406 */
1407 private static Pattern importStringToPattern(String s, Processor p, Log log) {
1408 if (isValidImportString(s)) {
1409 return validImportStringToPattern(s);
1410 } else {
1411 log.warning("proc.malformed.supported.string", s, p.getClass().getName());
1412 return noMatches; // won't match any valid identifier
1413 }
1414 }
1416 /**
1417 * Return true if the argument string is a valid import-style
1418 * string specifying claimed annotations; return false otherwise.
1419 */
1420 public static boolean isValidImportString(String s) {
1421 if (s.equals("*"))
1422 return true;
1424 boolean valid = true;
1425 String t = s;
1426 int index = t.indexOf('*');
1428 if (index != -1) {
1429 // '*' must be last character...
1430 if (index == t.length() -1) {
1431 // ... any and preceding character must be '.'
1432 if ( index-1 >= 0 ) {
1433 valid = t.charAt(index-1) == '.';
1434 // Strip off ".*$" for identifier checks
1435 t = t.substring(0, t.length()-2);
1436 }
1437 } else
1438 return false;
1439 }
1441 // Verify string is off the form (javaId \.)+ or javaId
1442 if (valid) {
1443 String[] javaIds = t.split("\\.", t.length()+2);
1444 for(String javaId: javaIds)
1445 valid &= SourceVersion.isIdentifier(javaId);
1446 }
1447 return valid;
1448 }
1450 public static Pattern validImportStringToPattern(String s) {
1451 if (s.equals("*")) {
1452 return allMatches;
1453 } else {
1454 String s_prime = s.replace(".", "\\.");
1456 if (s_prime.endsWith("*")) {
1457 s_prime = s_prime.substring(0, s_prime.length() - 1) + ".+";
1458 }
1460 return Pattern.compile(s_prime);
1461 }
1462 }
1464 /**
1465 * For internal use only. This method will be
1466 * removed without warning.
1467 */
1468 public Context getContext() {
1469 return context;
1470 }
1472 public String toString() {
1473 return "javac ProcessingEnvironment";
1474 }
1476 public static boolean isValidOptionName(String optionName) {
1477 for(String s : optionName.split("\\.", -1)) {
1478 if (!SourceVersion.isIdentifier(s))
1479 return false;
1480 }
1481 return true;
1482 }
1483 }