diff options
Diffstat (limited to 'javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java')
| -rw-r--r-- | javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java | 271 |
1 files changed, 271 insertions, 0 deletions
diff --git a/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java new file mode 100644 index 000000000..e5be2b80a --- /dev/null +++ b/javaparser-core/src/main/java/com/github/javaparser/ParserConfiguration.java @@ -0,0 +1,271 @@ +/* + * Copyright (C) 2007-2010 Júlio Vilmar Gesser. + * Copyright (C) 2011, 2013-2016 The JavaParser Team. + * + * This file is part of JavaParser. + * + * JavaParser can be used either under the terms of + * a) the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * b) the terms of the Apache License + * + * You should have received a copy of both licenses in LICENCE.LGPL and + * LICENCE.APACHE. Please refer to those files for details. + * + * JavaParser is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + */ + +package com.github.javaparser; + +import com.github.javaparser.ast.CompilationUnit; +import com.github.javaparser.ast.Node; +import com.github.javaparser.ast.validator.*; +import com.github.javaparser.printer.lexicalpreservation.LexicalPreservingPrinter; +import com.github.javaparser.resolution.SymbolResolver; +import com.github.javaparser.version.Java10PostProcessor; +import com.github.javaparser.version.Java11PostProcessor; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import static com.github.javaparser.ParserConfiguration.LanguageLevel.*; +import static com.github.javaparser.utils.Utils.assertNotNull; + +/** + * The configuration that is used by the parser. + * Note that this can be changed even when reusing the same JavaParser instance. + * It will pick up the changes. + */ +public class ParserConfiguration { + public enum LanguageLevel { + /** Does no post processing or validation. Only for people wanting the fastest parsing. */ + RAW(null, null), + /** The most used Java version. */ + POPULAR(new Java8Validator(), null), + /** The latest Java version that is available. */ + CURRENT(new Java8Validator(), null), + /** The newest Java features supported. */ + BLEEDING_EDGE(new Java11Validator(), new Java11PostProcessor()), + /** Java 1.0 */ + JAVA_1_0(new Java1_0Validator(), null), + /** Java 1.1 */ + JAVA_1_1(new Java1_1Validator(), null), + /** Java 1.2 */ + JAVA_1_2(new Java1_2Validator(), null), + /** Java 1.3 */ + JAVA_1_3(new Java1_3Validator(), null), + /** Java 1.4 */ + JAVA_1_4(new Java1_4Validator(), null), + /** Java 5 */ + JAVA_5(new Java5Validator(), null), + /** Java 6 */ + JAVA_6(new Java6Validator(), null), + /** Java 7 */ + JAVA_7(new Java7Validator(), null), + /** Java 8 */ + JAVA_8(new Java8Validator(), null), + /** Java 9 */ + JAVA_9(new Java9Validator(), null), + /** Java 10 */ + JAVA_10(new Java10Validator(), new Java10PostProcessor()), + /** Java 11 (work in progress) */ + JAVA_11_PREVIEW(new Java11Validator(), new Java11PostProcessor()); + + final Validator validator; + final ParseResult.PostProcessor postProcessor; + + LanguageLevel(Validator validator, ParseResult.PostProcessor postProcessor) { + this.validator = validator; + this.postProcessor = postProcessor; + } + } + + private boolean storeTokens = true; + private boolean attributeComments = true; + private boolean doNotAssignCommentsPrecedingEmptyLines = true; + private boolean doNotConsiderAnnotationsAsNodeStartForCodeAttribution = false; + private boolean lexicalPreservationEnabled = false; + private SymbolResolver symbolResolver = null; + private int tabSize = 1; + private LanguageLevel languageLevel = CURRENT; + + private final List<ParseResult.PostProcessor> postProcessors = new ArrayList<>(); + + public ParserConfiguration() { + postProcessors.add((result, configuration) -> { + if (configuration.isLexicalPreservationEnabled()) { + if (configuration.isLexicalPreservationEnabled()) { + result.ifSuccessful(LexicalPreservingPrinter::setup); + } + } + }); + postProcessors.add((result, configuration) -> { + if (configuration.isAttributeComments()) { + result.ifSuccessful(resultNode -> result + .getCommentsCollection().ifPresent(comments -> + new CommentsInserter(configuration).insertComments(resultNode, comments.copy().getComments()))); + } + }); + postProcessors.add((result, configuration) -> { + LanguageLevel languageLevel = getLanguageLevel(); + if (languageLevel.postProcessor != null) { + languageLevel.postProcessor.process(result, configuration); + } + if (languageLevel.validator != null) { + languageLevel.validator.accept(result.getResult().get(), new ProblemReporter(newProblem -> result.getProblems().add(newProblem))); + } + }); + postProcessors.add((result, configuration) -> configuration.getSymbolResolver().ifPresent(symbolResolver -> + result.ifSuccessful(resultNode -> { + if (resultNode instanceof CompilationUnit) { + resultNode.setData(Node.SYMBOL_RESOLVER_KEY, symbolResolver); + } + }) + )); + } + + public boolean isAttributeComments() { + return attributeComments; + } + + /** + * Whether to run CommentsInserter, which will put the comments that were found in the source code into the comment + * and javadoc fields of the nodes it thinks they refer to. + */ + public ParserConfiguration setAttributeComments(boolean attributeComments) { + this.attributeComments = attributeComments; + return this; + } + + public boolean isDoNotAssignCommentsPrecedingEmptyLines() { + return doNotAssignCommentsPrecedingEmptyLines; + } + + public ParserConfiguration setDoNotAssignCommentsPrecedingEmptyLines(boolean doNotAssignCommentsPrecedingEmptyLines) { + this.doNotAssignCommentsPrecedingEmptyLines = doNotAssignCommentsPrecedingEmptyLines; + return this; + } + + public boolean isDoNotConsiderAnnotationsAsNodeStartForCodeAttribution() { + return doNotConsiderAnnotationsAsNodeStartForCodeAttribution; + } + + public ParserConfiguration setDoNotConsiderAnnotationsAsNodeStartForCodeAttribution(boolean doNotConsiderAnnotationsAsNodeStartForCodeAttribution) { + this.doNotConsiderAnnotationsAsNodeStartForCodeAttribution = doNotConsiderAnnotationsAsNodeStartForCodeAttribution; + return this; + } + + public ParserConfiguration setStoreTokens(boolean storeTokens) { + this.storeTokens = storeTokens; + if (!storeTokens) { + setAttributeComments(false); + } + return this; + } + + public boolean isStoreTokens() { + return storeTokens; + } + + public int getTabSize() { + return tabSize; + } + + /** + * When a TAB character is encountered during parsing, the column position will be increased by this value. + * By default it is 1. + */ + public ParserConfiguration setTabSize(int tabSize) { + this.tabSize = tabSize; + return this; + } + + /** + * @deprecated use getLanguageLevel + */ + @Deprecated + public Optional<Validator> getValidator() { + throw new IllegalStateException("method is deprecated"); + } + + /** + * @deprecated use setLanguageLevel, or getPostProcessors if you use a custom validator. + */ + @Deprecated + public ParserConfiguration setValidator(Validator validator) { + // This whole method is a backwards compatability hack. + if (validator instanceof Java10Validator) { + setLanguageLevel(JAVA_10); + } else if (validator instanceof Java9Validator) { + setLanguageLevel(JAVA_9); + } else if (validator instanceof Java8Validator) { + setLanguageLevel(JAVA_8); + } else if (validator instanceof Java7Validator) { + setLanguageLevel(JAVA_7); + } else if (validator instanceof Java6Validator) { + setLanguageLevel(JAVA_6); + } else if (validator instanceof Java5Validator) { + setLanguageLevel(JAVA_5); + } else if (validator instanceof Java1_4Validator) { + setLanguageLevel(JAVA_1_4); + } else if (validator instanceof Java1_3Validator) { + setLanguageLevel(JAVA_1_3); + } else if (validator instanceof Java1_2Validator) { + setLanguageLevel(JAVA_1_2); + } else if (validator instanceof Java1_1Validator) { + setLanguageLevel(JAVA_1_1); + } else if (validator instanceof Java1_0Validator) { + setLanguageLevel(JAVA_1_0); + } else if (validator instanceof NoProblemsValidator) { + setLanguageLevel(RAW); + } + return this; + } + + /** + * Disabled by default. + * When this is enabled, LexicalPreservingPrinter.print can be used to reproduce + * the original formatting of the file. + */ + public ParserConfiguration setLexicalPreservationEnabled(boolean lexicalPreservationEnabled) { + this.lexicalPreservationEnabled = lexicalPreservationEnabled; + return this; + } + + public boolean isLexicalPreservationEnabled() { + return lexicalPreservationEnabled; + } + + /** + * Retrieve the SymbolResolver to be used while parsing, if any. + */ + public Optional<SymbolResolver> getSymbolResolver() { + return Optional.ofNullable(symbolResolver); + } + + /** + * Set the SymbolResolver to be injected while parsing. + */ + public ParserConfiguration setSymbolResolver(SymbolResolver symbolResolver) { + this.symbolResolver = symbolResolver; + return this; + } + + public List<ParseResult.PostProcessor> getPostProcessors() { + return postProcessors; + } + + public ParserConfiguration setLanguageLevel(LanguageLevel languageLevel) { + this.languageLevel = assertNotNull(languageLevel); + return this; + } + + public LanguageLevel getLanguageLevel() { + return languageLevel; + } +} |