proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/YamlPrinter.java
|
YamlPrinter
|
indent
|
class YamlPrinter {
private static final int NUM_SPACES_FOR_INDENT = 4;
private final boolean outputNodeType;
public YamlPrinter(boolean outputNodeType) {
this.outputNodeType = outputNodeType;
}
public String output(Node node) {
StringBuilder output = new StringBuilder();
output.append("---");
output(node, "root", 0, output);
output.append(System.lineSeparator() + "...");
return output.toString();
}
public void output(Node node, String name, int level, StringBuilder builder) {
assertNotNull(node);
NodeMetaModel metaModel = node.getMetaModel();
List<PropertyMetaModel> allPropertyMetaModels = metaModel.getAllPropertyMetaModels();
List<PropertyMetaModel> attributes = allPropertyMetaModels.stream().filter(PropertyMetaModel::isAttribute).filter(PropertyMetaModel::isSingular).collect(toList());
List<PropertyMetaModel> subNodes = allPropertyMetaModels.stream().filter(PropertyMetaModel::isNode).filter(PropertyMetaModel::isSingular).collect(toList());
List<PropertyMetaModel> subLists = allPropertyMetaModels.stream().filter(PropertyMetaModel::isNodeList).collect(toList());
if (outputNodeType)
builder.append(System.lineSeparator() + indent(level) + name + "(Type=" + metaModel.getTypeName() + "): ");
else
builder.append(System.lineSeparator() + indent(level) + name + ": ");
level++;
for (PropertyMetaModel a : attributes) {
builder.append(System.lineSeparator() + indent(level) + a.getName() + ": " + escapeValue(a.getValue(node).toString()));
}
for (PropertyMetaModel sn : subNodes) {
Node nd = (Node) sn.getValue(node);
if (nd != null)
output(nd, sn.getName(), level, builder);
}
for (PropertyMetaModel sl : subLists) {
NodeList<? extends Node> nl = (NodeList<? extends Node>) sl.getValue(node);
if (nl != null && nl.isNonEmpty()) {
builder.append(System.lineSeparator() + indent(level) + sl.getName() + ": ");
String slName = sl.getName();
slName = slName.endsWith("s") ? slName.substring(0, sl.getName().length() - 1) : slName;
for (Node nd : nl) output(nd, "- " + slName, level + 1, builder);
}
}
}
private String indent(int level) {<FILL_FUNCTION_BODY>}
private String escapeValue(String value) {
return "\"" + value.replace("\\", "\\\\").replaceAll("\"", "\\\\\"").replace("\n", "\\n").replace("\r", "\\r").replace("\f", "\\f").replace("\b", "\\b").replace("\t", "\\t") + "\"";
}
public static void print(Node node) {
System.out.println(new YamlPrinter(true).output(node));
}
}
|
StringBuilder sb = new StringBuilder();
for (int i = 0; i < level; i++) for (int j = 0; j < NUM_SPACES_FOR_INDENT; j++) sb.append(" ");
return sb.toString();
| 818
| 65
| 883
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/concretesyntaxmodel/CsmAttribute.java
|
CsmAttribute
|
getTokenType
|
class CsmAttribute implements CsmElement {
public ObservableProperty getProperty() {
return property;
}
private final ObservableProperty property;
public CsmAttribute(ObservableProperty property) {
this.property = property;
}
@Override
public void prettyPrint(Node node, SourcePrinter printer) {
Object value = property.getRawValue(node);
printer.print(PrintingHelper.printToString(value));
}
/**
* Obtain the token type corresponding to the specific value of the attribute.
* For example, to the attribute "Operator" different token could correspond like PLUS or MINUS.
*
* @param tokenText Operator's token text
*/
public int getTokenType(Node node, String text, String tokenText) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return String.format("%s(property:%s)", this.getClass().getSimpleName(), getProperty());
}
}
|
switch(property) {
case IDENTIFIER:
return GeneratedJavaParserConstants.IDENTIFIER;
case TYPE:
{
String expectedImage = "\"" + text.toLowerCase() + "\"";
for (int i = 0; i < GeneratedJavaParserConstants.tokenImage.length; i++) {
if (GeneratedJavaParserConstants.tokenImage[i].equals(expectedImage)) {
return i;
}
}
throw new RuntimeException(f("Attribute '%s' does not corresponding to any expected value. Text: %s", property.camelCaseName(), text));
}
case KEYWORD:
case OPERATOR:
{
String expectedImage = "\"" + tokenText.toLowerCase() + "\"";
for (int i = 0; i < GeneratedJavaParserConstants.tokenImage.length; i++) {
if (GeneratedJavaParserConstants.tokenImage[i].equals(expectedImage)) {
return i;
}
}
throw new RuntimeException(f("Attribute '%s' does not corresponding to any expected value. Text: %s", property.camelCaseName(), tokenText));
}
case VALUE:
if (node instanceof IntegerLiteralExpr) {
return GeneratedJavaParserConstants.INTEGER_LITERAL;
}
case NAME:
return GeneratedJavaParserConstants.IDENTIFIER;
}
throw new UnsupportedOperationException("getTokenType does not know how to handle property " + property + " with text: " + text);
| 254
| 374
| 628
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/concretesyntaxmodel/CsmConditional.java
|
CsmConditional
|
prettyPrint
|
class CsmConditional implements CsmElement {
private final Condition condition;
private final List<ObservableProperty> properties;
private final CsmElement thenElement;
private final CsmElement elseElement;
public Condition getCondition() {
return condition;
}
public ObservableProperty getProperty() {
if (properties.size() > 1) {
throw new IllegalStateException();
}
return properties.get(0);
}
public List<ObservableProperty> getProperties() {
return properties;
}
public CsmElement getThenElement() {
return thenElement;
}
public CsmElement getElseElement() {
return elseElement;
}
public enum Condition {
IS_EMPTY {
@Override
boolean evaluate(Node node, ObservableProperty property) {
NodeList<? extends Node> value = property.getValueAsMultipleReference(node);
return value == null || value.isEmpty();
}
}
, IS_NOT_EMPTY {
@Override
boolean evaluate(Node node, ObservableProperty property) {
NodeList<? extends Node> value = property.getValueAsMultipleReference(node);
return value != null && !value.isEmpty();
}
}
, IS_PRESENT {
@Override
boolean evaluate(Node node, ObservableProperty property) {
return !property.isNullOrNotPresent(node);
}
}
, FLAG {
@Override
boolean evaluate(Node node, ObservableProperty property) {
return property.getValueAsBooleanAttribute(node);
}
}
;
abstract boolean evaluate(Node node, ObservableProperty property);
}
public CsmConditional(ObservableProperty property, Condition condition, CsmElement thenElement, CsmElement elseElement) {
this.properties = Arrays.asList(property);
this.condition = condition;
this.thenElement = thenElement;
this.elseElement = elseElement;
}
public CsmConditional(List<ObservableProperty> properties, Condition condition, CsmElement thenElement, CsmElement elseElement) {
if (properties.size() < 1) {
throw new IllegalArgumentException();
}
this.properties = properties;
this.condition = condition;
this.thenElement = thenElement;
this.elseElement = elseElement;
}
public CsmConditional(ObservableProperty property, Condition condition, CsmElement thenElement) {
this(property, condition, thenElement, new CsmNone());
}
@Override
public void prettyPrint(Node node, SourcePrinter printer) {<FILL_FUNCTION_BODY>}
}
|
boolean test = false;
for (ObservableProperty prop : properties) {
test = test || condition.evaluate(node, prop);
}
if (test) {
thenElement.prettyPrint(node, printer);
} else {
elseElement.prettyPrint(node, printer);
}
| 685
| 79
| 764
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/concretesyntaxmodel/CsmList.java
|
CsmList
|
prettyPrint
|
class CsmList implements CsmElement {
private final ObservableProperty property;
private final CsmElement separatorPost;
private final CsmElement separatorPre;
private final CsmElement preceeding;
private final CsmElement following;
public ObservableProperty getProperty() {
return property;
}
public CsmElement getSeparatorPost() {
return separatorPost;
}
public CsmElement getSeparatorPre() {
return separatorPre;
}
public CsmElement getPreceeding() {
return preceeding;
}
public CsmElement getFollowing() {
return following;
}
public CsmList(ObservableProperty property, CsmElement separator) {
this(property, new CsmNone(), separator, new CsmNone(), new CsmNone());
}
public CsmList(ObservableProperty property) {
this(property, new CsmNone(), new CsmNone(), new CsmNone(), new CsmNone());
}
public CsmList(ObservableProperty property, CsmElement separatorPre, CsmElement separatorPost, CsmElement preceeding, CsmElement following) {
this.property = property;
this.separatorPre = separatorPre;
this.separatorPost = separatorPost;
this.preceeding = preceeding;
this.following = following;
}
@Override
public void prettyPrint(Node node, SourcePrinter printer) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return String.format("%s(property:%s)", this.getClass().getSimpleName(), getProperty());
}
}
|
if (property.isAboutNodes()) {
NodeList<? extends Node> nodeList = property.getValueAsMultipleReference(node);
if (nodeList == null) {
return;
}
if (!nodeList.isEmpty() && preceeding != null) {
preceeding.prettyPrint(node, printer);
}
for (int i = 0; i < nodeList.size(); i++) {
if (separatorPre != null && i != 0) {
separatorPre.prettyPrint(node, printer);
}
ConcreteSyntaxModel.genericPrettyPrint(nodeList.get(i), printer);
if (separatorPost != null && i != (nodeList.size() - 1)) {
separatorPost.prettyPrint(node, printer);
}
}
if (!nodeList.isEmpty() && following != null) {
following.prettyPrint(node, printer);
}
} else {
Collection<?> values = property.getValueAsCollection(node);
if (values == null) {
return;
}
if (!values.isEmpty() && preceeding != null) {
preceeding.prettyPrint(node, printer);
}
for (Iterator<?> it = values.iterator(); it.hasNext(); ) {
if (separatorPre != null && it.hasNext()) {
separatorPre.prettyPrint(node, printer);
}
printer.print(PrintingHelper.printToString(it.next()));
if (separatorPost != null && it.hasNext()) {
separatorPost.prettyPrint(node, printer);
}
}
if (!values.isEmpty() && following != null) {
following.prettyPrint(node, printer);
}
}
| 435
| 444
| 879
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/concretesyntaxmodel/CsmMix.java
|
CsmMix
|
equals
|
class CsmMix implements CsmElement {
private List<CsmElement> elements;
public CsmMix(List<CsmElement> elements) {
if (elements == null) {
throw new NullPointerException();
}
if (elements.stream().anyMatch(Objects::isNull)) {
throw new IllegalArgumentException("Null element in the mix");
}
this.elements = elements;
}
public List<CsmElement> getElements() {
return elements;
}
@Override
public void prettyPrint(Node node, SourcePrinter printer) {
elements.forEach(e -> e.prettyPrint(node, printer));
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return elements != null ? elements.hashCode() : 0;
}
@Override
public String toString() {
return elements.stream().map(e -> e.toString()).collect(Collectors.joining(",", "CsmMix[", "]"));
}
}
|
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
CsmMix csmMix = (CsmMix) o;
return elements != null ? elements.equals(csmMix.elements) : csmMix.elements == null;
| 280
| 82
| 362
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/concretesyntaxmodel/CsmOrphanCommentsEnding.java
|
CsmOrphanCommentsEnding
|
prettyPrint
|
class CsmOrphanCommentsEnding implements CsmElement {
@Override
public void prettyPrint(Node node, SourcePrinter printer) {<FILL_FUNCTION_BODY>}
}
|
List<Node> everything = new LinkedList<>();
everything.addAll(node.getChildNodes());
sortByBeginPosition(everything);
if (everything.isEmpty()) {
return;
}
int commentsAtEnd = 0;
boolean findingComments = true;
while (findingComments && commentsAtEnd < everything.size()) {
Node last = everything.get(everything.size() - 1 - commentsAtEnd);
findingComments = (last instanceof Comment);
if (findingComments) {
commentsAtEnd++;
}
}
for (int i = 0; i < commentsAtEnd; i++) {
Comment c = (Comment) everything.get(everything.size() - commentsAtEnd + i);
CsmComment.process(c, printer);
}
| 50
| 202
| 252
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/concretesyntaxmodel/CsmSingleReference.java
|
CsmSingleReference
|
prettyPrint
|
class CsmSingleReference implements CsmElement {
private final ObservableProperty property;
public ObservableProperty getProperty() {
return property;
}
public CsmSingleReference(ObservableProperty property) {
this.property = property;
}
@Override
public void prettyPrint(Node node, SourcePrinter printer) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return String.format("%s(property:%s)", this.getClass().getSimpleName(), getProperty());
}
}
|
Node child = property.getValueAsSingleReference(node);
if (child != null) {
ConcreteSyntaxModel.genericPrettyPrint(child, printer);
}
| 143
| 46
| 189
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/concretesyntaxmodel/CsmTextBlock.java
|
CsmTextBlock
|
prettyPrint
|
class CsmTextBlock implements CsmElement {
private final ObservableProperty property;
public CsmTextBlock(ObservableProperty property) {
this.property = property;
}
public ObservableProperty getProperty() {
return property;
}
@Override
public void prettyPrint(Node node, SourcePrinter printer) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return String.format("%s(property:%s)", this.getClass().getSimpleName(), getProperty());
}
}
|
printer.print("\"\"\"");
// Per https://openjdk.java.net/jeps/378#1--Line-terminators, any 'CRLF' and 'CR' are turned into 'LF' before interpreting the text
printer.println();
// TODO: Confirm if we need to force this to use {@code \n} separators
printer.print(property.getValueAsStringAttribute(node));
printer.print("\"\"\"");
| 143
| 115
| 258
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/concretesyntaxmodel/CsmToken.java
|
CsmToken
|
hashCode
|
class CsmToken implements CsmElement {
private final int tokenType;
private String content;
public int getTokenType() {
return tokenType;
}
public String getContent() {
return content;
}
public CsmToken(int tokenType) {
this.tokenType = tokenType;
this.content = GeneratedJavaParserConstants.tokenImage[tokenType];
if (content.startsWith("\"")) {
content = content.substring(1, content.length() - 1);
}
// Replace "raw" values with escaped textual counterparts (e.g. newlines {@code \r\n})
// and "placeholder" values ({@code <SPACE>}) with their textual counterparts
if (isEndOfLineToken(tokenType)) {
// Use the unescaped version
content = LineSeparator.lookupEscaped(this.content).get().asRawString();
} else if (isWhitespaceButNotEndOfLine(tokenType)) {
content = " ";
}
}
public CsmToken(int tokenType, String content) {
this.tokenType = tokenType;
this.content = content;
}
@Override
public void prettyPrint(Node node, SourcePrinter printer) {
if (isEndOfLineToken(tokenType)) {
printer.println();
} else {
printer.print(getContent());
}
}
@Override
public String toString() {
return String.format("%s(property:%s)", this.getClass().getSimpleName(), content);
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
CsmToken csmToken = (CsmToken) o;
if (tokenType != csmToken.tokenType)
return false;
if (content != null ? !content.equals(csmToken.content) : csmToken.content != null)
return false;
return true;
}
@Override
public int hashCode() {<FILL_FUNCTION_BODY>}
public boolean isWhiteSpace() {
return TokenTypes.isWhitespace(tokenType);
}
public boolean isWhiteSpaceNotEol() {
return isWhiteSpace() && !isNewLine();
}
public boolean isNewLine() {
return TokenTypes.isEndOfLineToken(tokenType);
}
/*
* Verifies if the content of the {@code CsmElement} is the same as the provided {@code TextElement}
*/
@Override
public boolean isCorrespondingElement(TextElement textElement) {
return (textElement instanceof TokenTextElement)
&& ((TokenTextElement)textElement).getTokenKind() == getTokenType()
&& ((TokenTextElement)textElement).getText().equals(getContent());
}
}
|
int result = tokenType;
result = 31 * result + (content != null ? content.hashCode() : 0);
return result;
| 760
| 40
| 800
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/concretesyntaxmodel/PrintingHelper.java
|
PrintingHelper
|
printToString
|
class PrintingHelper {
static String printToString(Object value) {<FILL_FUNCTION_BODY>}
}
|
if (value instanceof Stringable) {
return ((Stringable) value).asString();
}
if (value instanceof Enum) {
return ((Enum) value).name().toLowerCase();
} else {
if (value != null) {
return value.toString();
}
}
return "";
| 32
| 84
| 116
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/configuration/DefaultConfigurationOption.java
|
DefaultConfigurationOption
|
cast
|
class DefaultConfigurationOption implements ConfigurationOption {
ConfigOption configOption;
Object currentValue;
public DefaultConfigurationOption(ConfigOption configOption) {
this(configOption, null);
}
public DefaultConfigurationOption(ConfigOption configOption, Object value) {
this.configOption = configOption;
if (value != null)
value(value);
}
@Override
public boolean equals(Object o) {
if (o == null || !(o instanceof DefaultConfigurationOption))
return false;
DefaultConfigurationOption other = (DefaultConfigurationOption) o;
return configOption.equals(other.configOption);
}
@Override
public int hashCode() {
return configOption.hashCode();
}
/**
* Set a currentValue to an option
*/
@Override
public ConfigurationOption value(Object value) {
Utils.assertNotNull(value);
this.currentValue = value;
// verify the currentValue's type
if (!(configOption.type.isAssignableFrom(value.getClass()))) {
throw new IllegalArgumentException(String.format("%s is not an instance of %s", value, configOption.type.getName()));
}
return this;
}
/**
* returns True if the option has a currentValue
*/
@Override
public boolean hasValue() {
return this.currentValue != null;
}
/**
* returns the currentValue as an Integer
*/
@Override
public Integer asInteger() {
return cast();
}
/**
* returns the currentValue as a String
*/
@Override
public String asString() {
return cast();
}
/**
* returns the currentValue as a Boolean
*/
@Override
public Boolean asBoolean() {
return cast();
}
@Override
public <T extends Object> T asValue() {
return cast();
}
private <T extends Object> T cast() {<FILL_FUNCTION_BODY>}
}
|
if (!hasValue())
throw new IllegalArgumentException(String.format("The option %s has no currentValue", configOption.name()));
if (configOption.type.isAssignableFrom(currentValue.getClass()))
return (T) configOption.type.cast(currentValue);
throw new IllegalArgumentException(String.format("%s cannot be cast to %s", currentValue, configOption.type.getName()));
| 519
| 101
| 620
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/configuration/Indentation.java
|
Indentation
|
format
|
class Indentation {
public enum IndentType {
/**
* Indent with spaces.
*/
SPACES(' ', 1),
/**
* Indent with tabs as far as possible.
* For proper aligning, the tab width is necessary and by default 4.
*/
TABS('\t', 4),
/**
* Indent with tabs but align with spaces when wrapping and aligning
* method call chains and method call parameters.
*
* <p/><i>Example result:</i>
* <pre>
* class Foo {
*
* \tvoid bar() {
* \t\tfoo().bar()
* \t\t......baz(() -*> {
* \t\t..........\tboo().baa()
* \t\t..........\t......bee(a,
* \t\t..........\t..........b,
* \t\t..........\t..........c);
* \t\t..........})
* \t\t......bam();
* \t}
* }
* </pre>
*/
TABS_WITH_SPACE_ALIGN('\t', 4);
private Character car;
private int width;
private IndentType(Character c, int width) {
this.car = c;
this.width = width;
}
public Character getCar() {
return car;
}
public int getWidth() {
return width;
}
}
// default size
private static final int DEFAULT_SIZE = 4;
// type of the indentation
private IndentType type;
// size of the indentation (define how many spaces or tabs is used to indent)
private int size;
// formatted indentation
private String formattedIndentation = "";
/*
* Creates an Indentation with a type and size
*/
public Indentation(IndentType type, int size) {
this.type = type;
this.size = size;
format();
}
/*
* Creates an Indentation with the default size
*/
public Indentation(IndentType type) {
this(type, DEFAULT_SIZE);
}
/*
* set the size of the indentation (how many spaces or tabs?)
*/
public Indentation setSize(int size) {
this.size = size;
format();
return this;
}
public int getSize() {
return size;
}
/*
* set the type of the indentation (spaces, tabs...)
*/
public Indentation setType(IndentType type) {
this.type = type;
format();
return this;
}
public IndentType getType() {
return type;
}
/*
* returns the formatted string that represents the identification
*/
public String getIndent() {
return formattedIndentation;
}
// format the indentation string
private void format() {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return type.name() + " size=" + size;
}
}
|
StringBuilder indentString = new StringBuilder();
char indentChar = type.car;
for (int i = 0; i < size; i++) {
indentString.append(indentChar);
}
formattedIndentation = indentString.toString();
| 846
| 70
| 916
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/configuration/imports/DefaultImportOrderingStrategy.java
|
DefaultImportOrderingStrategy
|
sortImports
|
class DefaultImportOrderingStrategy implements ImportOrderingStrategy {
private boolean sortImportsAlphabetically = false;
@Override
public List<NodeList<ImportDeclaration>> sortImports(NodeList<ImportDeclaration> nodes) {<FILL_FUNCTION_BODY>}
@Override
public void setSortImportsAlphabetically(boolean sortImportsAlphabetically) {
this.sortImportsAlphabetically = sortImportsAlphabetically;
}
@Override
public boolean isSortImportsAlphabetically() {
return sortImportsAlphabetically;
}
}
|
if (sortImportsAlphabetically) {
Comparator<ImportDeclaration> sortLogic = comparingInt((ImportDeclaration i) -> i.isStatic() ? 0 : 1)
.thenComparing(NodeWithName::getNameAsString);
nodes.sort(sortLogic);
}
return Collections.singletonList(nodes);
| 149
| 91
| 240
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/configuration/imports/EclipseImportOrderingStrategy.java
|
EclipseImportOrderingStrategy
|
sortImports
|
class EclipseImportOrderingStrategy implements ImportOrderingStrategy {
private boolean sortImportsAlphabetically = false;
@Override
public List<NodeList<ImportDeclaration>> sortImports(NodeList<ImportDeclaration> nodes) {<FILL_FUNCTION_BODY>}
@Override
public void setSortImportsAlphabetically(boolean sortAlphabetically) {
sortImportsAlphabetically = sortAlphabetically;
}
@Override
public boolean isSortImportsAlphabetically() {
return sortImportsAlphabetically;
}
}
|
NodeList<ImportDeclaration> staticImports = new NodeList<>();
NodeList<ImportDeclaration> javaImports = new NodeList<>();
NodeList<ImportDeclaration> javaXImports = new NodeList<>();
NodeList<ImportDeclaration> orgImports = new NodeList<>();
NodeList<ImportDeclaration> comImports = new NodeList<>();
NodeList<ImportDeclaration> otherImports = new NodeList<>();
for (ImportDeclaration importDeclaration : nodes) {
// Check if is a static import
if (importDeclaration.isStatic()) {
staticImports.add(importDeclaration);
continue;
}
String importName = importDeclaration.getNameAsString();
if (importName.startsWith("java.")) {
javaImports.add(importDeclaration);
} else if (importName.startsWith("javax.")) {
javaXImports.add(importDeclaration);
} else if (importName.startsWith("org.")) {
orgImports.add(importDeclaration);
} else if (importName.startsWith("com.")) {
comImports.add(importDeclaration);
} else {
otherImports.add(importDeclaration);
}
}
if (sortImportsAlphabetically) {
Comparator<ImportDeclaration> sortLogic = Comparator.comparing(NodeWithName::getNameAsString);
staticImports.sort(sortLogic);
javaImports.sort(sortLogic);
javaXImports.sort(sortLogic);
orgImports.sort(sortLogic);
comImports.sort(sortLogic);
otherImports.sort(sortLogic);
}
return Arrays.asList(staticImports, javaImports, javaXImports, orgImports, comImports, otherImports);
| 144
| 460
| 604
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/configuration/imports/IntelliJImportOrderingStrategy.java
|
IntelliJImportOrderingStrategy
|
sortImports
|
class IntelliJImportOrderingStrategy implements ImportOrderingStrategy {
private boolean sortImportsAlphabetically = false;
@Override
public List<NodeList<ImportDeclaration>> sortImports(NodeList<ImportDeclaration> nodes) {<FILL_FUNCTION_BODY>}
@Override
public void setSortImportsAlphabetically(boolean sortAlphabetically) {
sortImportsAlphabetically = sortAlphabetically;
}
@Override
public boolean isSortImportsAlphabetically() {
return sortImportsAlphabetically;
}
}
|
NodeList<ImportDeclaration> otherImports = new NodeList<>();
NodeList<ImportDeclaration> javaImports = new NodeList<>();
NodeList<ImportDeclaration> staticImports = new NodeList<>();
for (ImportDeclaration importDeclaration : nodes) {
// Check if is a static import
if (importDeclaration.isStatic()) {
staticImports.add(importDeclaration);
continue;
}
String importName = importDeclaration.getNameAsString();
if (importName.startsWith("java.") || importName.startsWith("javax.")) {
javaImports.add(importDeclaration);
} else {
otherImports.add(importDeclaration);
}
}
if (sortImportsAlphabetically) {
Comparator<ImportDeclaration> sortLogic = Comparator.comparing(NodeWithName::getNameAsString);
otherImports.sort(sortLogic);
javaImports.sort(sortLogic);
staticImports.sort(sortLogic);
}
return Arrays.asList(otherImports, javaImports, staticImports);
| 145
| 283
| 428
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Added.java
|
Added
|
toTextElement
|
class Added implements DifferenceElement {
private final CsmElement element;
Added(CsmElement element) {
this.element = element;
}
@Override
public String toString() {
return "Added{" + element + '}';
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Added added = (Added) o;
return element.equals(added.element);
}
@Override
public int hashCode() {
return element.hashCode();
}
@Override
public CsmElement getElement() {
return element;
}
@Override
public boolean isAdded() {
return true;
}
@Override
public boolean isRemoved() {
return false;
}
@Override
public boolean isKept() {
return false;
}
public boolean isIndent() {
return element instanceof CsmIndent;
}
public boolean isUnindent() {
return element instanceof CsmUnindent;
}
private boolean isToken() {
return element instanceof CsmToken;
}
public TextElement toTextElement() {<FILL_FUNCTION_BODY>}
/*
* If the {@code DifferenceElement} wraps an EOL token then this method returns a new wrapped {@code CsmElement}
* with the specified line separator. The line separator parameter must be a CsmToken with a valid line separator.
*/
@Override
public DifferenceElement replaceEolTokens(CsmElement lineSeparator) {
return isNewLine() ? new Added(lineSeparator) : this;
}
/*
* Return true if the wrapped {@code CsmElement} is a new line token
*/
public boolean isNewLine() {
return isToken() && ((CsmToken) element).isNewLine();
}
}
|
if (element instanceof LexicalDifferenceCalculator.CsmChild) {
return new ChildTextElement(((LexicalDifferenceCalculator.CsmChild) element).getChild());
}
if (element instanceof CsmToken) {
return new TokenTextElement(((CsmToken) element).getTokenType(), ((CsmToken) element).getContent());
}
throw new UnsupportedOperationException("Unsupported element type: " + element.getClass().getSimpleName());
| 513
| 119
| 632
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/ChildTextElement.java
|
ChildTextElement
|
equals
|
class ChildTextElement extends TextElement {
private final Node child;
ChildTextElement(Node child) {
this.child = child;
}
@Override
public String expand() {
return LexicalPreservingPrinter.print(child);
}
public Node getChild() {
return child;
}
@Override
public boolean isToken(int tokenKind) {
return false;
}
@Override
public boolean isNode(Node node) {
return node == child;
}
NodeText getNodeTextForWrappedNode() {
return LexicalPreservingPrinter.getOrCreateNodeText(child);
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return child.hashCode();
}
@Override
public String toString() {
return "ChildTextElement{" + child + '}';
}
@Override
public boolean isWhiteSpace() {
return false;
}
@Override
public boolean isSpaceOrTab() {
return false;
}
@Override
public boolean isNewline() {
return false;
}
@Override
public boolean isComment() {
return child instanceof Comment;
}
@Override
public boolean isSeparator() {
return false;
}
@Override
public boolean isIdentifier() {
return false;
}
@Override
public boolean isKeyword() {
return false;
}
@Override
public boolean isPrimitive() {
return false;
}
@Override
public boolean isLiteral() {
return false;
}
@Override
public boolean isChildOfClass(Class<? extends Node> nodeClass) {
return nodeClass.isInstance(child);
}
@Override
Optional<Range> getRange() {
return child.getRange();
}
@Override
public void accept(LexicalPreservingVisitor visitor) {
NodeText nodeText = getNodeTextForWrappedNode();
nodeText.getElements().forEach(element -> element.accept(visitor));
}
}
|
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
ChildTextElement that = (ChildTextElement) o;
return child.equals(that.child);
| 574
| 64
| 638
|
<methods>public non-sealed void <init>() ,public boolean isChild() ,public abstract boolean isChildOfClass(Class<? extends com.github.javaparser.ast.Node>) ,public abstract boolean isComment() ,public abstract boolean isIdentifier() ,public abstract boolean isKeyword() ,public abstract boolean isLiteral() ,public abstract boolean isNewline() ,public abstract boolean isPrimitive() ,public abstract boolean isSeparator() ,public abstract boolean isSpaceOrTab() ,public abstract boolean isWhiteSpace() ,public final boolean isWhiteSpaceOrComment() ,public boolean match(com.github.javaparser.printer.lexicalpreservation.TextElement) <variables>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Kept.java
|
Kept
|
isWhiteSpaceOrComment
|
class Kept implements DifferenceElement {
private final CsmElement element;
Kept(CsmElement element) {
this.element = element;
}
@Override
public String toString() {
return "Kept{" + element + '}';
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Kept kept = (Kept) o;
return element.equals(kept.element);
}
@Override
public int hashCode() {
return element.hashCode();
}
@Override
public CsmElement getElement() {
return element;
}
public int getTokenType() {
if (isToken()) {
CsmToken csmToken = (CsmToken) element;
return csmToken.getTokenType();
}
throw new IllegalStateException("Kept is not a " + CsmToken.class.getSimpleName());
}
@Override
public boolean isAdded() {
return false;
}
@Override
public boolean isRemoved() {
return false;
}
@Override
public boolean isKept() {
return true;
}
public boolean isIndent() {
return element instanceof CsmIndent;
}
public boolean isUnindent() {
return element instanceof CsmUnindent;
}
public boolean isToken() {
return element instanceof CsmToken;
}
public boolean isPrimitiveType() {
if (isChild()) {
LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) element;
return csmChild.getChild() instanceof PrimitiveType;
}
return false;
}
public boolean isWhiteSpace() {
if (isToken()) {
CsmToken csmToken = (CsmToken) element;
return csmToken.isWhiteSpace();
}
return false;
}
public boolean isWhiteSpaceOrComment() {<FILL_FUNCTION_BODY>}
public boolean isNewLine() {
if (isToken()) {
CsmToken csmToken = (CsmToken) element;
return csmToken.isNewLine();
}
return false;
}
}
|
if (isToken()) {
CsmToken csmToken = (CsmToken) element;
return TokenTypes.isWhitespaceOrComment(csmToken.getTokenType());
}
return false;
| 618
| 57
| 675
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/NodeText.java
|
NodeText
|
findElement
|
class NodeText {
private final List<TextElement> elements;
public static final int NOT_FOUND = -1;
//
// Constructors
//
NodeText(List<TextElement> elements) {
this.elements = elements;
}
/**
* Initialize with an empty list of elements.
*/
NodeText() {
this(new LinkedList<>());
}
//
// Adding elements
//
/**
* Add an element at the end.
*/
void addElement(TextElement nodeTextElement) {
this.elements.add(nodeTextElement);
}
/**
* Add an element at the given position.
*/
void addElement(int index, TextElement nodeTextElement) {
this.elements.add(index, nodeTextElement);
}
void addChild(Node child) {
addElement(new ChildTextElement(child));
}
void addChild(int index, Node child) {
addElement(index, new ChildTextElement(child));
}
void addToken(int tokenKind, String text) {
elements.add(new TokenTextElement(tokenKind, text));
}
void addToken(int index, int tokenKind, String text) {
elements.add(index, new TokenTextElement(tokenKind, text));
}
//
// Finding elements
//
int findElement(TextElementMatcher matcher) {
return findElement(matcher, 0);
}
int findElement(TextElementMatcher matcher, int from) {<FILL_FUNCTION_BODY>}
int tryToFindElement(TextElementMatcher matcher, int from) {
for (int i = from; i < elements.size(); i++) {
TextElement element = elements.get(i);
if (matcher.match(element)) {
return i;
}
}
return NOT_FOUND;
}
int findChild(Node child) {
return findChild(child, 0);
}
int findChild(Node child, int from) {
return findElement(TextElementMatchers.byNode(child), from);
}
int tryToFindChild(Node child) {
return tryToFindChild(child, 0);
}
int tryToFindChild(Node child, int from) {
return tryToFindElement(TextElementMatchers.byNode(child), from);
}
//
// Removing single elements
//
public void remove(TextElementMatcher matcher, boolean potentiallyFollowingWhitespace) {
int i = 0;
for (TextElement e : elements) {
if (matcher.match(e)) {
elements.remove(e);
if (potentiallyFollowingWhitespace) {
if (i < elements.size()) {
if (elements.get(i).isWhiteSpace()) {
elements.remove(i);
}
} else {
throw new UnsupportedOperationException("There is no element to remove!");
}
}
return;
}
}
throw new IllegalArgumentException();
}
//
// Removing sequences
//
void removeElement(int index) {
elements.remove(index);
}
//
// Replacing elements
//
void replace(TextElementMatcher position, TextElement newElement) {
int index = findElement(position, 0);
elements.remove(index);
elements.add(index, newElement);
}
//
// Other methods
//
/**
* Generate the corresponding string.
*/
String expand() {
StringBuffer sb = new StringBuffer();
elements.forEach(e -> sb.append(e.expand()));
return sb.toString();
}
// Visible for testing
int numberOfElements() {
return elements.size();
}
// Visible for testing
TextElement getTextElement(int index) {
return elements.get(index);
}
// Visible for testing
List<TextElement> getElements() {
return elements;
}
@Override
public String toString() {
return "NodeText{" + elements + '}';
}
}
|
int res = tryToFindElement(matcher, from);
if (res == NOT_FOUND) {
throw new IllegalArgumentException(String.format("I could not find child '%s' from position %d. Elements: %s", matcher, from, elements));
}
return res;
| 1,100
| 75
| 1,175
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/PeekingIterator.java
|
PeekingIterator
|
fill
|
class PeekingIterator<E> implements ListIterator<E>, LookaheadIterator<E> {
/** The iterator being decorated. */
private final ListIterator<E> iterator;
/** Indicates that the decorated iterator is exhausted. */
private boolean exhausted;
/** Indicates if the lookahead slot is filled. */
private boolean slotFilled;
/** The current slot for lookahead. */
private E slot;
/**
* Decorates the specified iterator to support one-element lookahead.
* <p>
* If the iterator is already a {@link PeekingIterator} it is returned directly.
*
* @param <E> the element type
* @param iterator the iterator to decorate
* @return a new peeking iterator
* @throws NullPointerException if the iterator is null
*/
public <E> PeekingIterator<E> peekingIterator(final ListIterator<E> iterator) {
Objects.requireNonNull(iterator, "iterator");
if (iterator instanceof PeekingIterator<?>) {
final PeekingIterator<E> it = (PeekingIterator<E>) iterator;
return it;
}
return new PeekingIterator<>(iterator);
}
/**
* Constructor.
*
* @param iterator the iterator to decorate
*/
public PeekingIterator(final ListIterator<E> iterator) {
this.iterator = iterator;
}
/**
* Constructor.
*
* @param list the provider of the iterator to decorate
*/
public PeekingIterator(final List<E> list) {
this.iterator = list.listIterator();
}
private void fill() {<FILL_FUNCTION_BODY>}
@Override
public boolean hasNext() {
if (exhausted) {
return false;
}
return slotFilled || iterator.hasNext();
}
/**
* Returns the next element in iteration without advancing the underlying iterator.
* If the iterator is already exhausted, null will be returned.
* <p>
* Note: this method does not throw a {@link NoSuchElementException} if the iterator
* is already exhausted. If you want such a behavior, use {@link #element()} instead.
* <p>
* The rationale behind this is to follow the {@link java.util.Queue} interface
* which uses the same terminology.
*
* @return the next element from the iterator
*/
@Override
public E peek() {
fill();
return exhausted ? null : slot;
}
/**
* Returns the next element in iteration without advancing the underlying iterator.
* If the iterator is already exhausted, null will be returned.
*
* @return the next element from the iterator
* @throws NoSuchElementException if the iterator is already exhausted according to {@link #hasNext()}
*/
@Override
public E element() {
fill();
if (exhausted) {
throw new NoSuchElementException();
}
return slot;
}
@Override
public E next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
final E x = slotFilled ? slot : iterator.next();
// reset the lookahead slot
slot = null;
slotFilled = false;
return x;
}
/**
* {@inheritDoc}
*
* @throws IllegalStateException if {@link #peek()} or {@link #element()} has been called
* prior to the call to {@link #remove()}
*/
@Override
public void remove() {
if (slotFilled) {
throw new IllegalStateException("peek() or element() called before remove()");
}
iterator.remove();
}
@Override
public boolean hasPrevious() {
return iterator.hasPrevious();
}
@Override
public E previous() {
return iterator.previous();
}
@Override
public int nextIndex() {
return iterator.nextIndex();
}
/*
* Returns the index of the element that would be returned by the last call to next.
* Returns list size - 1 if the listiterator is at the end of the list.
* Returns -1 if the listiterator is at the beginning of the list.
*/
public int currentIndex() {
if (!hasPrevious()) return previousIndex();
return nextIndex() - 1;
}
@Override
public int previousIndex() {
return iterator.previousIndex();
}
@Override
public void set(E e) {
if (slotFilled) {
throw new IllegalStateException("peek() or element() called before set()");
}
iterator.set(e);
}
@Override
public void add(E e) {
if (slotFilled) {
throw new IllegalStateException("peek() or element() called before add()");
}
iterator.add(e);
}
}
|
if (exhausted || slotFilled) {
return;
}
if (iterator.hasNext()) {
slot = iterator.next();
slotFilled = true;
} else {
exhausted = true;
slot = null;
slotFilled = false;
}
| 1,474
| 90
| 1,564
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/PhantomNodeLogic.java
|
PhantomNodeLogic
|
inPhantomNode
|
class PhantomNodeLogic {
private static final int LEVELS_TO_EXPLORE = 3;
private static final Map<Node, Boolean> isPhantomNodeCache = synchronizedMap(new IdentityHashMap<>());
private static final AstObserver cacheCleaner = new AstObserverAdapter() {
@Override
public void parentChange(Node observedNode, Node previousParent, Node newParent) {
isPhantomNodeCache.remove(observedNode);
}
};
static boolean isPhantomNode(Node node) {
if (isPhantomNodeCache.containsKey(node)) {
return isPhantomNodeCache.get(node);
}
if (node instanceof UnknownType) {
return true;
}
boolean res = (node.getParentNode().isPresent() && node.getParentNode().get().hasRange() && node.hasRange() && !node.getParentNode().get().getRange().get().contains(node.getRange().get()) || inPhantomNode(node, LEVELS_TO_EXPLORE));
isPhantomNodeCache.put(node, res);
node.register(cacheCleaner);
return res;
}
/**
* A node contained in a phantom node is also a phantom node. We limit how many levels up we check just for performance reasons.
*/
private static boolean inPhantomNode(Node node, int levels) {<FILL_FUNCTION_BODY>}
/**
* Clean up the cache used by the LexicalPreserving logic. This should only be used once you're done printing all parsed data with
* a JavaParser's configuration setLexicalPreservationEnabled=true.
*/
public static void cleanUpCache() {
isPhantomNodeCache.clear();
}
}
|
return node.getParentNode().isPresent() && (isPhantomNode(node.getParentNode().get()) || inPhantomNode(node.getParentNode().get(), levels - 1));
| 453
| 51
| 504
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Removed.java
|
Removed
|
isWhiteSpaceNotEol
|
class Removed implements DifferenceElement {
private final CsmElement element;
Removed(CsmElement element) {
this.element = element;
}
@Override
public String toString() {
return "Removed{" + element + '}';
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Removed removed = (Removed) o;
return element.equals(removed.element);
}
@Override
public int hashCode() {
return element.hashCode();
}
@Override
public CsmElement getElement() {
return element;
}
public Node getChild() {
if (isChild()) {
LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) element;
return csmChild.getChild();
}
throw new IllegalStateException("Removed is not a " + LexicalDifferenceCalculator.CsmChild.class.getSimpleName());
}
public int getTokenType() {
if (isToken()) {
CsmToken csmToken = (CsmToken) element;
return csmToken.getTokenType();
}
throw new IllegalStateException("Removed is not a " + CsmToken.class.getSimpleName());
}
@Override
public boolean isAdded() {
return false;
}
@Override
public boolean isRemoved() {
return true;
}
@Override
public boolean isKept() {
return false;
}
public boolean isToken() {
return element instanceof CsmToken;
}
public boolean isPrimitiveType() {
if (isChild()) {
LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) element;
return csmChild.getChild() instanceof PrimitiveType;
}
return false;
}
public boolean isWhiteSpace() {
if (isToken()) {
CsmToken csmToken = (CsmToken) element;
return csmToken.isWhiteSpace();
}
return false;
}
public boolean isWhiteSpaceNotEol() {<FILL_FUNCTION_BODY>}
public boolean isNewLine() {
if (isToken()) {
CsmToken csmToken = (CsmToken) element;
return csmToken.isNewLine();
}
return false;
}
}
|
if (isToken()) {
CsmToken csmToken = (CsmToken) element;
return csmToken.isWhiteSpaceNotEol();
}
return false;
| 670
| 49
| 719
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/Reshuffled.java
|
Reshuffled
|
hashCode
|
class Reshuffled implements DifferenceElement {
private final CsmMix previousOrder;
private final CsmMix nextOrder;
Reshuffled(CsmMix previousOrder, CsmMix nextOrder) {
this.previousOrder = previousOrder;
this.nextOrder = nextOrder;
}
@Override
public String toString() {
return "Reshuffled{" + nextOrder + ", previous=" + previousOrder + '}';
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Reshuffled that = (Reshuffled) o;
if (!previousOrder.equals(that.previousOrder))
return false;
return nextOrder.equals(that.nextOrder);
}
@Override
public int hashCode() {<FILL_FUNCTION_BODY>}
@Override
public CsmMix getElement() {
return nextOrder;
}
public CsmMix getPreviousOrder() {
return previousOrder;
}
public CsmMix getNextOrder() {
return nextOrder;
}
@Override
public boolean isAdded() {
return false;
}
@Override
public boolean isRemoved() {
return false;
}
@Override
public boolean isKept() {
return false;
}
/*
* If the {@code DifferenceElement} wraps an EOL token then this method returns a new {@code DifferenceElement}
* with all eof token replaced by the specified line separator. The line separator parameter must be a CsmToken with a valid line separator.
*/
@Override
public DifferenceElement replaceEolTokens(CsmElement lineSeparator) {
CsmMix modifiedNextOrder = new CsmMix(replaceTokens(nextOrder.getElements(), lineSeparator));
CsmMix modifiedPreviousOrder = new CsmMix(replaceTokens(previousOrder.getElements(), lineSeparator));
return new Reshuffled(modifiedPreviousOrder, modifiedNextOrder);
}
/*
* Replaces all eol tokens in the list by the specified line separator token
*/
private List<CsmElement> replaceTokens(List<CsmElement> elements, CsmElement lineSeparator) {
return elements.stream().map(element -> isNewLineToken(element) ? lineSeparator : element).collect(Collectors.toList());
}
/*
* Return true if the wrapped {@code CsmElement} is a new line token
*/
private boolean isNewLineToken(CsmElement element) {
return isToken(element) && ((CsmToken) element).isNewLine();
}
private boolean isToken(CsmElement element) {
return element instanceof CsmToken;
}
}
|
int result = previousOrder.hashCode();
result = 31 * result + nextOrder.hashCode();
return result;
| 731
| 34
| 765
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/TextElement.java
|
TextElement
|
matchByRange
|
class TextElement implements TextElementMatcher, PrintableTextElement {
abstract String expand();
abstract boolean isToken(int tokenKind);
final boolean isCommentToken() {
return isToken(GeneratedJavaParserConstants.JAVADOC_COMMENT) || isToken(GeneratedJavaParserConstants.SINGLE_LINE_COMMENT) || isToken(GeneratedJavaParserConstants.MULTI_LINE_COMMENT);
}
@Override
public boolean match(TextElement textElement) {
return this.equals(textElement);
}
abstract boolean isNode(Node node);
public abstract boolean isLiteral();
public abstract boolean isWhiteSpace();
public abstract boolean isSpaceOrTab();
public abstract boolean isNewline();
public abstract boolean isComment();
public abstract boolean isSeparator();
public abstract boolean isIdentifier();
public abstract boolean isKeyword();
public abstract boolean isPrimitive();
public final boolean isWhiteSpaceOrComment() {
return isWhiteSpace() || isComment();
}
/**
* Is this TextElement representing a child of the given class?
*/
public abstract boolean isChildOfClass(Class<? extends Node> nodeClass);
public boolean isChild() {
return isChildOfClass(Node.class);
}
abstract Optional<Range> getRange();
/**
* Creates a {@link TextElementMatcher} that matches any TextElement with the same range as this TextElement.<br>
* This can be used to curry another TextElementMatcher.<br>
* e.g. {@code someTextElementMatcher.and(textElement.matchByRange());}
*
* @return TextElementMatcher that matches any TextElement with the same Range
*/
TextElementMatcher matchByRange() {<FILL_FUNCTION_BODY>}
}
|
return (TextElement textElement) -> getRange().flatMap(r1 -> textElement.getRange().map(r1::equals)).// We're missing range information. This may happen when a node is manually instantiated. Don't be too harsh on that:
orElse(true);
| 461
| 73
| 534
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/TextElementIteratorsFactory.java
|
ComposedIterator
|
reverseIterator
|
class ComposedIterator<E> implements Iterator<E> {
private final List<Iterator<E>> elements;
private int currIndex;
ComposedIterator(List<Iterator<E>> elements) {
this.elements = elements;
currIndex = 0;
}
@Override
public boolean hasNext() {
if (currIndex >= elements.size()) {
return false;
}
if (elements.get(currIndex).hasNext()) {
return true;
}
currIndex++;
return hasNext();
}
@Override
public E next() {
if (!hasNext()) {
throw new IllegalArgumentException();
}
return elements.get(currIndex).next();
}
@Override
public void remove() {
elements.get(currIndex).remove();
}
}
private static Iterator<TokenTextElement> reverseIterator(NodeText nodeText, int index) {<FILL_FUNCTION_BODY>
|
TextElement textElement = nodeText.getTextElement(index);
if (textElement instanceof TokenTextElement) {
return new SingleElementIterator<TokenTextElement>((TokenTextElement) textElement) {
@Override
public void remove() {
nodeText.removeElement(index);
}
};
}
if (textElement instanceof ChildTextElement) {
ChildTextElement childTextElement = (ChildTextElement) textElement;
NodeText textForChild = childTextElement.getNodeTextForWrappedNode();
return reverseIterator(textForChild);
}
throw new IllegalArgumentException();
| 257
| 152
| 409
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/TextElementMatchers.java
|
TextElementMatchers
|
byNode
|
class TextElementMatchers {
static TextElementMatcher byTokenType(int tokenType) {
return textElement -> textElement.isToken(tokenType);
}
static TextElementMatcher byNode(final Node node) {<FILL_FUNCTION_BODY>}
}
|
return new TextElementMatcher() {
@Override
public boolean match(TextElement textElement) {
return textElement.isNode(node);
}
@Override
public String toString() {
return "match node " + node;
}
};
| 73
| 73
| 146
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/TokenTextElement.java
|
TokenTextElement
|
equals
|
class TokenTextElement extends TextElement {
private final JavaToken token;
TokenTextElement(JavaToken token) {
this.token = token;
}
TokenTextElement(int tokenKind, String text) {
this(new JavaToken(tokenKind, text));
}
TokenTextElement(int tokenKind) {
this(new JavaToken(tokenKind));
}
@Override
public String expand() {
return token.getText();
}
// Visible for testing
public String getText() {
return token.getText();
}
public int getTokenKind() {
return token.getKind();
}
public JavaToken getToken() {
return token;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return token.hashCode();
}
@Override
public String toString() {
return token.toString();
}
@Override
boolean isToken(int tokenKind) {
return token.getKind() == tokenKind;
}
@Override
boolean isNode(Node node) {
return false;
}
@Override
public boolean isWhiteSpace() {
return token.getCategory().isWhitespace();
}
@Override
public boolean isSpaceOrTab() {
return token.getCategory().isWhitespaceButNotEndOfLine();
}
@Override
public boolean isComment() {
return token.getCategory().isComment();
}
@Override
public boolean isSeparator() {
return token.getCategory().isSeparator();
}
@Override
public boolean isNewline() {
return token.getCategory().isEndOfLine();
}
@Override
public boolean isChildOfClass(Class<? extends Node> nodeClass) {
return false;
}
@Override
public boolean isIdentifier() {
return getToken().getCategory().isIdentifier();
}
@Override
public boolean isKeyword() {
return getToken().getCategory().isKeyword();
}
@Override
public boolean isLiteral() {
return getToken().getCategory().isLiteral();
}
@Override
public boolean isPrimitive() {
return Kind.valueOf(getTokenKind()).isPrimitive();
}
@Override
Optional<Range> getRange() {
return token.getRange();
}
@Override
public void accept(LexicalPreservingVisitor visitor) {
visitor.visit(this);
}
}
|
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
TokenTextElement that = (TokenTextElement) o;
return token.equals(that.token);
| 680
| 65
| 745
|
<methods>public non-sealed void <init>() ,public boolean isChild() ,public abstract boolean isChildOfClass(Class<? extends com.github.javaparser.ast.Node>) ,public abstract boolean isComment() ,public abstract boolean isIdentifier() ,public abstract boolean isKeyword() ,public abstract boolean isLiteral() ,public abstract boolean isNewline() ,public abstract boolean isPrimitive() ,public abstract boolean isSeparator() ,public abstract boolean isSpaceOrTab() ,public abstract boolean isWhiteSpace() ,public final boolean isWhiteSpaceOrComment() ,public boolean match(com.github.javaparser.printer.lexicalpreservation.TextElement) <variables>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/changes/ListAdditionChange.java
|
ListAdditionChange
|
getValue
|
class ListAdditionChange implements Change {
private final ObservableProperty observableProperty;
private final int index;
private final Node nodeAdded;
public ListAdditionChange(ObservableProperty observableProperty, int index, Node nodeAdded) {
this.observableProperty = observableProperty;
this.index = index;
this.nodeAdded = nodeAdded;
}
@Override
public Object getValue(ObservableProperty property, Node node) {<FILL_FUNCTION_BODY>}
@Override
public ObservableProperty getProperty() {
return observableProperty;
}
}
|
if (property == observableProperty) {
Object currentRawValue = new NoChange().getValue(property, node);
if (currentRawValue instanceof Optional) {
Optional<?> optional = (Optional<?>) currentRawValue;
currentRawValue = optional.orElse(null);
}
if (!(currentRawValue instanceof NodeList)) {
throw new IllegalStateException("Expected NodeList, found " + currentRawValue.getClass().getCanonicalName());
}
NodeList<Node> currentNodeList = (NodeList<Node>) currentRawValue;
// Note: When adding to a node list children get assigned the list's parent, thus we must set the list's parent before adding children (#2592).
NodeList<Node> newNodeList = new NodeList<>();
newNodeList.setParentNode(currentNodeList.getParentNodeForChildren());
newNodeList.addAll(currentNodeList);
// Perform modification -- add to the list
newNodeList.add(index, nodeAdded);
return newNodeList;
}
return new NoChange().getValue(property, node);
| 148
| 275
| 423
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/changes/ListRemovalChange.java
|
ListRemovalChange
|
getValue
|
class ListRemovalChange implements Change {
private final ObservableProperty observableProperty;
private final int index;
public ListRemovalChange(ObservableProperty observableProperty, int index) {
this.observableProperty = observableProperty;
this.index = index;
}
@Override
public Object getValue(ObservableProperty property, Node node) {<FILL_FUNCTION_BODY>}
private boolean isSameNode(Node n1, Node n2) {
return n1.equals(n2) && isSameRange(n1, n2);
}
private boolean isSameRange(Node n1, Node n2) {
return (!n1.hasRange() && !n2.hasRange())
|| (n1.hasRange() && n2.hasRange() && isSameRange(n1.getRange().get(), n2.getRange().get()));
}
private boolean isSameRange(Range r1, Range r2) {
return r1.equals(r2);
}
@Override
public ObservableProperty getProperty() {
return observableProperty;
}
}
|
if (property == observableProperty) {
Object currentRawValue = new NoChange().getValue(property, node);
if (currentRawValue instanceof Optional) {
Optional<?> optional = (Optional<?>) currentRawValue;
currentRawValue = optional.orElse(null);
}
if (!(currentRawValue instanceof NodeList)) {
throw new IllegalStateException("Expected NodeList, found " + currentRawValue.getClass().getCanonicalName());
}
NodeList<Node> currentNodeList = (NodeList<Node>) currentRawValue;
// Note: When adding to a node list children get assigned the list's parent, thus we must set the list's parent before adding children (#2592).
NodeList<Node> newNodeList = new NodeList<>();
// fix #2187 set the parent node in the new list
newNodeList.setParentNode(currentNodeList.getParentNodeForChildren());
// Here we want to obtain a sub-list that does not contain an element.
// It is important not to implement this by first adding all the elements in the
// list and then deleting the element to be removed, as this involves event
// propagation mechanisms, particularly for lexical preservation,
// which deletes the relationship between a node and its parent node.
// This relationship is necessary to reinforce indentation, for example when
// deleting a node, as indentation can be carried by the parent node.
currentNodeList.stream().filter(n -> !isSameNode(currentNodeList.get(index),n))
.forEach(selectedNode -> newNodeList.add(selectedNode));
return newNodeList;
}
return new NoChange().getValue(property, node);
| 278
| 420
| 698
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/changes/ListReplacementChange.java
|
ListReplacementChange
|
getValue
|
class ListReplacementChange implements Change {
private final ObservableProperty observableProperty;
private final int index;
private final Node newValue;
public ListReplacementChange(ObservableProperty observableProperty, int index, Node newValue) {
this.observableProperty = observableProperty;
this.index = index;
this.newValue = newValue;
}
@Override
public Object getValue(ObservableProperty property, Node node) {<FILL_FUNCTION_BODY>}
@Override
public ObservableProperty getProperty() {
return observableProperty;
}
}
|
if (property == observableProperty) {
Object currentRawValue = new NoChange().getValue(property, node);
if (currentRawValue instanceof Optional) {
Optional<?> optional = (Optional<?>) currentRawValue;
currentRawValue = optional.orElse(null);
}
if (!(currentRawValue instanceof NodeList)) {
throw new IllegalStateException("Expected NodeList, found " + currentRawValue.getClass().getCanonicalName());
}
NodeList<Node> currentNodeList = (NodeList<Node>) currentRawValue;
// Note: When adding to a node list children get assigned the list's parent, thus we must set the list's parent before adding children (#2592).
NodeList<Node> newNodeList = new NodeList<>();
newNodeList.setParentNode(currentNodeList.getParentNodeForChildren());
newNodeList.addAll(currentNodeList);
// Perform modification -- replace an item in the list
newNodeList.set(index, newValue);
return newNodeList;
}
return new NoChange().getValue(property, node);
| 149
| 277
| 426
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/changes/PropertyChange.java
|
PropertyChange
|
getValue
|
class PropertyChange implements Change {
private final ObservableProperty property;
private final Object oldValue;
private final Object newValue;
public PropertyChange(ObservableProperty property, Object oldValue, Object newValue) {
this.property = property;
this.oldValue = oldValue;
this.newValue = newValue;
}
@Override
public ObservableProperty getProperty() {
return property;
}
public Object getOldValue() {
return oldValue;
}
public Object getNewValue() {
return newValue;
}
@Override
public Object getValue(ObservableProperty property, Node node) {<FILL_FUNCTION_BODY>}
}
|
if (property == this.property) {
return newValue;
}
return property.getRawValue(node);
| 182
| 34
| 216
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/UnsolvedSymbolException.java
|
UnsolvedSymbolException
|
toString
|
class UnsolvedSymbolException extends RuntimeException {
/**
* The name of the symbol that could not be resolved.
*/
private String name;
/**
* Additional information that provides more details on the context that a symbol could not be resolved in, or
* {@code null} if there is no contextual information, or if the contextual information is unknown.
*/
private String context;
/**
* The throwable that caused this {@code UnsolvedSymbolException} to get thrown, or {@code null} if this
* {@code UnsolvedSymbolException} was not caused by another throwable, or if the causative throwable is unknown.
*/
private Throwable cause;
public UnsolvedSymbolException(String name) {
this(name, null, null);
}
public UnsolvedSymbolException(String name, String context) {
this(name, context, null);
}
public UnsolvedSymbolException(String name, Throwable cause) {
this(name, null, cause);
}
public UnsolvedSymbolException(String name, String context, Throwable cause) {
super("Unsolved symbol" + (context != null ? " in " + context : "") + " : " + name, cause);
this.name = name;
this.context = context;
this.cause = cause;
}
public String getName() {
return name;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "UnsolvedSymbolException{" + "context='" + context + "'" + ", name='" + name + "'" + ", cause='" + cause + "'" + "}";
| 384
| 47
| 431
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.Throwable) ,public void <init>(java.lang.String, java.lang.Throwable) <variables>static final long serialVersionUID
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/FunctionalInterfaceLogic.java
|
FunctionalInterfaceLogic
|
getFunctionalMethod
|
class FunctionalInterfaceLogic {
private static String JAVA_LANG_FUNCTIONAL_INTERFACE = FunctionalInterface.class.getCanonicalName();
private FunctionalInterfaceLogic() {
// prevent instantiation
}
/**
* Get the functional method defined by the type, if any.
*/
public static Optional<MethodUsage> getFunctionalMethod(ResolvedType type) {<FILL_FUNCTION_BODY>}
/**
* Get the functional method defined by the type, if any.
*/
public static Optional<MethodUsage> getFunctionalMethod(ResolvedReferenceTypeDeclaration typeDeclaration) {
//We need to find all abstract methods
Set<MethodUsage> methods = typeDeclaration.getAllMethods().stream()
.filter(m -> m.getDeclaration().isAbstract())
// Remove methods inherited by Object:
// Consider the case of Comparator which define equals. It would be considered a functional method.
.filter(m -> !isPublicMemberOfObject(m))
.collect(Collectors.toSet());
// TODO a functional interface can have multiple subsignature method with a return-type-substitutable
// see https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html#jls-9.8
if (methods.size() == 0) {
return Optional.empty();
}
Iterator<MethodUsage> iterator = methods.iterator();
MethodUsage methodUsage = iterator.next();
while (iterator.hasNext()) {
MethodUsage otherMethodUsage = iterator.next();
if (!(methodUsage.isSameSignature(otherMethodUsage)
|| methodUsage.isSubSignature(otherMethodUsage)
|| otherMethodUsage.isSubSignature(methodUsage))) {
methodUsage = null;
break;
}
if (!(methodUsage.isReturnTypeSubstituable(otherMethodUsage))) {
methodUsage = null;
break;
}
}
return Optional.ofNullable(methodUsage);
}
public static boolean isFunctionalInterfaceType(ResolvedType type) {
if (type.isReferenceType()) {
Optional<ResolvedReferenceTypeDeclaration> optionalTypeDeclaration = type.asReferenceType().getTypeDeclaration();
if (optionalTypeDeclaration.isPresent() && optionalTypeDeclaration.get().hasAnnotation(JAVA_LANG_FUNCTIONAL_INTERFACE)) {
return true;
}
}
return getFunctionalMethod(type).isPresent();
}
private static String getSignature(Method m) {
return String.format("%s(%s)", m.getName(), String.join(", ", Arrays.stream(m.getParameters()).map(p -> toSignature(p)).collect(Collectors.toList())));
}
private static String toSignature(Parameter p) {
return p.getType().getCanonicalName();
}
private static List<String> OBJECT_PUBLIC_METHODS_SIGNATURES = Arrays.stream(Object.class.getDeclaredMethods())
.filter(m -> Modifier.isPublic(m.getModifiers()))
.map(method -> getSignature(method))
.collect(Collectors.toList());
private static boolean isPublicMemberOfObject(MethodUsage m) {
return OBJECT_PUBLIC_METHODS_SIGNATURES.contains(m.getDeclaration().getSignature());
}
}
|
Optional<ResolvedReferenceTypeDeclaration> optionalTypeDeclaration = type.asReferenceType().getTypeDeclaration();
if(!optionalTypeDeclaration.isPresent()) {
return Optional.empty();
}
ResolvedReferenceTypeDeclaration typeDeclaration = optionalTypeDeclaration.get();
if (type.isReferenceType() && typeDeclaration.isInterface()) {
return getFunctionalMethod(typeDeclaration);
}
return Optional.empty();
| 863
| 106
| 969
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/logic/InferenceVariableType.java
|
InferenceVariableType
|
equivalentType
|
class InferenceVariableType implements ResolvedType {
@Override
public String toString() {
return "InferenceVariableType{" +
"id=" + id +
'}';
}
private int id;
private ResolvedTypeParameterDeclaration correspondingTp;
public void setCorrespondingTp(ResolvedTypeParameterDeclaration correspondingTp) {
this.correspondingTp = correspondingTp;
}
private Set<ResolvedType> equivalentTypes = new HashSet<>();
private TypeSolver typeSolver;
public void registerEquivalentType(ResolvedType type) {
this.equivalentTypes.add(type);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof InferenceVariableType)) return false;
InferenceVariableType that = (InferenceVariableType) o;
return id == that.id;
}
@Override
public int hashCode() {
return id;
}
private Set<ResolvedType> superTypes = new HashSet<>();
public InferenceVariableType(int id, TypeSolver typeSolver) {
this.id = id;
this.typeSolver = typeSolver;
}
@Override
public String describe() {
return "InferenceVariable_" + id;
}
@Override
public boolean isAssignableBy(ResolvedType other) {
throw new UnsupportedOperationException();
}
private Set<ResolvedType> concreteEquivalentTypesAlsoIndirectly(Set<InferenceVariableType> considered, InferenceVariableType inferenceVariableType) {
considered.add(inferenceVariableType);
Set<ResolvedType> result = new HashSet<>();
result.addAll(inferenceVariableType.equivalentTypes.stream().filter(t -> !t.isTypeVariable() && !(t instanceof InferenceVariableType)).collect(Collectors.toSet()));
inferenceVariableType.equivalentTypes.stream().filter(t -> t instanceof InferenceVariableType).forEach(t -> {
InferenceVariableType ivt = (InferenceVariableType)t;
if (!considered.contains(ivt)) {
result.addAll(concreteEquivalentTypesAlsoIndirectly(considered, ivt));
}
});
return result;
}
public ResolvedType equivalentType() {<FILL_FUNCTION_BODY>}
private boolean hasInferenceVariables(ResolvedType type){
if (type instanceof InferenceVariableType){
return true;
}
if (type.isReferenceType()){
ResolvedReferenceType refType = type.asReferenceType();
for (ResolvedType t : refType.typeParametersValues()){
if (hasInferenceVariables(t)){
return true;
}
}
return false;
}
if (type.isWildcard()){
ResolvedWildcard wildcardType = type.asWildcard();
return hasInferenceVariables(wildcardType.getBoundedType());
}
return false;
}
}
|
Set<ResolvedType> concreteEquivalent = concreteEquivalentTypesAlsoIndirectly(new HashSet<>(), this);
if (concreteEquivalent.isEmpty()) {
if (correspondingTp == null) {
return new ReferenceTypeImpl(typeSolver.getSolvedJavaLangObject());
}
return new ResolvedTypeVariable(correspondingTp);
}
if (concreteEquivalent.size() == 1) {
return concreteEquivalent.iterator().next();
}
Set<ResolvedType> notTypeVariables = equivalentTypes.stream()
.filter(t -> !t.isTypeVariable() && !hasInferenceVariables(t))
.collect(Collectors.toSet());
if (notTypeVariables.size() == 1) {
return notTypeVariables.iterator().next();
}
if (notTypeVariables.size() == 0 && !superTypes.isEmpty()) {
if (superTypes.size() == 1) {
return superTypes.iterator().next();
}
throw new IllegalStateException("Super types are: " + superTypes);
}
throw new IllegalStateException("Equivalent types are: " + equivalentTypes);
| 790
| 296
| 1,086
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/model/SymbolReference.java
|
SymbolReference
|
getCorrespondingDeclaration
|
class SymbolReference<S extends ResolvedDeclaration> {
/**
* Create a solve reference to the given symbol.
*/
public static <S extends ResolvedDeclaration, S2 extends S> SymbolReference<S> solved(S2 symbolDeclaration) {
return new SymbolReference<>(symbolDeclaration);
}
/**
* Create a reference for an unsolved symbol.
*
* @return The created unsolved symbol reference.
*
* @param <S> The symbol reference type.
*/
public static <S extends ResolvedDeclaration> SymbolReference<S> unsolved() {
return new SymbolReference<>(null);
}
/**
* Create an unsolved reference specifying the type of the value expected.
*
* @deprecated Consider using {@link #unsolved()} instead.
*/
@Deprecated
public static <S extends ResolvedDeclaration, S2 extends S> SymbolReference<S> unsolved(Class<S2> clazz) {
return unsolved();
}
/**
* Adapt a {@link SymbolReference} into another {@link SymbolReference}.
*
* @param ref The reference to be adapted.
* @param clazz The final type to be used.
*
* @return The adapted symbol reference.
*
* @param <I> The Symbol Reference before adapting.
* @param <O> The Symbol Reference after adapting.
*/
public static <I extends ResolvedDeclaration, O extends ResolvedDeclaration> SymbolReference<O> adapt(SymbolReference<I> ref, Class<O> clazz) {
Optional<I> declaration = ref.getDeclaration();
if (declaration.isPresent()) {
I symbol = declaration.get();
if (clazz.isInstance(symbol)) {
return solved(clazz.cast(symbol));
}
}
return unsolved();
}
private final S correspondingDeclaration;
private SymbolReference(@Nullable S correspondingDeclaration) {
this.correspondingDeclaration = correspondingDeclaration;
}
/**
* Get the declaration associated with the Symbol.
*
* @return an {@link Optional} with a present value if the symbol is solved, otherwise an empty {@link Optional}.
*/
public Optional<S> getDeclaration() {
return Optional.ofNullable(correspondingDeclaration);
}
/**
* The corresponding declaration. If not solve this throws UnsupportedOperationException.
*/
public S getCorrespondingDeclaration() {<FILL_FUNCTION_BODY>}
/**
* Is the reference solved?
*/
public boolean isSolved() {
return getDeclaration().isPresent();
}
@Override
public String toString() {
return "SymbolReference{" + correspondingDeclaration + "}";
}
}
|
Optional<S> declaration = getDeclaration();
if (declaration.isPresent()) {
return declaration.get();
}
throw new UnsolvedSymbolException("Corresponding declaration not available for unsolved symbol.");
| 704
| 59
| 763
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/model/Value.java
|
Value
|
toString
|
class Value {
private ResolvedType type;
private String name;
public Value(ResolvedType type, String name) {
this.type = type;
this.name = name;
}
/**
* Create a Value from a ValueDeclaration.
*/
public static Value from(ResolvedValueDeclaration decl) {
ResolvedType type = decl.getType();
return new Value(type, decl.getName());
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
public String getName() {
return name;
}
public ResolvedType getType() {
return type;
}
}
|
return "Value{" +
"type=" + type +
", name='" + name + '\'' +
'}';
| 178
| 36
| 214
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/model/typesystem/LazyType.java
|
LazyType
|
getType
|
class LazyType implements ResolvedType {
private ResolvedType concrete;
private Function<Void, ResolvedType> provider;
public LazyType(Function<Void, ResolvedType> provider) {
this.provider = provider;
}
public ResolvedType getType() {<FILL_FUNCTION_BODY>}
@Override
public boolean isArray() {
return getType().isArray();
}
@Override
public int arrayLevel() {
return getType().arrayLevel();
}
@Override
public boolean isPrimitive() {
return getType().isPrimitive();
}
@Override
public boolean isNull() {
return getType().isNull();
}
@Override
public boolean isReference() {
return getType().isReference();
}
@Override
public boolean isReferenceType() {
return getType().isReferenceType();
}
@Override
public boolean isVoid() {
return getType().isVoid();
}
@Override
public boolean isTypeVariable() {
return getType().isTypeVariable();
}
@Override
public boolean isWildcard() {
return getType().isWildcard();
}
@Override
public ResolvedArrayType asArrayType() {
return getType().asArrayType();
}
@Override
public ResolvedReferenceType asReferenceType() {
return getType().asReferenceType();
}
@Override
public ResolvedTypeParameterDeclaration asTypeParameter() {
return getType().asTypeParameter();
}
@Override
public ResolvedTypeVariable asTypeVariable() {
return getType().asTypeVariable();
}
@Override
public ResolvedPrimitiveType asPrimitive() {
return getType().asPrimitive();
}
@Override
public ResolvedWildcard asWildcard() {
return getType().asWildcard();
}
@Override
public String describe() {
return getType().describe();
}
@Override
public ResolvedType replaceTypeVariables(ResolvedTypeParameterDeclaration tp, ResolvedType replaced,
Map<ResolvedTypeParameterDeclaration, ResolvedType> inferredTypes) {
return getType().replaceTypeVariables(tp, replaced, inferredTypes);
}
@Override
public ResolvedType replaceTypeVariables(ResolvedTypeParameterDeclaration tp, ResolvedType replaced) {
return getType().replaceTypeVariables(tp, replaced);
}
@Override
public boolean isAssignableBy(ResolvedType other) {
return getType().isAssignableBy(other);
}
}
|
if (concrete == null) {
concrete = provider.apply(null);
}
return concrete;
| 706
| 31
| 737
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/model/typesystem/NullType.java
|
NullType
|
isAssignableBy
|
class NullType implements ResolvedType {
public static final NullType INSTANCE = new NullType();
private NullType() {
// prevent instantiation
}
@Override
public boolean isArray() {
return false;
}
public boolean isNull() {
return true;
}
@Override
public boolean isReferenceType() {
return false;
}
@Override
public String describe() {
return "null";
}
@Override
public boolean isTypeVariable() {
return false;
}
@Override
public boolean isAssignableBy(ResolvedType other) {<FILL_FUNCTION_BODY>}
}
|
throw new UnsupportedOperationException("It does not make sense to assign a value to null, it can only be assigned");
| 182
| 30
| 212
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/types/ResolvedArrayType.java
|
ResolvedArrayType
|
replaceTypeVariables
|
class ResolvedArrayType implements ResolvedType {
private ResolvedType baseType;
public ResolvedArrayType(ResolvedType baseType) {
this.baseType = baseType;
}
// /
// / Object methods
// /
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
ResolvedArrayType that = (ResolvedArrayType) o;
if (!baseType.equals(that.baseType))
return false;
return true;
}
@Override
public int hashCode() {
return baseType.hashCode();
}
@Override
public String toString() {
return "ResolvedArrayType{" + baseType + "}";
}
// /
// / Type methods
// /
@Override
public ResolvedArrayType asArrayType() {
return this;
}
@Override
public boolean isArray() {
return true;
}
@Override
public String describe() {
return baseType.describe() + "[]";
}
public ResolvedType getComponentType() {
return baseType;
}
@Override
// https://docs.oracle.com/javase/specs/jls/se8/html/jls-5.html#jls-5.2
public boolean isAssignableBy(ResolvedType other) {
if (other.isNull()) {
return true;
}
if (other.isArray()) {
if (baseType.isPrimitive() && other.asArrayType().getComponentType().isPrimitive()) {
return baseType.equals(other.asArrayType().getComponentType());
}
// An array of primitive type is not assignable by an array of boxed type nor the reverse
// An array of primitive type cannot be assigned to an array of Object
if ((baseType.isPrimitive() && other.asArrayType().getComponentType().isReferenceType())
|| (baseType.isReferenceType() && other.asArrayType().getComponentType().isPrimitive())) {
return false;
}
// An array can be assigned only to a variable of a compatible array type, or to
// a variable of type Object, Cloneable or java.io.Serializable.
return baseType.isAssignableBy(other.asArrayType().getComponentType());
}
return false;
}
@Override
public ResolvedType replaceTypeVariables(ResolvedTypeParameterDeclaration tpToReplace, ResolvedType replaced, Map<ResolvedTypeParameterDeclaration, ResolvedType> inferredTypes) {<FILL_FUNCTION_BODY>}
// /
// / Erasure
// /
// The erasure of an array type T[] is |T|[].
@Override
public ResolvedType erasure() {
return new ResolvedArrayType(baseType.erasure());
}
@Override
public String toDescriptor() {
StringBuffer sb = new StringBuffer();
sb.append("[");
sb.append(baseType.toDescriptor());
return sb.toString();
}
}
|
ResolvedType baseTypeReplaced = baseType.replaceTypeVariables(tpToReplace, replaced, inferredTypes);
if (baseTypeReplaced == baseType) {
return this;
}
return new ResolvedArrayType(baseTypeReplaced);
| 821
| 68
| 889
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/types/ResolvedIntersectionType.java
|
ResolvedIntersectionType
|
equals
|
class ResolvedIntersectionType implements ResolvedType {
private List<ResolvedType> elements;
public ResolvedIntersectionType(Collection<ResolvedType> elements) {
if (elements.size() < 2) {
throw new IllegalArgumentException("An intersection type should have at least two elements. This has " + elements.size());
}
this.elements = new LinkedList<>(elements);
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return new HashSet<>(elements).hashCode();
}
@Override
public String describe() {
return String.join(" & ", elements.stream().map(ResolvedType::describe).collect(Collectors.toList()));
}
@Override
public boolean isAssignableBy(ResolvedType other) {
return elements.stream().allMatch(e -> e.isAssignableBy(other));
}
@Override
public ResolvedType replaceTypeVariables(ResolvedTypeParameterDeclaration tp, ResolvedType replaced, Map<ResolvedTypeParameterDeclaration, ResolvedType> inferredTypes) {
List<ResolvedType> elementsReplaced = elements.stream().map(e -> e.replaceTypeVariables(tp, replaced, inferredTypes)).collect(Collectors.toList());
if (elementsReplaced.equals(elements)) {
return this;
}
return new ResolvedIntersectionType(elementsReplaced);
}
/*
* Returns the list of the resolved types
*/
public List<ResolvedType> getElements() {
return elements;
}
}
|
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
ResolvedIntersectionType that = (ResolvedIntersectionType) o;
return new HashSet<>(elements).equals(new HashSet<>(that.elements));
| 422
| 79
| 501
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/types/ResolvedTypeVariable.java
|
ResolvedTypeVariable
|
equals
|
class ResolvedTypeVariable implements ResolvedType {
private ResolvedTypeParameterDeclaration typeParameter;
public ResolvedTypeVariable(ResolvedTypeParameterDeclaration typeParameter) {
this.typeParameter = typeParameter;
}
@Override
public String toString() {
return "TypeVariable {" + typeParameter.toString() + "}";
}
public String qualifiedName() {
return this.typeParameter.getQualifiedName();
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return typeParameter.hashCode();
}
@Override
public boolean isArray() {
return false;
}
@Override
public ResolvedType replaceTypeVariables(ResolvedTypeParameterDeclaration tpToBeReplaced, ResolvedType replaced, Map<ResolvedTypeParameterDeclaration, ResolvedType> inferredTypes) {
if (tpToBeReplaced.getName().equals(this.typeParameter.getName())) {
inferredTypes.put(this.asTypeParameter(), replaced);
return replaced;
}
return this;
}
@Override
public boolean isReferenceType() {
return false;
}
@Override
public String describe() {
return typeParameter.getName();
}
@Override
public ResolvedTypeParameterDeclaration asTypeParameter() {
return typeParameter;
}
@Override
public ResolvedTypeVariable asTypeVariable() {
return this;
}
@Override
public boolean isTypeVariable() {
return true;
}
@Override
public boolean isAssignableBy(ResolvedType other) {
if (other.isTypeVariable()) {
return describe().equals(other.describe());
}
return true;
}
@Override
public boolean mention(List<ResolvedTypeParameterDeclaration> typeParameters) {
return typeParameters.contains(typeParameter);
}
// /
// / Erasure
// /
// The erasure of a type variable (§4.4) is the erasure of its leftmost bound.
// If no bound is declared for a type variable, Object is assumed.
//
@Override
public ResolvedType erasure() {
if (typeParameter.isBounded()) {
return typeParameter.getBounds().get(0).getType();
}
return typeParameter.object();
}
/*
* Returns the resolved type for a type variable.
*/
@Override
public ResolvedType solveGenericTypes(Context context) {
return context.solveGenericType(describe()).orElse(this);
}
@Override
public String toDescriptor() {
return String.format("L%s;", qualifiedName());
}
}
|
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
ResolvedTypeVariable that = (ResolvedTypeVariable) o;
if (!typeParameter.getName().equals(that.typeParameter.getName()))
return false;
if (typeParameter.declaredOnType() != that.typeParameter.declaredOnType())
return false;
if (typeParameter.declaredOnMethod() != that.typeParameter.declaredOnMethod())
return false;
return true;
| 722
| 142
| 864
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/types/ResolvedUnionType.java
|
ResolvedUnionType
|
getCommonAncestor
|
class ResolvedUnionType implements ResolvedType {
private List<ResolvedType> elements;
public ResolvedUnionType(List<ResolvedType> elements) {
if (elements.size() < 2) {
throw new IllegalArgumentException("An union type should have at least two elements. This has " + elements.size());
}
this.elements = new LinkedList<>(elements);
}
public Optional<ResolvedReferenceType> getCommonAncestor() {<FILL_FUNCTION_BODY>}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
ResolvedUnionType that = (ResolvedUnionType) o;
return new HashSet<>(elements).equals(new HashSet<>(that.elements));
}
@Override
public int hashCode() {
return new HashSet<>(elements).hashCode();
}
@Override
public String describe() {
return String.join(" | ", elements.stream().map(ResolvedType::describe).collect(Collectors.toList()));
}
@Override
public boolean isAssignableBy(ResolvedType other) {
return elements.stream().allMatch(e -> e.isAssignableBy(other));
}
@Override
public boolean isUnionType() {
return true;
}
@Override
public ResolvedUnionType asUnionType() {
return this;
}
/*
* Returns the list of the resolved types
*/
public List<ResolvedType> getElements() {
return elements;
}
}
|
Optional<List<ResolvedReferenceType>> reduce = elements.stream()
.map(ResolvedType::asReferenceType)
.map(rt -> rt. getAllAncestors(ResolvedReferenceTypeDeclaration.breadthFirstFunc))
.reduce((a, b) -> {
ArrayList<ResolvedReferenceType> common = new ArrayList<>(a);
common.retainAll(b);
return common;
});
return reduce.orElse(new ArrayList<>()).stream().findFirst();
| 439
| 131
| 570
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/types/ResolvedVoidType.java
|
ResolvedVoidType
|
isAssignableBy
|
class ResolvedVoidType implements ResolvedType {
public static final ResolvedType INSTANCE = new ResolvedVoidType();
private ResolvedVoidType() {
}
@Override
public String describe() {
return "void";
}
@Override
public boolean isAssignableBy(ResolvedType other) {<FILL_FUNCTION_BODY>}
@Override
public boolean isVoid() {
return true;
}
@Override
public String toDescriptor() {
return "V";
}
}
|
// According to https://docs.oracle.com/javase/specs/jls/se16/html/jls-14.html#jls-14.8:
// """
// Note that the Java programming language does not allow a "cast to void" - void is not a type - so the
// traditional C trick of writing an expression statement such as:
//
// (void)... ; // incorrect!
//
// does not work.
// """
//
// In short, nothing can be assign to "void".
return false;
| 151
| 146
| 297
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/types/ResolvedWildcard.java
|
ResolvedWildcard
|
solveGenericTypes
|
class ResolvedWildcard implements ResolvedType {
public static ResolvedWildcard UNBOUNDED = new ResolvedWildcard(null, null);
private BoundType type;
private ResolvedType boundedType;
private ResolvedWildcard(BoundType type, ResolvedType boundedType) {
if (type == null && boundedType != null) {
throw new IllegalArgumentException();
}
if (type != null && boundedType == null) {
throw new IllegalArgumentException();
}
this.type = type;
this.boundedType = boundedType;
}
public static ResolvedWildcard superBound(ResolvedType type) {
return new ResolvedWildcard(BoundType.SUPER, type);
}
public static ResolvedWildcard extendsBound(ResolvedType type) {
return new ResolvedWildcard(BoundType.EXTENDS, type);
}
@Override
public String toString() {
return "WildcardUsage{" + "type=" + type + ", boundedType=" + boundedType + '}';
}
@Override
public boolean isWildcard() {
return true;
}
@Override
public ResolvedWildcard asWildcard() {
return this;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof ResolvedWildcard))
return false;
ResolvedWildcard that = (ResolvedWildcard) o;
if (boundedType != null ? !boundedType.equals(that.boundedType) : that.boundedType != null)
return false;
if (type != that.type)
return false;
return true;
}
@Override
public int hashCode() {
int result = type != null ? type.hashCode() : 0;
result = 31 * result + (boundedType != null ? boundedType.hashCode() : 0);
return result;
}
@Override
public String describe() {
if (type == null) {
return "?";
}
if (type == BoundType.SUPER) {
return "? super " + boundedType.describe();
}
if (type == BoundType.EXTENDS) {
return "? extends " + boundedType.describe();
}
throw new UnsupportedOperationException();
}
public boolean isSuper() {
return type == BoundType.SUPER;
}
public boolean isExtends() {
return type == BoundType.EXTENDS;
}
public boolean isBounded() {
return isSuper() || isExtends();
}
public ResolvedType getBoundedType() {
if (boundedType == null) {
throw new IllegalStateException();
}
return boundedType;
}
@Override
public boolean isAssignableBy(ResolvedType other) {
if (boundedType == null) {
// return other.isReferenceType() && other.asReferenceType().getQualifiedName().equals(Object.class.getCanonicalName());
return false;
}
if (type == BoundType.SUPER) {
return boundedType.isAssignableBy(other);
}
if (type == BoundType.EXTENDS) {
return false;
}
throw new RuntimeException();
}
@Override
public ResolvedType replaceTypeVariables(ResolvedTypeParameterDeclaration tpToReplace, ResolvedType replaced, Map<ResolvedTypeParameterDeclaration, ResolvedType> inferredTypes) {
if (replaced == null) {
throw new IllegalArgumentException();
}
if (boundedType == null) {
return this;
}
ResolvedType boundedTypeReplaced = boundedType.replaceTypeVariables(tpToReplace, replaced, inferredTypes);
if (boundedTypeReplaced == null) {
throw new RuntimeException();
}
if (boundedTypeReplaced != boundedType) {
return new ResolvedWildcard(type, boundedTypeReplaced);
}
return this;
}
@Override
public boolean mention(List<ResolvedTypeParameterDeclaration> typeParameters) {
return boundedType != null && boundedType.mention(typeParameters);
}
public boolean isUpperBounded() {
return isExtends();
}
public boolean isLowerBounded() {
return isSuper();
}
public enum BoundType {
SUPER, EXTENDS
}
/*
* Returns the bounded resolved type.
*/
@Override
public ResolvedType solveGenericTypes(Context context) {<FILL_FUNCTION_BODY>}
//
// Erasure
//
// The erasure of a type variable (§4.4) is the erasure of its leftmost bound.
// This method returns null if no bound is declared. This is probably a limitation.
//
@Override
public ResolvedType erasure() {
return boundedType;
}
}
|
if (isExtends() || isSuper()) {
ResolvedType boundResolved = getBoundedType().solveGenericTypes(context);
if (isExtends()) {
return ResolvedWildcard.extendsBound(boundResolved);
}
return ResolvedWildcard.superBound(boundResolved);
}
return this;
| 1,307
| 93
| 1,400
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/resolution/types/parametrization/ResolvedTypeParametersMap.java
|
Builder
|
replaceAll
|
class Builder {
private Map<String, ResolvedType> nameToValue;
private Map<String, ResolvedTypeParameterDeclaration> nameToDeclaration;
public Builder() {
nameToValue = new HashMap<>();
nameToDeclaration = new HashMap<>();
}
private Builder(Map<String, ResolvedType> nameToValue, Map<String, ResolvedTypeParameterDeclaration> nameToDeclaration) {
this.nameToValue = new HashMap<>();
this.nameToValue.putAll(nameToValue);
this.nameToDeclaration = new HashMap<>();
this.nameToDeclaration.putAll(nameToDeclaration);
}
public ResolvedTypeParametersMap build() {
return new ResolvedTypeParametersMap(nameToValue, nameToDeclaration);
}
public Builder setValue(ResolvedTypeParameterDeclaration typeParameter, ResolvedType value) {
// TODO: we shouldn't just silently overwrite existing types!
String qualifiedName = typeParameter.getQualifiedName();
nameToValue.put(qualifiedName, value);
nameToDeclaration.put(qualifiedName, typeParameter);
return this;
}
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof ResolvedTypeParametersMap))
return false;
ResolvedTypeParametersMap that = (ResolvedTypeParametersMap) o;
return nameToValue.equals(that.nameToValue) && nameToDeclaration.equals(that.nameToDeclaration);
}
@Override
public int hashCode() {
return nameToValue.hashCode();
}
@Override
public String toString() {
return "TypeParametersMap{" + "nameToValue=" + nameToValue + '}';
}
private Map<String, ResolvedType> nameToValue;
private Map<String, ResolvedTypeParameterDeclaration> nameToDeclaration;
public static ResolvedTypeParametersMap empty() {
return new Builder().build();
}
private ResolvedTypeParametersMap(Map<String, ResolvedType> nameToValue, Map<String, ResolvedTypeParameterDeclaration> nameToDeclaration) {
this.nameToValue = new HashMap<>();
this.nameToValue.putAll(nameToValue);
this.nameToDeclaration = new HashMap<>();
this.nameToDeclaration.putAll(nameToDeclaration);
}
public ResolvedType getValue(ResolvedTypeParameterDeclaration typeParameter) {
String qualifiedName = typeParameter.getQualifiedName();
if (nameToValue.containsKey(qualifiedName)) {
return nameToValue.get(qualifiedName);
}
return new ResolvedTypeVariable(typeParameter);
}
public Optional<ResolvedType> getValueBySignature(String signature) {
if (nameToValue.containsKey(signature)) {
return Optional.of(nameToValue.get(signature));
}
return Optional.empty();
}
public List<String> getNames() {
return new ArrayList<>(nameToValue.keySet());
}
public List<ResolvedType> getTypes() {
return new ArrayList<>(nameToValue.values());
}
public Builder toBuilder() {
return new Builder(nameToValue, nameToDeclaration);
}
public boolean isEmpty() {
return nameToValue.isEmpty();
}
public ResolvedType replaceAll(ResolvedType type) {<FILL_FUNCTION_BODY>
|
Map<ResolvedTypeParameterDeclaration, ResolvedType> inferredTypes = new HashMap<>();
for (ResolvedTypeParameterDeclaration typeParameterDeclaration : this.nameToDeclaration.values()) {
type = type.replaceTypeVariables(typeParameterDeclaration, getValue(typeParameterDeclaration), inferredTypes);
}
return type;
| 896
| 83
| 979
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/ClassUtils.java
|
ClassUtils
|
isPrimitiveOrWrapper
|
class ClassUtils {
/**
* Maps primitive {@code Class}es to their corresponding wrapper {@code Class}.
*/
private static final Map<Class<?>, Class<?>> primitiveWrapperMap = new HashMap<>();
static {
primitiveWrapperMap.put(Boolean.TYPE, Boolean.class);
primitiveWrapperMap.put(Byte.TYPE, Byte.class);
primitiveWrapperMap.put(Character.TYPE, Character.class);
primitiveWrapperMap.put(Short.TYPE, Short.class);
primitiveWrapperMap.put(Integer.TYPE, Integer.class);
primitiveWrapperMap.put(Long.TYPE, Long.class);
primitiveWrapperMap.put(Double.TYPE, Double.class);
primitiveWrapperMap.put(Float.TYPE, Float.class);
primitiveWrapperMap.put(Void.TYPE, Void.TYPE);
}
/**
* Maps wrapper {@code Class}es to their corresponding primitive types.
*/
private static final Map<Class<?>, Class<?>> wrapperPrimitiveMap = new HashMap<>();
static {
for (final Class<?> primitiveClass : primitiveWrapperMap.keySet()) {
final Class<?> wrapperClass = primitiveWrapperMap.get(primitiveClass);
if (!primitiveClass.equals(wrapperClass)) {
wrapperPrimitiveMap.put(wrapperClass, primitiveClass);
}
}
}
/**
* Returns whether the given {@code type} is a primitive or primitive wrapper ({@link Boolean}, {@link Byte},
* {@link Character},
* {@link Short}, {@link Integer}, {@link Long}, {@link Double}, {@link Float}).
*
* @param type The class to query or null.
* @return true if the given {@code type} is a primitive or primitive wrapper ({@link Boolean}, {@link Byte}, {@link
* Character}, {@link Short}, {@link Integer}, {@link Long}, {@link Double}, {@link Float}).
*/
public static boolean isPrimitiveOrWrapper(final Class<?> type) {<FILL_FUNCTION_BODY>}
/**
* Returns whether the given {@code type} is a primitive wrapper ({@link Boolean}, {@link Byte}, {@link Character},
* {@link Short},
* {@link Integer}, {@link Long}, {@link Double}, {@link Float}).
*
* @param type The class to query or null.
* @return true if the given {@code type} is a primitive wrapper ({@link Boolean}, {@link Byte}, {@link Character},
* {@link Short}, {@link Integer}, {@link Long}, {@link Double}, {@link Float}).
* @since 3.1
*/
public static boolean isPrimitiveWrapper(final Class<?> type) {
return wrapperPrimitiveMap.containsKey(type);
}
}
|
if (type == null) {
return false;
}
return type.isPrimitive() || isPrimitiveWrapper(type);
| 692
| 37
| 729
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/CodeGenerationUtils.java
|
CodeGenerationUtils
|
subtractPaths
|
class CodeGenerationUtils {
private CodeGenerationUtils() {
}
public static String getterName(Class<?> type, String name) {
if (name.startsWith("is") && boolean.class.equals(type)) {
return name;
}
if (Boolean.TYPE.equals(type)) {
return "is" + capitalize(name);
}
return "get" + capitalize(name);
}
public static String getterToPropertyName(String getterName) {
if (getterName.startsWith("is")) {
return decapitalize(getterName.substring("is".length()));
}
if (getterName.startsWith("get")) {
return decapitalize(getterName.substring("get".length()));
}
if (getterName.startsWith("has")) {
return decapitalize(getterName.substring("has".length()));
}
throw new IllegalArgumentException("Unexpected getterName '" + getterName + "'");
}
public static String setterName(String fieldName) {
if (fieldName.startsWith("is")) {
return "set" + fieldName.substring(2);
}
return "set" + capitalize(fieldName);
}
public static String optionalOf(String text, boolean isOptional) {
if (isOptional) {
return f("Optional.of(%s)", text);
}
return "Optional.empty()";
}
/**
* A shortcut to String.format.
*/
public static String f(String format, Object... params) {
return String.format(format, params);
}
/**
* Calculates the path to a file in a package.
*
* @param root the root directory in which the package resides
* @param pkg the package in which the file resides, like "com.laamella.parser"
* @param file the filename of the file in the package.
*/
public static Path fileInPackageAbsolutePath(String root, String pkg, String file) {
pkg = packageToPath(pkg);
return Paths.get(root, pkg, file).normalize();
}
public static Path fileInPackageAbsolutePath(Path root, String pkg, String file) {
return fileInPackageAbsolutePath(root.toString(), pkg, file);
}
/**
* Turns a package and a file into a relative path. "com.laamella" and "Simple.java" will become
* "com/laamella/Simple.java"
*/
public static Path fileInPackageRelativePath(String pkg, String file) {
pkg = packageToPath(pkg);
return Paths.get(pkg, file).normalize();
}
/**
* Converts a package name like "com.laamella.parser" to a path like "com/laamella/parser"
*/
public static String packageToPath(String pkg) {
return pkg.replace('.', File.separatorChar);
}
/**
* Calculates the path of a package.
*
* @param root the root directory in which the package resides
* @param pkg the package, like "com.laamella.parser"
*/
public static Path packageAbsolutePath(String root, String pkg) {
pkg = packageToPath(pkg);
return Paths.get(root, pkg).normalize();
}
public static Path packageAbsolutePath(Path root, String pkg) {
return packageAbsolutePath(root.toString(), pkg);
}
/**
* @return the root directory of the classloader for class c.
*/
public static Path classLoaderRoot(Class<?> c) {
try {
return Paths.get(c.getProtectionDomain().getCodeSource().getLocation().toURI());
} catch (URISyntaxException e) {
throw new AssertionError("Bug in JavaParser, please report.", e);
}
}
/**
* Useful for locating source code in your Maven project. Finds the classpath for class c, then backs up out of
* "target/(test-)classes", giving the directory containing the pom.xml.
*/
public static Path mavenModuleRoot(Class<?> c) {
return classLoaderRoot(c).resolve(Paths.get("..", "..")).normalize();
}
/**
* Shortens path "full" by cutting "difference" off the end of it.
*/
public static Path subtractPaths(Path full, Path difference) {<FILL_FUNCTION_BODY>}
}
|
while (difference != null) {
if (difference.getFileName().equals(full.getFileName())) {
difference = difference.getParent();
full = full.getParent();
} else {
throw new RuntimeException(f("'%s' could not be subtracted from '%s'", difference, full));
}
}
return full;
| 1,189
| 93
| 1,282
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/Log.java
|
StandardOutStandardErrorAdapter
|
error
|
class StandardOutStandardErrorAdapter implements Adapter {
@Override
public void info(Supplier<String> messageSupplier) {
System.out.println(messageSupplier.get());
}
@Override
public void trace(Supplier<String> messageSupplier) {
System.out.println(messageSupplier.get());
}
@Override
public void error(Supplier<Throwable> throwableSupplier, Supplier<String> messageSupplier) {<FILL_FUNCTION_BODY>}
private void printStackTrace(Throwable throwable) {
try (StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw)) {
throwable.printStackTrace(pw);
trace(sw::toString);
} catch (IOException e) {
throw new AssertionError("Error in logging library");
}
}
}
|
Throwable throwable = throwableSupplier.get();
String message = messageSupplier.get();
if (message == null) {
System.err.println(throwable.getMessage());
printStackTrace(throwable);
} else if (throwable == null) {
System.err.println(message);
} else {
System.err.println(message + ":" + throwable.getMessage());
printStackTrace(throwable);
}
| 223
| 117
| 340
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/Pair.java
|
Pair
|
equals
|
class Pair<A, B> {
public final A a;
public final B b;
public Pair(A a, B b) {
this.a = a;
this.b = b;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
int result = a != null ? a.hashCode() : 0;
return 31 * result + (b != null ? b.hashCode() : 0);
}
@Override
public String toString() {
return f("<%s, %s>", a, b);
}
}
|
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Pair<?, ?> pair = (Pair<?, ?>) o;
if (!Objects.equals(a, pair.a))
return false;
if (!Objects.equals(b, pair.b))
return false;
return true;
| 180
| 101
| 281
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/ParserCollectionStrategy.java
|
ParserCollectionStrategy
|
collect
|
class ParserCollectionStrategy implements CollectionStrategy {
private final ParserConfiguration parserConfiguration;
public ParserCollectionStrategy() {
this(new ParserConfiguration());
}
public ParserCollectionStrategy(ParserConfiguration parserConfiguration) {
this.parserConfiguration = parserConfiguration;
}
@Override
public ParserConfiguration getParserConfiguration() {
return parserConfiguration;
}
@Override
public ProjectRoot collect(Path path) {<FILL_FUNCTION_BODY>}
}
|
ProjectRoot projectRoot = new ProjectRoot(path, parserConfiguration);
try {
Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
Path current_root;
final PathMatcher javaMatcher = getPathMatcher("glob:**.java");
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
if ("module-info.java".equals(file.getFileName().toString())) {
// module-info.java is useless for finding the source root, since it can be placed within any directory.
return CONTINUE;
}
if (javaMatcher.matches(file)) {
current_root = getRoot(file).orElse(null);
if (current_root != null) {
return SKIP_SIBLINGS;
}
}
return CONTINUE;
}
@Override
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
if (Files.isHidden(dir) || (current_root != null && dir.startsWith(current_root))) {
return SKIP_SUBTREE;
}
return CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException e) throws IOException {
if (current_root != null && Files.isSameFile(dir, current_root)) {
projectRoot.addSourceRoot(dir);
current_root = null;
}
return CONTINUE;
}
});
} catch (IOException e) {
Log.error(e, "Unable to walk %s", () -> path);
}
return projectRoot;
| 126
| 425
| 551
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/PositionUtils.java
|
PositionUtils
|
firstNonAnnotationNode
|
class PositionUtils {
private PositionUtils() {
// prevent instantiation
}
public static <T extends Node> void sortByBeginPosition(List<T> nodes) {
sortByBeginPosition(nodes, false);
}
public static <T extends Node> void sortByBeginPosition(NodeList<T> nodes) {
sortByBeginPosition(nodes, false);
}
public static <T extends Node> void sortByBeginPosition(List<T> nodes, final boolean ignoringAnnotations) {
nodes.sort((o1, o2) -> PositionUtils.compare(o1, o2, ignoringAnnotations));
}
public static boolean areInOrder(Node a, Node b) {
return areInOrder(a, b, false);
}
public static boolean areInOrder(Node a, Node b, boolean ignoringAnnotations) {
return compare(a, b, ignoringAnnotations) <= 0;
}
private static int compare(Node a, Node b, boolean ignoringAnnotations) {
if (a.hasRange() && !b.hasRange()) {
return -1;
}
if (!a.hasRange() && b.hasRange()) {
return 1;
}
if (!a.hasRange() && !b.hasRange()) {
return 0;
}
if (ignoringAnnotations) {
int signLine = signum(beginLineWithoutConsideringAnnotation(a) - beginLineWithoutConsideringAnnotation(b));
if (signLine == 0) {
return signum(beginColumnWithoutConsideringAnnotation(a) - beginColumnWithoutConsideringAnnotation(b));
}
return signLine;
}
Position aBegin = a.getBegin().get();
Position bBegin = b.getBegin().get();
int signLine = signum(aBegin.line - bBegin.line);
if (signLine == 0) {
return signum(aBegin.column - bBegin.column);
}
return signLine;
}
public static AnnotationExpr getLastAnnotation(Node node) {
if (node instanceof NodeWithAnnotations) {
NodeList<AnnotationExpr> annotations = NodeList.nodeList(((NodeWithAnnotations<?>) node).getAnnotations());
if (annotations.isEmpty()) {
return null;
}
sortByBeginPosition(annotations);
return annotations.get(annotations.size() - 1);
}
return null;
}
private static int beginLineWithoutConsideringAnnotation(Node node) {
return firstNonAnnotationNode(node).getRange().get().begin.line;
}
private static int beginColumnWithoutConsideringAnnotation(Node node) {
return firstNonAnnotationNode(node).getRange().get().begin.column;
}
private static Node firstNonAnnotationNode(Node node) {<FILL_FUNCTION_BODY>}
/**
* Compare the position of two nodes. Optionally include annotations within the range checks.
* This method takes into account whether the nodes are within the same compilation unit.
* <p>
* Note that this performs a "strict contains", where the container must extend beyond the other node in both
* directions (otherwise it would count as an overlap, rather than "contain").
* <p>
* If `ignoringAnnotations` is false, annotations on the container are ignored. For this reason, where
* `container == other`, the raw `other` may extend beyond the sans-annotations `container` thus return false.
*/
public static boolean nodeContains(Node container, Node other, boolean ignoringAnnotations) {
if (!container.hasRange()) {
throw new IllegalArgumentException("Cannot compare the positions of nodes if container node does not have a range.");
}
if (!other.hasRange()) {
throw new IllegalArgumentException("Cannot compare the positions of nodes if contained node does not have a range.");
}
// // FIXME: Not all nodes seem to have the compilation unit available?
// if (!Objects.equals(container.findCompilationUnit(), other.findCompilationUnit())) {
// // Allow the check to complete if they are both within a known CU (i.e. the CUs are the same),
// // ... or both not within a CU (i.e. both are Optional.empty())
// return false;
// }
final boolean nodeCanHaveAnnotations = container instanceof NodeWithAnnotations;
// final boolean hasAnnotations = PositionUtils.getLastAnnotation(container) != null;
if (!ignoringAnnotations || PositionUtils.getLastAnnotation(container) == null) {
// No special consideration required - perform simple range check.
return container.containsWithinRange(other);
}
if (!container.containsWithinRange(other)) {
return false;
}
if (!nodeCanHaveAnnotations) {
return true;
}
// If the node is contained, but it comes immediately after the annotations,
// let's not consider it contained (i.e. it must be "strictly contained").
Node nodeWithoutAnnotations = firstNonAnnotationNode(container);
Range rangeWithoutAnnotations = container.getRange().get().withBegin(nodeWithoutAnnotations.getBegin().get());
return rangeWithoutAnnotations.// .contains(other.getRange().get());
strictlyContains(other.getRange().get());
}
}
|
if (node instanceof ClassOrInterfaceDeclaration) {
// Modifiers appear before the class name --
ClassOrInterfaceDeclaration casted = (ClassOrInterfaceDeclaration) node;
Modifier earliestModifier = casted.getModifiers().stream().filter(modifier -> modifier.hasRange()).min(Comparator.comparing(o -> o.getRange().get().begin)).orElse(null);
if (earliestModifier == null) {
return casted.getName();
}
return earliestModifier;
}
if (node instanceof MethodDeclaration) {
// Modifiers appear before the class name --
MethodDeclaration casted = (MethodDeclaration) node;
Modifier earliestModifier = casted.getModifiers().stream().filter(modifier -> modifier.hasRange()).min(Comparator.comparing(o -> o.getRange().get().begin)).orElse(null);
if (earliestModifier == null) {
return casted.getType();
}
return earliestModifier;
}
if (node instanceof FieldDeclaration) {
// Modifiers appear before the class name --
FieldDeclaration casted = (FieldDeclaration) node;
Modifier earliestModifier = casted.getModifiers().stream().filter(modifier -> modifier.hasRange()).min(Comparator.comparing(o -> o.getRange().get().begin)).orElse(null);
if (earliestModifier == null) {
return casted.getVariable(0).getType();
}
return earliestModifier;
}
return node;
| 1,325
| 391
| 1,716
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/ProjectRoot.java
|
ProjectRoot
|
toString
|
class ProjectRoot {
private final Path root;
private final Map<Path, SourceRoot> cache = new ConcurrentHashMap<>();
private final ParserConfiguration parserConfiguration;
public ProjectRoot(Path root) {
this(root, new ParserConfiguration());
}
public ProjectRoot(Path root, ParserConfiguration parserConfiguration) {
this.root = root;
this.parserConfiguration = parserConfiguration;
}
public Optional<SourceRoot> getSourceRoot(Path sourceRoot) {
return Optional.ofNullable(cache.get(sourceRoot));
}
public List<SourceRoot> getSourceRoots() {
return new ArrayList<>(cache.values());
}
public void addSourceRoot(Path path) {
cache.put(path, new SourceRoot(path).setParserConfiguration(parserConfiguration));
}
public Path getRoot() {
return root;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "ProjectRoot at " + root + " with " + cache.values().toString();
| 254
| 24
| 278
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/SeparatedItemStringBuilder.java
|
SeparatedItemStringBuilder
|
append
|
class SeparatedItemStringBuilder {
private final String separator;
private final String postfix;
private boolean hasItems = false;
private StringBuilder builder;
public SeparatedItemStringBuilder(String prefix, String separator, String postfix) {
builder = new StringBuilder(prefix);
this.separator = separator;
this.postfix = postfix;
}
/**
* Add one item. Either pass a string, or a format for String.format and corresponding arguments.
*/
public SeparatedItemStringBuilder append(CharSequence format, Object... args) {<FILL_FUNCTION_BODY>}
public boolean hasItems() {
return hasItems;
}
/**
* Convert the builder into its final string representation.
*/
@Override
public String toString() {
// This order of toStringing avoids debuggers from making a mess.
return builder.toString() + postfix;
}
}
|
if (hasItems) {
builder.append(separator);
}
builder.append(String.format(format.toString(), args));
hasItems = true;
return this;
| 246
| 51
| 297
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/SourceZip.java
|
SourceZip
|
parse
|
class SourceZip {
private final Path zipPath;
private ParserConfiguration parserConfiguration;
/**
* Create a new ZIP parser. An instance of {@link JavaParser} with the default {@link ParserConfiguration} will be
* used to parse the ZIP.
*
* @param zipPath The absolute path of ZIP file to parse.
*/
public SourceZip(Path zipPath) {
this(zipPath, new ParserConfiguration());
}
/**
* Create a new ZIP parser. An instance of {@link JavaParser} with the given configuration will be used to parse
* the ZIP.
*
* @param zipPath The absolute path of ZIP file to parse.
* @param configuration The configuration to initiate the default parser with.
*/
public SourceZip(Path zipPath, ParserConfiguration configuration) {
assertNotNull(zipPath);
assertNotNull(configuration);
this.zipPath = zipPath.normalize();
this.parserConfiguration = configuration;
Log.info("New source zip at \"%s\"", () -> this.zipPath);
}
/**
* Tries to parse all '.java' files in the ZIP located at this <i>SourceZip</i>'s path and returns the parse
* results in a list.
*
* @return A list of path-compilation unit pairs.
*
* @throws IOException If an error occurs while trying to parse the given source.
*/
public List<Pair<Path, ParseResult<CompilationUnit>>> parse() throws IOException {
Log.info("Parsing zip at \"%s\"", () -> zipPath);
List<Pair<Path, ParseResult<CompilationUnit>>> results = new ArrayList<>();
parse((path, result) -> results.add(new Pair<>(path, result)));
return results;
}
/**
* Tries to parse all '.java' files in the ZIP located at this <i>SourceZip</i>'s path and returns the parse
* results in a list.
*
* @return A list of path-compilation unit pairs.
*
* @throws IOException If an error occurs while trying to parse the given source.
*/
public SourceZip parse(Callback callback) throws IOException {<FILL_FUNCTION_BODY>}
/**
* An interface to define a callback for each file that's parsed.
*/
@FunctionalInterface
public interface Callback {
/**
* Process the given parse result.
*
* @param relativeZipEntryPath The relative path of the entry in the ZIP file that was parsed.
* @param result The parse result of file located at <i>absolutePath</i>.
*/
void process(Path relativeZipEntryPath, ParseResult<CompilationUnit> result);
}
/**
* Get the path of the ZIP file to be parsed.
*
* @return The absolute path of this ZIP file.
*/
public Path getZipPath() {
return zipPath;
}
public ParserConfiguration getParserConfiguration() {
return parserConfiguration;
}
public SourceZip setParserConfiguration(ParserConfiguration parserConfiguration) {
assertNotNull(parserConfiguration);
this.parserConfiguration = parserConfiguration;
return this;
}
}
|
Log.info("Parsing zip at \"%s\"", () -> zipPath);
JavaParser javaParser = new JavaParser(parserConfiguration);
try (ZipFile zipFile = new ZipFile(zipPath.toFile())) {
for (ZipEntry entry : Collections.list(zipFile.entries())) {
if (!entry.isDirectory() && entry.getName().endsWith(".java")) {
Log.info("Parsing zip entry \"%s\"", () -> entry.getName());
final ParseResult<CompilationUnit> result = javaParser.parse(COMPILATION_UNIT, provider(zipFile.getInputStream(entry)));
callback.process(Paths.get(entry.getName()), result);
}
}
}
return this;
| 832
| 192
| 1,024
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/StringEscapeUtils.java
|
UnicodeUnescaper
|
translate
|
class UnicodeUnescaper extends CharSequenceTranslator {
/**
* {@inheritDoc}
*/
@Override
protected int translate(final CharSequence input, final int index, final Writer out) throws IOException {<FILL_FUNCTION_BODY>}
}
|
if (input.charAt(index) == '\\' && index + 1 < input.length() && input.charAt(index + 1) == 'u') {
// consume optional additional 'u' chars
int i = 2;
while (index + i < input.length() && input.charAt(index + i) == 'u') {
i++;
}
if (index + i < input.length() && input.charAt(index + i) == '+') {
i++;
}
if (index + i + 4 <= input.length()) {
// Get 4 hex digits
final CharSequence unicode = input.subSequence(index + i, index + i + 4);
try {
final int value = Integer.parseInt(unicode.toString(), 16);
out.write((char) value);
} catch (final NumberFormatException nfe) {
throw new IllegalArgumentException("Unable to parse unicode value: " + unicode, nfe);
}
return i + 4;
}
throw new IllegalArgumentException("Less than 4 hex digits in unicode value: '" + input.subSequence(index, input.length()) + "' due to end of CharSequence");
}
return 0;
| 70
| 311
| 381
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/TypeUtils.java
|
TypeUtils
|
getPrimitiveTypeDescriptor
|
class TypeUtils {
/*
* Returns the method descriptor (https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.3)
* The method descriptor for the method: {@code Object m(int i, double d, Thread t) {...}}
* is {@code (IDLjava/lang/Thread;)Ljava/lang/Object;}
* Note that the internal forms of the binary names of Thread and Object are used.
*/
public static String getMethodDescriptor(Method method) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("(");
for (Class<?> parameter : method.getParameterTypes()) {
appendDescriptor(parameter, stringBuilder);
}
stringBuilder.append(")");
appendDescriptor(method.getReturnType(), stringBuilder);
return stringBuilder.toString();
}
private static void appendDescriptor(final Class<?> clazz, final StringBuilder stringBuilder) {
Class<?> currentClass = clazz;
while (currentClass.isArray()) {
stringBuilder.append("[");
currentClass = currentClass.getComponentType();
}
if (currentClass.isPrimitive()) {
String descriptor = getPrimitiveTypeDescriptor(currentClass);
stringBuilder.append(descriptor);
} else {
stringBuilder.append("L").append(currentClass.getName().replace(".", "/")).append(";");
}
}
public static String getPrimitiveTypeDescriptor(final Class<?> clazz) {<FILL_FUNCTION_BODY>}
}
|
if (clazz == Void.TYPE || clazz == Void.class) {
return new VoidType().toDescriptor();
}
String className = clazz.getSimpleName();
Optional<Primitive> prim = Primitive.byTypeName(className);
if (prim.isPresent()) {
return prim.get().toDescriptor();
}
prim = Primitive.byBoxedTypeName(className);
return prim.map(pType -> pType.toDescriptor())
.orElseThrow(
() -> new IllegalArgumentException(String.format("Unknown primitive type \"%s\"", className)));
| 403
| 154
| 557
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/VisitorMap.java
|
EqualsHashcodeOverridingFacade
|
equals
|
class EqualsHashcodeOverridingFacade implements Visitable {
private final N overridden;
EqualsHashcodeOverridingFacade(N overridden) {
this.overridden = overridden;
}
@Override
public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
throw new AssertionError();
}
@Override
public <A> void accept(VoidVisitor<A> v, A arg) {
throw new AssertionError();
}
@Override
public final int hashCode() {
return overridden.accept(hashcodeVisitor, null);
}
@Override
public boolean equals(final Object obj) {<FILL_FUNCTION_BODY>}
}
|
if (obj == null || !(obj instanceof VisitorMap.EqualsHashcodeOverridingFacade)) {
return false;
}
return overridden.accept(equalsVisitor, ((EqualsHashcodeOverridingFacade) obj).overridden);
| 202
| 66
| 268
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-core/src/main/java/com/github/javaparser/utils/VisitorSet.java
|
EqualsHashcodeOverridingFacade
|
equals
|
class EqualsHashcodeOverridingFacade implements Visitable {
private final N overridden;
EqualsHashcodeOverridingFacade(N overridden) {
this.overridden = overridden;
}
@Override
public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
throw new AssertionError();
}
@Override
public <A> void accept(VoidVisitor<A> v, A arg) {
throw new AssertionError();
}
@Override
public final int hashCode() {
return overridden.accept(hashcodeVisitor, null);
}
@Override
public boolean equals(final Object obj) {<FILL_FUNCTION_BODY>}
}
|
if (obj == null || !(obj instanceof VisitorSet.EqualsHashcodeOverridingFacade)) {
return false;
}
return overridden.accept(equalsVisitor, ((EqualsHashcodeOverridingFacade) obj).overridden);
| 227
| 71
| 298
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/SourceFileInfoExtractor.java
|
SourceFileInfoExtractor
|
solve
|
class SourceFileInfoExtractor {
private final TypeSolver typeSolver;
private int successes = 0;
private int failures = 0;
private int unsupported = 0;
private boolean printFileName = true;
private PrintStream out = System.out;
private PrintStream err = System.err;
private boolean verbose = false;
public SourceFileInfoExtractor(TypeSolver typeSolver) {
this.typeSolver = typeSolver;
}
public void setVerbose(boolean verbose) {
this.verbose = verbose;
}
public void setPrintFileName(boolean printFileName) {
this.printFileName = printFileName;
}
public void setOut(PrintStream out) {
this.out = out;
}
public void setErr(PrintStream err) {
this.err = err;
}
public int getSuccesses() {
return successes;
}
public int getUnsupported() {
return unsupported;
}
public int getFailures() {
return failures;
}
private void solveTypeDecl(ClassOrInterfaceDeclaration node) {
ResolvedTypeDeclaration typeDeclaration = JavaParserFacade.get(typeSolver).getTypeDeclaration(node);
if (typeDeclaration.isClass()) {
out.println("\n[ Class " + typeDeclaration.getQualifiedName() + " ]");
for (ResolvedReferenceType sc : typeDeclaration.asClass().getAllSuperClasses()) {
out.println(" superclass: " + sc.getQualifiedName());
}
for (ResolvedReferenceType sc : typeDeclaration.asClass().getAllInterfaces()) {
out.println(" interface: " + sc.getQualifiedName());
}
}
}
private void solve(Node node) {<FILL_FUNCTION_BODY>}
private void solveMethodCalls(Node node) {
if (node instanceof MethodCallExpr) {
out.println(" Line " + lineNr(node) + ") " + node + " ==> " + toString((MethodCallExpr) node));
}
for (Node child : node.getChildNodes()) {
solveMethodCalls(child);
}
}
private String toString(MethodCallExpr node) {
try {
return toString(JavaParserFacade.get(typeSolver).solve(node));
} catch (Exception e) {
if (verbose) {
System.err.println("Error resolving call at L" + lineNr(node) + ": " + node);
e.printStackTrace();
}
return "ERROR";
}
}
private String toString(SymbolReference<ResolvedMethodDeclaration> methodDeclarationSymbolReference) {
if (methodDeclarationSymbolReference.isSolved()) {
return methodDeclarationSymbolReference.getCorrespondingDeclaration().getQualifiedSignature();
}
return "UNSOLVED";
}
private List<Node> collectAllNodes(Node node) {
List<Node> nodes = new ArrayList<>();
node.walk(nodes::add);
nodes.sort(comparing(n -> n.getBegin().get()));
return nodes;
}
public void solve(Path path) throws IOException {
Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
if (file.toString().endsWith(".java")) {
if (printFileName) {
out.println("- parsing " + file.toAbsolutePath());
}
CompilationUnit cu = parse(file);
List<Node> nodes = collectAllNodes(cu);
nodes.forEach(n -> solve(n));
}
return FileVisitResult.CONTINUE;
}
});
}
public void solveMethodCalls(Path path) throws IOException {
Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
if (file.toString().endsWith(".java")) {
if (printFileName) {
out.println("- parsing " + file.toAbsolutePath());
}
CompilationUnit cu = parse(file);
solveMethodCalls(cu);
}
return FileVisitResult.CONTINUE;
}
});
}
private int lineNr(Node node) {
return node.getRange().map(range -> range.begin.line).orElseThrow(IllegalStateException::new);
}
}
|
if (node instanceof ClassOrInterfaceDeclaration) {
solveTypeDecl((ClassOrInterfaceDeclaration) node);
} else if (node instanceof Expression) {
Node parentNode = demandParentNode(node);
if (parentNode instanceof ImportDeclaration ||
parentNode instanceof Expression ||
parentNode instanceof MethodDeclaration ||
parentNode instanceof PackageDeclaration) {
// skip
return;
}
if (parentNode instanceof Statement ||
parentNode instanceof VariableDeclarator ||
parentNode instanceof SwitchEntry) {
try {
ResolvedType ref = JavaParserFacade.get(typeSolver).getType(node);
out.println(" Line " + lineNr(node) + ") " + node + " ==> " + ref.describe());
successes++;
} catch (UnsupportedOperationException upe) {
unsupported++;
err.println(upe.getMessage());
throw upe;
} catch (RuntimeException re) {
failures++;
err.println(re.getMessage());
throw re;
}
}
}
| 1,171
| 269
| 1,440
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/cache/GuavaCache.java
|
GuavaCache
|
stats
|
class GuavaCache<K, V> implements Cache<K, V> {
/**
* Wrap a Guava cache with a custom cache.
*
* @param guavaCache The guava cache to be wrapped-
*
* @param <expectedK> The expected type for the key.
* @param <expectedV> The expected type for the value.
*
* @return A newly created instance of {@link NoCache}.
*/
public static <expectedK, expectedV> GuavaCache<expectedK, expectedV> create(com.google.common.cache.Cache<expectedK, expectedV> guavaCache) {
return new GuavaCache<>(guavaCache);
}
private final com.google.common.cache.Cache<K, V> guavaCache;
public GuavaCache(com.google.common.cache.Cache<K, V> guavaCache) {
this.guavaCache = Objects.requireNonNull(guavaCache, "The argument GuavaCache can't be null.");
}
@Override
public void put(K key, V value) {
guavaCache.put(key, value);
}
@Override
public Optional<V> get(K key) {
return Optional.ofNullable(
guavaCache.getIfPresent(key)
);
}
@Override
public void remove(K key) {
guavaCache.invalidate(key);
}
@Override
public void removeAll() {
guavaCache.invalidateAll();
}
@Override
public boolean contains(K key) {
return get(key).isPresent();
}
@Override
public long size() {
return guavaCache.size();
}
@Override
public boolean isEmpty() {
return size() == 0;
}
@Override
public CacheStats stats() {<FILL_FUNCTION_BODY>}
}
|
com.google.common.cache.CacheStats stats = guavaCache.stats();
return new DefaultCacheStats(stats.hitCount(), stats.missCount(), stats.loadSuccessCount(),
stats.loadExceptionCount(), stats.totalLoadTime(), stats.evictionCount());
| 489
| 70
| 559
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/declarations/common/MethodDeclarationCommonLogic.java
|
MethodDeclarationCommonLogic
|
resolveTypeVariables
|
class MethodDeclarationCommonLogic {
private ResolvedMethodDeclaration methodDeclaration;
private TypeSolver typeSolver;
public MethodDeclarationCommonLogic(ResolvedMethodDeclaration methodDeclaration, TypeSolver typeSolver) {
this.methodDeclaration = methodDeclaration;
this.typeSolver = typeSolver;
}
public MethodUsage resolveTypeVariables(Context context, List<ResolvedType> parameterTypes) {<FILL_FUNCTION_BODY>}
private ResolvedType replaceTypeParams(ResolvedType type, Context context) {
if (type.isTypeVariable()) {
ResolvedTypeParameterDeclaration typeParameter = type.asTypeParameter();
if (typeParameter.declaredOnType()) {
Optional<ResolvedType> typeParam = typeParamByName(typeParameter.getName(), context);
if (typeParam.isPresent()) {
type = typeParam.get();
}
}
}
if (type.isReferenceType()) {
type.asReferenceType().transformTypeParameters(tp -> replaceTypeParams(tp, context));
}
return type;
}
protected Optional<ResolvedType> typeParamByName(String name, Context context) {
return methodDeclaration.getTypeParameters().stream().filter(tp -> tp.getName().equals(name)).map(tp -> toType(tp)).findFirst();
}
protected ResolvedType toType(ResolvedTypeParameterDeclaration typeParameterDeclaration) {
return new ResolvedTypeVariable(typeParameterDeclaration);
}
}
|
ResolvedType returnType = replaceTypeParams(methodDeclaration.getReturnType(), context);
List<ResolvedType> params = new ArrayList<>();
for (int i = 0; i < methodDeclaration.getNumberOfParams(); i++) {
ResolvedType replaced = replaceTypeParams(methodDeclaration.getParam(i).getType(), context);
params.add(replaced);
}
// We now look at the type parameter for the method which we can derive from the parameter types
// and then we replace them in the return type
// Map<TypeParameterDeclaration, Type> determinedTypeParameters = new HashMap<>();
InferenceContext inferenceContext = new InferenceContext(typeSolver);
for (int i = 0; i < methodDeclaration.getNumberOfParams(); i++) {
ResolvedParameterDeclaration formalParamDecl = methodDeclaration.getParam(i);
ResolvedType formalParamType = formalParamDecl.getType();
// Don't continue if a vararg parameter is reached and there are no arguments left
if (formalParamDecl.isVariadic() && parameterTypes.size() < methodDeclaration.getNumberOfParams()) {
break;
}
ResolvedType actualParamType = parameterTypes.get(i);
if (formalParamDecl.isVariadic() && !actualParamType.isArray()) {
formalParamType = formalParamType.asArrayType().getComponentType();
}
inferenceContext.addPair(formalParamType, actualParamType);
}
returnType = inferenceContext.resolve(inferenceContext.addSingle(returnType));
return new MethodUsage(methodDeclaration, params, returnType);
| 381
| 407
| 788
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/FailureHandler.java
|
FailureHandler
|
getRuntimeExceptionFrom
|
class FailureHandler {
private static final Map<Class<? extends Throwable>, Function<Throwable, ? extends RuntimeException>> FAILURE_CONVERTER = new HashMap<>();
static {
FAILURE_CONVERTER.put(UnsolvedSymbolException.class,
(Throwable th) -> (RuntimeException)th);
}
public RuntimeException handle(Throwable th) {
return handle(th, null);
}
public RuntimeException handle(Throwable th, String message) {
// searching for exact mapping
Function<Throwable, ? extends RuntimeException> converter = FAILURE_CONVERTER.get(findRootCause(th).getClass());
if (converter != null) {
return converter.apply(th);
}
// handle runtime exceptions
if (RuntimeException.class.isAssignableFrom(th.getClass())) {
return (RuntimeException) th;
}
return getRuntimeExceptionFrom(findRootCause(th), message);
}
protected final <E extends Throwable> E findRootCause(Throwable failure) {
while (failure != null) {
if (isRootCause(failure)) {
return (E) failure;
}
failure = failure.getCause();
}
return null;
}
private boolean isRootCause(Throwable th) {
return th.getCause() == null;
}
private RuntimeException getRuntimeExceptionFrom(Throwable th, String message) {<FILL_FUNCTION_BODY>}
}
|
if (message == null || message.isEmpty())
return new RuntimeException(findRootCause(th));
return new RuntimeException(message, findRootCause(th));
| 398
| 45
| 443
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFactory.java
|
JavaParserFactory
|
getContext
|
class JavaParserFactory {
public static Context getContext(Node node, TypeSolver typeSolver) {<FILL_FUNCTION_BODY>}
public static SymbolDeclarator getSymbolDeclarator(Node node, TypeSolver typeSolver) {
if (node instanceof FieldDeclaration) {
return new FieldSymbolDeclarator((FieldDeclaration) node, typeSolver);
}
if (node instanceof Parameter) {
return new ParameterSymbolDeclarator((Parameter) node, typeSolver);
}
if (node instanceof PatternExpr) {
return new PatternSymbolDeclarator((PatternExpr) node, typeSolver);
}
if (node instanceof ExpressionStmt) {
ExpressionStmt expressionStmt = (ExpressionStmt) node;
if (expressionStmt.getExpression() instanceof VariableDeclarationExpr) {
return new VariableSymbolDeclarator((VariableDeclarationExpr) (expressionStmt.getExpression()),
typeSolver);
}
return new NoSymbolDeclarator<>(expressionStmt, typeSolver);
}
if (node instanceof ForEachStmt) {
ForEachStmt foreachStmt = (ForEachStmt) node;
return new VariableSymbolDeclarator(foreachStmt.getVariable(), typeSolver);
}
return new NoSymbolDeclarator<>(node, typeSolver);
}
}
|
if (node == null) {
throw new NullPointerException("Node should not be null");
}
if (node instanceof ArrayAccessExpr) {
return new ArrayAccessExprContext((ArrayAccessExpr) node, typeSolver);
}
if (node instanceof AnnotationDeclaration) {
return new AnnotationDeclarationContext((AnnotationDeclaration) node, typeSolver);
}
if (node instanceof BinaryExpr) {
return new BinaryExprContext((BinaryExpr) node, typeSolver);
}
if (node instanceof BlockStmt) {
return new BlockStmtContext((BlockStmt) node, typeSolver);
}
if (node instanceof CompilationUnit) {
return new CompilationUnitContext((CompilationUnit) node, typeSolver);
}
if (node instanceof EnclosedExpr) {
return new EnclosedExprContext((EnclosedExpr) node, typeSolver);
}
if (node instanceof ForEachStmt) {
return new ForEachStatementContext((ForEachStmt) node, typeSolver);
}
if (node instanceof ForStmt) {
return new ForStatementContext((ForStmt) node, typeSolver);
}
if (node instanceof IfStmt) {
return new IfStatementContext((IfStmt) node, typeSolver);
}
if (node instanceof InstanceOfExpr) {
return new InstanceOfExprContext((InstanceOfExpr) node, typeSolver);
}
if (node instanceof LambdaExpr) {
return new LambdaExprContext((LambdaExpr) node, typeSolver);
}
if (node instanceof MethodDeclaration) {
return new MethodContext((MethodDeclaration) node, typeSolver);
}
if (node instanceof ConstructorDeclaration) {
return new ConstructorContext((ConstructorDeclaration) node, typeSolver);
}
if (node instanceof ClassOrInterfaceDeclaration) {
return new ClassOrInterfaceDeclarationContext((ClassOrInterfaceDeclaration) node, typeSolver);
}
if (node instanceof MethodCallExpr) {
return new MethodCallExprContext((MethodCallExpr) node, typeSolver);
}
if (node instanceof MethodReferenceExpr) {
return new MethodReferenceExprContext((MethodReferenceExpr) node, typeSolver);
}
if (node instanceof EnumDeclaration) {
return new EnumDeclarationContext((EnumDeclaration) node, typeSolver);
}
if (node instanceof FieldAccessExpr) {
return new FieldAccessContext((FieldAccessExpr) node, typeSolver);
}
if (node instanceof SwitchEntry) {
return new SwitchEntryContext((SwitchEntry) node, typeSolver);
}
if (node instanceof TryStmt) {
return new TryWithResourceContext((TryStmt) node, typeSolver);
}
if (node instanceof Statement) {
return new StatementContext<>((Statement) node, typeSolver);
}
if (node instanceof CatchClause) {
return new CatchClauseContext((CatchClause) node, typeSolver);
}
if (node instanceof UnaryExpr) {
return new UnaryExprContext((UnaryExpr) node, typeSolver);
}
if (node instanceof VariableDeclarator) {
return new VariableDeclaratorContext((VariableDeclarator) node, typeSolver);
}
if (node instanceof VariableDeclarationExpr) {
return new VariableDeclarationExprContext((VariableDeclarationExpr) node, typeSolver);
}
if (node instanceof ObjectCreationExpr &&
((ObjectCreationExpr) node).getAnonymousClassBody().isPresent()) {
return new AnonymousClassDeclarationContext((ObjectCreationExpr) node, typeSolver);
}
if (node instanceof ObjectCreationExpr) {
return new ObjectCreationContext((ObjectCreationExpr)node, typeSolver);
}
if (node instanceof NameExpr) {
// to resolve a name when in a fieldAccess context, we can go up until we get a node other than FieldAccessExpr,
// in order to prevent a infinite loop if the name is the same as the field (ie x.x, x.y.x, or x.y.z.x)
if (node.getParentNode().isPresent() && node.getParentNode().get() instanceof FieldAccessExpr) {
Node ancestor = node.getParentNode().get();
while (ancestor.getParentNode().isPresent()) {
ancestor = ancestor.getParentNode().get();
if (!(ancestor instanceof FieldAccessExpr)) {
break;
}
}
return getContext(ancestor, typeSolver);
}
if (node.getParentNode().isPresent() && node.getParentNode().get() instanceof ObjectCreationExpr && node.getParentNode().get().getParentNode().isPresent()) {
return getContext(node.getParentNode().get().getParentNode().get(), typeSolver);
}
}
final Node parentNode = demandParentNode(node);
if (node instanceof ClassOrInterfaceType && parentNode instanceof ClassOrInterfaceDeclaration) {
ClassOrInterfaceDeclaration parentDeclaration = (ClassOrInterfaceDeclaration) parentNode;
if (parentDeclaration.getImplementedTypes().contains(node) ||
parentDeclaration.getExtendedTypes().contains(node)) {
// When resolving names in implements and extends the body of the declaration
// should not be searched so use limited context.
return new ClassOrInterfaceDeclarationExtendsContext(parentDeclaration, typeSolver);
}
}
return getContext(parentNode, typeSolver);
| 341
| 1,360
| 1,701
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/AbstractMethodLikeDeclarationContext.java
|
AbstractMethodLikeDeclarationContext
|
solveSymbolAsValue
|
class AbstractMethodLikeDeclarationContext
<T extends Node & NodeWithParameters<T> & NodeWithTypeParameters<T>> extends AbstractJavaParserContext<T> {
public AbstractMethodLikeDeclarationContext(T wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public final SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
for (Parameter parameter : wrappedNode.getParameters()) {
SymbolDeclarator sb = JavaParserFactory.getSymbolDeclarator(parameter, typeSolver);
SymbolReference<? extends ResolvedValueDeclaration> symbolReference = AbstractJavaParserContext.solveWith(sb, name);
if (symbolReference.isSolved()) {
return symbolReference;
}
}
// if nothing is found we should ask the parent context
return solveSymbolInParentContext(name);
}
@Override
public final Optional<ResolvedType> solveGenericType(String name) {
// First check if the method-like declaration has type parameters defined.
// For example: {@code public <T> boolean containsAll(Collection<T> c);}
for (TypeParameter tp : wrappedNode.getTypeParameters()) {
if (tp.getName().getId().equals(name)) {
return Optional.of(new ResolvedTypeVariable(new JavaParserTypeParameter(tp, typeSolver)));
}
}
// If no generic types on the method declaration, continue to solve elsewhere as usual.
return solveGenericTypeInParentContext(name);
}
@Override
public final Optional<Value> solveSymbolAsValue(String name) {<FILL_FUNCTION_BODY>}
@Override
public final SymbolReference<ResolvedTypeDeclaration> solveType(String name, List<ResolvedType> typeArguments) {
// TODO: Is null check required?
if (wrappedNode.getTypeParameters() != null) {
for (TypeParameter tp : wrappedNode.getTypeParameters()) {
if (tp.getName().getId().equals(name)) {
return SymbolReference.solved(new JavaParserTypeParameter(tp, typeSolver));
}
}
}
// Local types
List<TypeDeclaration> localTypes = wrappedNode.findAll(TypeDeclaration.class);
for (TypeDeclaration<?> localType : localTypes) {
if (localType.getName().getId().equals(name)) {
return SymbolReference.solved(JavaParserFacade.get(typeSolver)
.getTypeDeclaration(localType));
}
if (name.startsWith(String.format("%s.", localType.getName()))) {
return JavaParserFactory.getContext(localType, typeSolver)
.solveType(name.substring(localType.getName().getId().length() + 1));
}
}
return solveTypeInParentContext(name, typeArguments);
}
@Override
public final SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) {
// TODO: Document why staticOnly is forced to be false.
return solveMethodInParentContext(name, argumentsTypes, false);
}
}
|
for (Parameter parameter : wrappedNode.getParameters()) {
SymbolDeclarator sb = JavaParserFactory.getSymbolDeclarator(parameter, typeSolver);
Optional<Value> symbolReference = solveWithAsValue(sb, name);
if (symbolReference.isPresent()) {
// Perform parameter type substitution as needed
return symbolReference;
}
}
// if nothing is found we should ask the parent context
return solveSymbolAsValueInParentContext(name);
| 789
| 120
| 909
|
<methods>public void <init>(T, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public T getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected T wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/AnnotationDeclarationContext.java
|
AnnotationDeclarationContext
|
solveSymbol
|
class AnnotationDeclarationContext extends AbstractJavaParserContext<AnnotationDeclaration> {
private JavaParserTypeDeclarationAdapter javaParserTypeDeclarationAdapter;
public AnnotationDeclarationContext(AnnotationDeclaration wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
this.javaParserTypeDeclarationAdapter = new JavaParserTypeDeclarationAdapter(wrappedNode, typeSolver,
getDeclaration(), this);
}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {<FILL_FUNCTION_BODY>}
@Override
public SymbolReference<ResolvedTypeDeclaration> solveType(String name, List<ResolvedType> resolvedTypes) {
return javaParserTypeDeclarationAdapter.solveType(name, resolvedTypes);
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) {
return javaParserTypeDeclarationAdapter.solveMethod(name, argumentsTypes, staticOnly);
}
///
/// Private methods
///
private ResolvedReferenceTypeDeclaration getDeclaration() {
return new JavaParserAnnotationDeclaration(this.wrappedNode, typeSolver);
}
}
|
if (typeSolver == null) throw new IllegalArgumentException();
if (this.getDeclaration().hasField(name)) {
return SymbolReference.solved(this.getDeclaration().getField(name));
}
// then to parent
return solveSymbolInParentContext(name);
| 301
| 74
| 375
|
<methods>public void <init>(com.github.javaparser.ast.body.AnnotationDeclaration, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.body.AnnotationDeclaration getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.body.AnnotationDeclaration wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/AnonymousClassDeclarationContext.java
|
AnonymousClassDeclarationContext
|
solveType
|
class AnonymousClassDeclarationContext extends AbstractJavaParserContext<ObjectCreationExpr> {
private final JavaParserAnonymousClassDeclaration myDeclaration =
new JavaParserAnonymousClassDeclaration(wrappedNode, typeSolver);
public AnonymousClassDeclarationContext(ObjectCreationExpr node, TypeSolver typeSolver) {
super(node, typeSolver);
Preconditions.checkArgument(node.getAnonymousClassBody().isPresent(),
"An anonymous class must have a body");
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name,
List<ResolvedType> argumentsTypes,
boolean staticOnly) {
List<ResolvedMethodDeclaration> candidateMethods = myDeclaration
.getDeclaredMethods()
.stream()
.filter(m -> m.getName().equals(name) && (!staticOnly || m.isStatic()))
.collect(Collectors.toList());
if (!myDeclaration.isJavaLangObject()) {
for (ResolvedReferenceType ancestor : myDeclaration.getAncestors()) {
ancestor.getTypeDeclaration().ifPresent(ancestorTypeDeclaration -> {
SymbolReference<ResolvedMethodDeclaration> res = MethodResolutionLogic.solveMethodInType(
ancestorTypeDeclaration,
name,
argumentsTypes,
staticOnly
);
// consider methods from superclasses and only default methods from interfaces :
// not true, we should keep abstract as a valid candidate
// abstract are removed in MethodResolutionLogic.isApplicable is necessary
if (res.isSolved()) {
candidateMethods.add(res.getCorrespondingDeclaration());
}
});
}
}
// We want to avoid infinite recursion when a class is using its own method
// see issue #75
if (candidateMethods.isEmpty()) {
SymbolReference<ResolvedMethodDeclaration> parentSolution =
getParent()
.orElseThrow(() -> new RuntimeException("Parent context unexpectedly empty."))
.solveMethod(name, argumentsTypes, staticOnly);
if (parentSolution.isSolved()) {
candidateMethods.add(parentSolution.getCorrespondingDeclaration());
}
}
// if is interface and candidate method list is empty, we should check the Object Methods
if (candidateMethods.isEmpty() && myDeclaration.getSuperTypeDeclaration().isInterface()) {
SymbolReference<ResolvedMethodDeclaration> res =
MethodResolutionLogic.solveMethodInType(new ReflectionClassDeclaration(Object.class,
typeSolver),
name,
argumentsTypes,
false);
if (res.isSolved()) {
candidateMethods.add(res.getCorrespondingDeclaration());
}
}
return MethodResolutionLogic.findMostApplicable(candidateMethods,
name,
argumentsTypes,
typeSolver);
}
@Override
public SymbolReference<ResolvedTypeDeclaration> solveType(String name, List<ResolvedType> typeArguments) {<FILL_FUNCTION_BODY>}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
Preconditions.checkArgument(typeSolver != null);
if (myDeclaration.hasField(name)) {
return SymbolReference.solved(myDeclaration.getField(name));
}
return solveSymbolInParentContext(name);
}
}
|
List<TypeDeclaration> typeDeclarations = myDeclaration.findMembersOfKind(TypeDeclaration.class);
Optional<SymbolReference<ResolvedTypeDeclaration>> exactMatch =
typeDeclarations
.stream()
.filter(internalType -> internalType.getName().getId().equals(name))
.findFirst()
.map(internalType ->
SymbolReference.solved(
JavaParserFacade.get(typeSolver).getTypeDeclaration(internalType)));
if(exactMatch.isPresent()){
return exactMatch.get();
}
Optional<SymbolReference<ResolvedTypeDeclaration>> recursiveMatch =
typeDeclarations
.stream()
.filter(internalType -> name.startsWith(String.format("%s.", internalType.getName())))
.findFirst()
.map(internalType ->
JavaParserFactory
.getContext(internalType, typeSolver)
.solveType(name.substring(internalType.getName().getId().length() + 1)));
if (recursiveMatch.isPresent()) {
return recursiveMatch.get();
}
Optional<SymbolReference<ResolvedTypeDeclaration>> typeArgumentsMatch =
wrappedNode
.getTypeArguments()
.map(nodes ->
((NodeWithTypeArguments<?>) nodes).getTypeArguments()
.orElse(new NodeList<>()))
.orElse(new NodeList<>())
.stream()
.filter(type -> type.toString().equals(name))
.findFirst()
.map(matchingType ->
SymbolReference.solved(
new JavaParserTypeParameter(new TypeParameter(matchingType.toString()),
typeSolver)));
if (typeArgumentsMatch.isPresent()) {
return typeArgumentsMatch.get();
}
// Look into extended classes and implemented interfaces
for (ResolvedReferenceType ancestor : myDeclaration.getAncestors()) {
// look at names of extended classes and implemented interfaces (this may not be important because they are checked in CompilationUnitContext)
Optional<ResolvedReferenceTypeDeclaration> optionalTypeDeclaration = ancestor.getTypeDeclaration();
if (optionalTypeDeclaration.isPresent()) {
ResolvedReferenceTypeDeclaration typeDeclaration = optionalTypeDeclaration.get();
if (typeDeclaration.getName().equals(name)) {
return SymbolReference.solved(typeDeclaration);
}
// look into internal types of extended classes and implemented interfaces
try {
for (ResolvedTypeDeclaration internalTypeDeclaration : typeDeclaration.internalTypes()) {
if (internalTypeDeclaration.getName().equals(name)) {
return SymbolReference.solved(internalTypeDeclaration);
}
}
} catch (UnsupportedOperationException e) {
// just continue using the next ancestor
}
}
}
return solveTypeInParentContext(name, typeArguments);
| 855
| 707
| 1,562
|
<methods>public void <init>(com.github.javaparser.ast.expr.ObjectCreationExpr, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.expr.ObjectCreationExpr getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.expr.ObjectCreationExpr wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ArrayAccessExprContext.java
|
ArrayAccessExprContext
|
solveSymbolInParentContext
|
class ArrayAccessExprContext extends AbstractJavaParserContext<ArrayAccessExpr> {
public ArrayAccessExprContext(ArrayAccessExpr wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbolInParentContext(String name) {<FILL_FUNCTION_BODY>}
}
|
/*
* Simple implementation, included explicitly here for clarity:
* - Delegate to parent context per the documentation for ArrayAccessExprContext
* - Required to prevent recursive access to the "parent node" (not necessarily the same as the "parent context")
*/
return super.solveSymbolInParentContext(name);
| 95
| 81
| 176
|
<methods>public void <init>(com.github.javaparser.ast.expr.ArrayAccessExpr, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.expr.ArrayAccessExpr getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.expr.ArrayAccessExpr wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/BlockStmtContext.java
|
BlockStmtContext
|
solveSymbol
|
class BlockStmtContext extends AbstractJavaParserContext<BlockStmt> {
public BlockStmtContext(BlockStmt wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public List<VariableDeclarator> localVariablesExposedToChild(Node child) {
int position = wrappedNode.getStatements().indexOf(child);
if (position == -1) {
throw new RuntimeException();
}
List<VariableDeclarator> variableDeclarators = new LinkedList<>();
for (int i = position - 1; i >= 0; i--) {
variableDeclarators.addAll(localVariablesDeclaredIn(wrappedNode.getStatement(i)));
}
return variableDeclarators;
}
private List<VariableDeclarator> localVariablesDeclaredIn(Statement statement) {
if (statement instanceof ExpressionStmt) {
ExpressionStmt expressionStmt = (ExpressionStmt) statement;
if (expressionStmt.getExpression() instanceof VariableDeclarationExpr) {
VariableDeclarationExpr variableDeclarationExpr = (VariableDeclarationExpr) expressionStmt.getExpression();
List<VariableDeclarator> variableDeclarators = new LinkedList<>();
variableDeclarators.addAll(variableDeclarationExpr.getVariables());
return variableDeclarators;
}
}
return Collections.emptyList();
}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {<FILL_FUNCTION_BODY>}
}
|
Optional<Context> optionalParent = getParent();
if (!optionalParent.isPresent()) {
return SymbolReference.unsolved();
}
if (wrappedNode.getStatements().size() > 0) {
// tries to resolve a declaration from local variables defined in child statements
// or from parent node context
// for example resolve declaration for the MethodCallExpr a.method() in
// A a = this;
// {
// a.method();
// }
List<VariableDeclarator> variableDeclarators = new LinkedList<>();
// find all variable declarators exposed to child
// given that we don't know the statement we are trying to resolve, we look for all variable declarations
// defined in the context of the wrapped node whether it is located before or after the statement that interests us
// because a variable cannot be (re)defined after having been used
wrappedNode.getStatements().getLast().ifPresent(stmt -> variableDeclarators.addAll(localVariablesExposedToChild(stmt)));
if (!variableDeclarators.isEmpty()) {
// FIXME: Work backwards from the current statement, to only consider declarations prior to this statement.
for (VariableDeclarator vd : variableDeclarators) {
if (vd.getNameAsString().equals(name)) {
return SymbolReference.solved(JavaParserSymbolDeclaration.localVar(vd, typeSolver));
}
}
}
}
// Otherwise continue as normal...
return solveSymbolInParentContext(name);
| 391
| 378
| 769
|
<methods>public void <init>(com.github.javaparser.ast.stmt.BlockStmt, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.stmt.BlockStmt getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.stmt.BlockStmt wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/CatchClauseContext.java
|
CatchClauseContext
|
solveSymbolAsValue
|
class CatchClauseContext extends AbstractJavaParserContext<CatchClause> {
public CatchClauseContext(CatchClause wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public final SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
SymbolDeclarator sb = JavaParserFactory.getSymbolDeclarator(wrappedNode.getParameter(), typeSolver);
SymbolReference<? extends ResolvedValueDeclaration> symbolReference = AbstractJavaParserContext.solveWith(sb, name);
if (symbolReference.isSolved()) {
return symbolReference;
}
// if nothing is found we should ask the parent context
return solveSymbolInParentContext(name);
}
@Override
public final Optional<Value> solveSymbolAsValue(String name) {<FILL_FUNCTION_BODY>}
@Override
public final SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) {
// TODO: Document why staticOnly is forced to be false.
return solveMethodInParentContext(name, argumentsTypes, false);
}
@Override
public List<VariableDeclarator> localVariablesExposedToChild(Node child) {
return Collections.emptyList();
}
@Override
public List<Parameter> parametersExposedToChild(Node child) {
// TODO/FIXME: Presumably the parameters must be exposed to all children and their descendants, not just the direct child?
if (child == getWrappedNode().getBody()) {
return Collections.singletonList(getWrappedNode().getParameter());
}
return Collections.emptyList();
}
}
|
SymbolDeclarator sb = JavaParserFactory.getSymbolDeclarator(wrappedNode.getParameter(), typeSolver);
Optional<Value> symbolReference = solveWithAsValue(sb, name);
if (symbolReference.isPresent()) {
// Perform parameter type substitution as needed
return symbolReference;
}
// if nothing is found we should ask the parent context
return solveSymbolAsValueInParentContext(name);
| 439
| 108
| 547
|
<methods>public void <init>(com.github.javaparser.ast.stmt.CatchClause, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.stmt.CatchClause getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.stmt.CatchClause wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ClassOrInterfaceDeclarationContext.java
|
ClassOrInterfaceDeclarationContext
|
fieldsExposedToChild
|
class ClassOrInterfaceDeclarationContext extends AbstractJavaParserContext<ClassOrInterfaceDeclaration> {
private JavaParserTypeDeclarationAdapter javaParserTypeDeclarationAdapter;
///
/// Constructors
///
public ClassOrInterfaceDeclarationContext(ClassOrInterfaceDeclaration wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
this.javaParserTypeDeclarationAdapter = new JavaParserTypeDeclarationAdapter(wrappedNode, typeSolver,
getDeclaration(), this);
}
///
/// Public methods
///
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
if (typeSolver == null) throw new IllegalArgumentException();
if (this.getDeclaration().hasVisibleField(name)) {
return SymbolReference.solved(this.getDeclaration().getVisibleField(name));
}
// then to parent
return solveSymbolInParentContext(name);
}
@Override
public Optional<Value> solveSymbolAsValue(String name) {
if (typeSolver == null) throw new IllegalArgumentException();
if (this.getDeclaration().hasField(name)) {
return Optional.of(Value.from(this.getDeclaration().getField(name)));
}
// then to parent
return solveSymbolAsValueInParentContext(name);
}
@Override
public Optional<ResolvedType> solveGenericType(String name) {
// First check if the method-like declaration has type parameters defined.
// For example: {@code public <T> boolean containsAll(Collection<T> c);}
for (TypeParameter tp : wrappedNode.getTypeParameters()) {
if (tp.getName().getId().equals(name)) {
return Optional.of(new ResolvedTypeVariable(new JavaParserTypeParameter(tp, typeSolver)));
}
}
// If no generic types on the method declaration, continue to solve as usual.
return solveGenericTypeInParentContext(name);
}
@Override
public SymbolReference<ResolvedTypeDeclaration> solveType(String name, List<ResolvedType> typeArguments) {
return javaParserTypeDeclarationAdapter.solveType(name, typeArguments);
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) {
return javaParserTypeDeclarationAdapter.solveMethod(name, argumentsTypes, staticOnly);
}
public SymbolReference<ResolvedConstructorDeclaration> solveConstructor(List<ResolvedType> argumentsTypes) {
return javaParserTypeDeclarationAdapter.solveConstructor(argumentsTypes);
}
@Override
public List<ResolvedFieldDeclaration> fieldsExposedToChild(Node child) {<FILL_FUNCTION_BODY>}
///
/// Private methods
///
private ResolvedReferenceTypeDeclaration getDeclaration() {
return JavaParserFacade.get(typeSolver).getTypeDeclaration(this.wrappedNode);
}
}
|
List<ResolvedFieldDeclaration> fields = new LinkedList<>();
fields.addAll(this.wrappedNode.resolve().getDeclaredFields());
this.wrappedNode.getExtendedTypes().forEach(i -> fields.addAll(i.resolve().asReferenceType().getAllFieldsVisibleToInheritors()));
this.wrappedNode.getImplementedTypes().forEach(i -> fields.addAll(i.resolve().asReferenceType().getAllFieldsVisibleToInheritors()));
return fields;
| 739
| 125
| 864
|
<methods>public void <init>(com.github.javaparser.ast.body.ClassOrInterfaceDeclaration, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.body.ClassOrInterfaceDeclaration getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.body.ClassOrInterfaceDeclaration wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ClassOrInterfaceDeclarationExtendsContext.java
|
ClassOrInterfaceDeclarationExtendsContext
|
solveType
|
class ClassOrInterfaceDeclarationExtendsContext extends AbstractJavaParserContext<ClassOrInterfaceDeclaration> {
public ClassOrInterfaceDeclarationExtendsContext(ClassOrInterfaceDeclaration wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public SymbolReference<ResolvedTypeDeclaration> solveType(String name, List<ResolvedType> typeArguments) {<FILL_FUNCTION_BODY>}
}
|
for (TypeParameter typeParameter : wrappedNode.getTypeParameters()) {
if (typeParameter.getName().getId().equals(name)) {
return SymbolReference.solved(new JavaParserTypeParameter(typeParameter, typeSolver));
}
}
return super.solveType(name, typeArguments);
| 108
| 79
| 187
|
<methods>public void <init>(com.github.javaparser.ast.body.ClassOrInterfaceDeclaration, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.body.ClassOrInterfaceDeclaration getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.body.ClassOrInterfaceDeclaration wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ConstructorContext.java
|
ConstructorContext
|
parametersExposedToChild
|
class ConstructorContext extends AbstractMethodLikeDeclarationContext<ConstructorDeclaration> {
///
/// Constructors
///
public ConstructorContext(ConstructorDeclaration wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public List<Parameter> parametersExposedToChild(Node child) {<FILL_FUNCTION_BODY>}
}
|
// TODO/FIXME: Presumably the parameters must be exposed to all children and their descendants, not just the direct child?
if (child == wrappedNode.getBody()) {
return wrappedNode.getParameters();
}
return Collections.emptyList();
| 101
| 67
| 168
|
<methods>public void <init>(com.github.javaparser.ast.body.ConstructorDeclaration, com.github.javaparser.resolution.TypeSolver) ,public final Optional<com.github.javaparser.resolution.types.ResolvedType> solveGenericType(java.lang.String) ,public final SymbolReference<com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration> solveMethod(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>, boolean) ,public final SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbol(java.lang.String) ,public final Optional<com.github.javaparser.resolution.model.Value> solveSymbolAsValue(java.lang.String) ,public final SymbolReference<com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration> solveType(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) <variables>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ContextHelper.java
|
ContextHelper
|
solveMethodAsUsage
|
class ContextHelper {
private ContextHelper() {
// prevent instantiation
}
public static Optional<MethodUsage> solveMethodAsUsage(ResolvedTypeDeclaration typeDeclaration, String name,
List<ResolvedType> argumentsTypes, Context invokationContext,
List<ResolvedType> typeParameters) {<FILL_FUNCTION_BODY>}
}
|
if (typeDeclaration instanceof MethodUsageResolutionCapability) {
return ((MethodUsageResolutionCapability) typeDeclaration)
.solveMethodAsUsage(name, argumentsTypes, invokationContext, typeParameters);
}
throw new UnsupportedOperationException(typeDeclaration.toString());
| 92
| 72
| 164
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/EnclosedExprContext.java
|
EnclosedExprContext
|
negatedPatternExprsExposedFromChildren
|
class EnclosedExprContext extends AbstractJavaParserContext<EnclosedExpr> {
public EnclosedExprContext(EnclosedExpr wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public List<PatternExpr> patternExprsExposedFromChildren() {
List<PatternExpr> results = new ArrayList<>();
/*
* Test for an assignment expression
* Example:
* while ((numChars = reader.read(buffer, 0, buffer.length)) > 0) {
* result.append(buffer, 0, numChars);
* }
*/
if(!wrappedNode.getInner().isAssignExpr()) {
// Propagate any pattern expressions "up" without modification
Context innerContext = JavaParserFactory.getContext(wrappedNode.getInner(), typeSolver);
if (!this.equals(innerContext)) {
results = new ArrayList<>(innerContext.patternExprsExposedFromChildren());
}
}
return results;
}
@Override
public List<PatternExpr> negatedPatternExprsExposedFromChildren() {<FILL_FUNCTION_BODY>}
}
|
List<PatternExpr> results = new ArrayList<>();
/*
* Test for an assignment expression
* Example:
* while ((numChars = reader.read(buffer, 0, buffer.length)) > 0) {
* result.append(buffer, 0, numChars);
* }
*/
if(!wrappedNode.getInner().isAssignExpr()) {
// Propagate any pattern expressions "up" without modification
Context innerContext = JavaParserFactory.getContext(wrappedNode.getInner(), typeSolver);
if (!this.equals(innerContext)) {
results = new ArrayList<>(innerContext.negatedPatternExprsExposedFromChildren());
}
}
return results;
| 298
| 184
| 482
|
<methods>public void <init>(com.github.javaparser.ast.expr.EnclosedExpr, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.expr.EnclosedExpr getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.expr.EnclosedExpr wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/EnumDeclarationContext.java
|
EnumDeclarationContext
|
solveSymbol
|
class EnumDeclarationContext extends AbstractJavaParserContext<EnumDeclaration> {
private JavaParserTypeDeclarationAdapter javaParserTypeDeclarationAdapter;
public EnumDeclarationContext(EnumDeclaration wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
this.javaParserTypeDeclarationAdapter = new JavaParserTypeDeclarationAdapter(wrappedNode, typeSolver,
getDeclaration(), this);
}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {<FILL_FUNCTION_BODY>}
@Override
public SymbolReference<ResolvedTypeDeclaration> solveType(String name, List<ResolvedType> resolvedTypes) {
return javaParserTypeDeclarationAdapter.solveType(name, resolvedTypes);
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) {
return javaParserTypeDeclarationAdapter.solveMethod(name, argumentsTypes, staticOnly);
}
///
/// Private methods
///
private ResolvedReferenceTypeDeclaration getDeclaration() {
return new JavaParserEnumDeclaration(this.wrappedNode, typeSolver);
}
}
|
if (typeSolver == null) throw new IllegalArgumentException();
// among constants
for (EnumConstantDeclaration constant : wrappedNode.getEntries()) {
if (constant.getName().getId().equals(name)) {
return SymbolReference.solved(new JavaParserEnumConstantDeclaration(constant, typeSolver));
}
}
if (this.getDeclaration().hasField(name)) {
return SymbolReference.solved(this.getDeclaration().getField(name));
}
// then to parent
return solveSymbolInParentContext(name);
| 301
| 140
| 441
|
<methods>public void <init>(com.github.javaparser.ast.body.EnumDeclaration, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.body.EnumDeclaration getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.body.EnumDeclaration wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/FieldAccessContext.java
|
FieldAccessContext
|
solveSymbolAsValue
|
class FieldAccessContext extends AbstractJavaParserContext<FieldAccessExpr> {
private static final String ARRAY_LENGTH_FIELD_NAME = "length";
public FieldAccessContext(FieldAccessExpr wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
if (wrappedNode.getName().toString().equals(name)) {
if (wrappedNode.getScope() instanceof ThisExpr) {
ResolvedType typeOfThis = JavaParserFacade.get(typeSolver).getTypeOfThisIn(wrappedNode);
if(typeOfThis.asReferenceType().getTypeDeclaration().isPresent()) {
return new SymbolSolver(typeSolver).solveSymbolInType(
typeOfThis.asReferenceType().getTypeDeclaration().get(),
name
);
}
}
}
return JavaParserFactory.getContext(demandParentNode(wrappedNode), typeSolver).solveSymbol(name);
}
@Override
public SymbolReference<ResolvedTypeDeclaration> solveType(String name, List<ResolvedType> typeArguments) {
return JavaParserFactory.getContext(demandParentNode(wrappedNode), typeSolver).solveType(name, typeArguments);
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> parameterTypes, boolean staticOnly) {
return JavaParserFactory.getContext(demandParentNode(wrappedNode), typeSolver).solveMethod(name, parameterTypes, false);
}
@Override
public Optional<Value> solveSymbolAsValue(String name) {
Expression scope = wrappedNode.getScope();
if (wrappedNode.getName().toString().equals(name)) {
ResolvedType typeOfScope = JavaParserFacade.get(typeSolver).getType(scope);
if (typeOfScope.isArray() && ARRAY_LENGTH_FIELD_NAME.equals(name)) {
return Optional.of(new Value(ResolvedPrimitiveType.INT, ARRAY_LENGTH_FIELD_NAME));
}
if (typeOfScope.isReferenceType()) {
return solveSymbolAsValue(name, typeOfScope.asReferenceType());
}
if (typeOfScope.isConstraint()) {
return solveSymbolAsValue(name, typeOfScope.asConstraintType().getBound().asReferenceType());
}
return Optional.empty();
}
return solveSymbolAsValueInParentContext(name);
}
/*
* Try to resolve the name parameter as a field of the reference type
*/
private Optional<Value> solveSymbolAsValue(String name, ResolvedReferenceType type) {<FILL_FUNCTION_BODY>}
public SymbolReference<ResolvedValueDeclaration> solveField(String name) {
Collection<ResolvedReferenceTypeDeclaration> rrtds = findTypeDeclarations(Optional.of(wrappedNode.getScope()));
for (ResolvedReferenceTypeDeclaration rrtd : rrtds) {
if (rrtd.isEnum()) {
Optional<ResolvedEnumConstantDeclaration> enumConstant = rrtd.asEnum().getEnumConstants().stream().filter(c -> c.getName().equals(name)).findFirst();
if (enumConstant.isPresent()) {
return SymbolReference.solved(enumConstant.get());
}
}
try {
return SymbolReference.solved(rrtd.getField(wrappedNode.getName().getId()));
} catch (Throwable t) {
}
}
return SymbolReference.unsolved();
}
}
|
Optional<ResolvedReferenceTypeDeclaration> optionalTypeDeclaration = type.getTypeDeclaration();
if (optionalTypeDeclaration.isPresent()) {
ResolvedReferenceTypeDeclaration typeDeclaration = optionalTypeDeclaration.get();
if (typeDeclaration.isEnum()) {
ResolvedEnumDeclaration enumDeclaration = (ResolvedEnumDeclaration) typeDeclaration;
if (enumDeclaration.hasEnumConstant(name)) {
return Optional.of(new Value(enumDeclaration.getEnumConstant(name).getType(), name));
}
}
}
Optional<ResolvedType> typeUsage = type.getFieldType(name);
return typeUsage.map(resolvedType -> new Value(resolvedType, name));
| 908
| 168
| 1,076
|
<methods>public void <init>(com.github.javaparser.ast.expr.FieldAccessExpr, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.expr.FieldAccessExpr getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.expr.FieldAccessExpr wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForEachStatementContext.java
|
ForEachStatementContext
|
localVariablesExposedToChild
|
class ForEachStatementContext extends AbstractJavaParserContext<ForEachStmt> {
public ForEachStatementContext(ForEachStmt wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
if (wrappedNode.getVariable().getVariables().size() != 1) {
throw new IllegalStateException();
}
VariableDeclarator variableDeclarator = wrappedNode.getVariable().getVariables().get(0);
if (variableDeclarator.getName().getId().equals(name)) {
return SymbolReference.solved(JavaParserSymbolDeclaration.localVar(variableDeclarator, typeSolver));
}
if (demandParentNode(wrappedNode) instanceof BlockStmt) {
return StatementContext.solveInBlock(name, typeSolver, wrappedNode);
}
return solveSymbolInParentContext(name);
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) {
// TODO: Document why staticOnly is forced to be false.
return solveMethodInParentContext(name, argumentsTypes, false);
}
@Override
public List<VariableDeclarator> localVariablesExposedToChild(Node child) {<FILL_FUNCTION_BODY>}
}
|
if (child == wrappedNode.getBody()) {
return wrappedNode.getVariable().getVariables();
}
return Collections.emptyList();
| 357
| 41
| 398
|
<methods>public void <init>(com.github.javaparser.ast.stmt.ForEachStmt, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.stmt.ForEachStmt getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.stmt.ForEachStmt wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForStatementContext.java
|
ForStatementContext
|
localVariablesExposedToChild
|
class ForStatementContext extends AbstractJavaParserContext<ForStmt> {
public ForStatementContext(ForStmt wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
for (Expression expression : wrappedNode.getInitialization()) {
if (expression instanceof VariableDeclarationExpr) {
VariableDeclarationExpr variableDeclarationExpr = (VariableDeclarationExpr) expression;
for (VariableDeclarator variableDeclarator : variableDeclarationExpr.getVariables()) {
if (variableDeclarator.getName().getId().equals(name)) {
return SymbolReference.solved(JavaParserSymbolDeclaration.localVar(variableDeclarator, typeSolver));
}
}
} else if (!(expression instanceof AssignExpr || expression instanceof MethodCallExpr || expression instanceof UnaryExpr)) {
throw new UnsupportedOperationException(expression.getClass().getCanonicalName());
}
}
if (demandParentNode(wrappedNode) instanceof NodeWithStatements) {
return StatementContext.solveInBlock(name, typeSolver, wrappedNode);
}
return solveSymbolInParentContext(name);
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) {
// TODO: Document why staticOnly is forced to be false.
return solveMethodInParentContext(name, argumentsTypes, false);
}
@Override
public List<VariableDeclarator> localVariablesExposedToChild(Node child) {<FILL_FUNCTION_BODY>}
}
|
List<VariableDeclarator> res = new LinkedList<>();
for (Expression expression : wrappedNode.getInitialization()) {
if (expression instanceof VariableDeclarationExpr) {
VariableDeclarationExpr variableDeclarationExpr = (VariableDeclarationExpr) expression;
res.addAll(variableDeclarationExpr.getVariables());
}
}
return res;
| 416
| 89
| 505
|
<methods>public void <init>(com.github.javaparser.ast.stmt.ForStmt, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.stmt.ForStmt getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.stmt.ForStmt wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/IfStatementContext.java
|
IfStatementContext
|
nodeContextIsThenOfIfStmt
|
class IfStatementContext extends StatementContext<IfStmt> {
//public class IfStatementContext extends AbstractJavaParserContext<IfStmt> {
public IfStatementContext(IfStmt wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public List<PatternExpr> patternExprsExposedToChild(Node child) {
Expression condition = wrappedNode.getCondition();
Context conditionContext = JavaParserFactory.getContext(condition, typeSolver);
List<PatternExpr> results = new ArrayList<>();
boolean givenNodeIsWithinThenStatement = wrappedNode.getThenStmt().containsWithinRange(child);
if(givenNodeIsWithinThenStatement) {
results.addAll(conditionContext.patternExprsExposedFromChildren());
}
wrappedNode.getElseStmt().ifPresent(elseStatement -> {
boolean givenNodeIsWithinElseStatement = elseStatement.containsWithinRange(child);
if(givenNodeIsWithinElseStatement) {
results.addAll(conditionContext.negatedPatternExprsExposedFromChildren());
}
});
return results;
}
/**
* <pre>{@code
* if() {
* // Does not match here (doesn't need to, as stuff inside of the if() is likely in context..)
* } else if() {
* // Matches here
* } else {
* // Matches here
* }
* }</pre>
*
* @return true, If this is an if inside of an if...
*/
public boolean nodeContextIsChainedIfElseIf(Context parentContext) {
return parentContext instanceof AbstractJavaParserContext
&& ((AbstractJavaParserContext<?>) this).getWrappedNode() instanceof IfStmt
&& ((AbstractJavaParserContext<?>) parentContext).getWrappedNode() instanceof IfStmt;
}
/**
* <pre>{@code
* if() {
* // Does not match here (doesn't need to, as stuff inside of the if() is likely in context..)
* } else {
* // Does not match here, as the else block is a field inside of an ifstmt as opposed to child
* }
* }</pre>
*
* @return true, If this is an else inside of an if...
*/
public boolean nodeContextIsImmediateChildElse(Context parentContext) {
if (!(parentContext instanceof AbstractJavaParserContext)) {
return false;
}
if (!(this instanceof AbstractJavaParserContext)) {
return false;
}
AbstractJavaParserContext<?> abstractContext = (AbstractJavaParserContext<?>) this;
AbstractJavaParserContext<?> abstractParentContext = (AbstractJavaParserContext<?>) parentContext;
Node wrappedNode = abstractContext.getWrappedNode();
Node wrappedParentNode = abstractParentContext.getWrappedNode();
if (wrappedParentNode instanceof IfStmt) {
IfStmt parentIfStmt = (IfStmt) wrappedParentNode;
if (parentIfStmt.getElseStmt().isPresent()) {
boolean currentNodeIsAnElseBlock = parentIfStmt.getElseStmt().get() == wrappedNode;
if (currentNodeIsAnElseBlock) {
return true;
}
}
}
return false;
}
/**
* <pre>{@code
* if() {
* // Does not match here (doesn't need to, as stuff inside of the if() is likely in context..)
* } else {
* // Does not match here, as the else block is a field inside of an ifstmt as opposed to child
* }
* }</pre>
*
* @return true, If this is an else inside of an if...
*/
public boolean nodeContextIsThenOfIfStmt(Context parentContext) {<FILL_FUNCTION_BODY>}
public boolean nodeContextIsConditionOfIfStmt(Context parentContext) {
if (!(parentContext instanceof AbstractJavaParserContext)) {
return false;
}
if (!(this instanceof AbstractJavaParserContext)) {
return false;
}
AbstractJavaParserContext<?> abstractContext = (AbstractJavaParserContext<?>) this;
AbstractJavaParserContext<?> abstractParentContext = (AbstractJavaParserContext<?>) parentContext;
Node wrappedNode = abstractContext.getWrappedNode();
Node wrappedParentNode = abstractParentContext.getWrappedNode();
if (wrappedParentNode instanceof IfStmt) {
IfStmt parentIfStmt = (IfStmt) wrappedParentNode;
boolean currentNodeIsCondition = parentIfStmt.getCondition() == wrappedNode;
if (currentNodeIsCondition) {
return true;
}
}
return false;
}
}
|
if (!(parentContext instanceof AbstractJavaParserContext)) {
return false;
}
if (!(this instanceof AbstractJavaParserContext)) {
return false;
}
AbstractJavaParserContext<?> abstractContext = (AbstractJavaParserContext<?>) this;
AbstractJavaParserContext<?> abstractParentContext = (AbstractJavaParserContext<?>) parentContext;
Node wrappedNode = abstractContext.getWrappedNode();
Node wrappedParentNode = abstractParentContext.getWrappedNode();
if (wrappedParentNode instanceof IfStmt) {
IfStmt parentIfStmt = (IfStmt) wrappedParentNode;
boolean currentNodeIsAnElseBlock = parentIfStmt.getThenStmt() == wrappedNode;
if (currentNodeIsAnElseBlock) {
return true;
}
}
return false;
| 1,237
| 215
| 1,452
|
<methods>public void <init>(com.github.javaparser.ast.stmt.IfStmt, com.github.javaparser.resolution.TypeSolver) ,public List<com.github.javaparser.ast.expr.PatternExpr> negatedPatternExprsExposedFromChildren() ,public List<com.github.javaparser.ast.expr.PatternExpr> patternExprsExposedFromChildren() ,public static SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveInBlock(java.lang.String, com.github.javaparser.resolution.TypeSolver, com.github.javaparser.ast.stmt.Statement) ,public static Optional<com.github.javaparser.resolution.model.Value> solveInBlockAsValue(java.lang.String, com.github.javaparser.resolution.TypeSolver, com.github.javaparser.ast.stmt.Statement) ,public SymbolReference<com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration> solveMethod(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>, boolean) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbol(java.lang.String) ,public Optional<com.github.javaparser.resolution.model.Value> solveSymbolAsValue(java.lang.String) <variables>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/InstanceOfExprContext.java
|
InstanceOfExprContext
|
patternExprsExposedFromChildren
|
class InstanceOfExprContext extends AbstractJavaParserContext<InstanceOfExpr> {
public InstanceOfExprContext(InstanceOfExpr wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
Optional<PatternExpr> optionalPatternExpr = wrappedNode.getPattern();
if(optionalPatternExpr.isPresent()) {
if(optionalPatternExpr.get().getNameAsString().equals(name)) {
JavaParserPatternDeclaration decl = JavaParserSymbolDeclaration.patternVar(optionalPatternExpr.get(), typeSolver);
return SymbolReference.solved(decl);
}
}
Optional<Context> optionalParentContext = getParent();
if (!optionalParentContext.isPresent()) {
return SymbolReference.unsolved();
}
Context parentContext = optionalParentContext.get();
if(parentContext instanceof BinaryExprContext) {
Optional<PatternExpr> optionalPatternExpr1 = parentContext.patternExprInScope(name);
if(optionalPatternExpr1.isPresent()) {
JavaParserPatternDeclaration decl = JavaParserSymbolDeclaration.patternVar(optionalPatternExpr1.get(), typeSolver);
return SymbolReference.solved(decl);
}
} // TODO: Also consider unary expr context
// if nothing is found we should ask the parent context
return solveSymbolInParentContext(name);
}
@Override
public List<PatternExpr> patternExprsExposedFromChildren() {<FILL_FUNCTION_BODY>}
}
|
List<PatternExpr> results = new ArrayList<>();
// If this instanceof expression has a pattern, add it to the list.
wrappedNode.getPattern().ifPresent(results::add);
return results;
| 397
| 55
| 452
|
<methods>public void <init>(com.github.javaparser.ast.expr.InstanceOfExpr, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.expr.InstanceOfExpr getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.expr.InstanceOfExpr wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodContext.java
|
MethodContext
|
parametersExposedToChild
|
class MethodContext extends AbstractMethodLikeDeclarationContext<MethodDeclaration> {
///
/// Constructors
///
public MethodContext(MethodDeclaration wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public List<Parameter> parametersExposedToChild(Node child) {<FILL_FUNCTION_BODY>}
}
|
// TODO/FIXME: Presumably the parameters must be exposed to all children and their descendants, not just the direct child?
if (wrappedNode.getBody().isPresent() && child == wrappedNode.getBody().get()) {
return wrappedNode.getParameters();
}
return Collections.emptyList();
| 99
| 80
| 179
|
<methods>public void <init>(com.github.javaparser.ast.body.MethodDeclaration, com.github.javaparser.resolution.TypeSolver) ,public final Optional<com.github.javaparser.resolution.types.ResolvedType> solveGenericType(java.lang.String) ,public final SymbolReference<com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration> solveMethod(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>, boolean) ,public final SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbol(java.lang.String) ,public final Optional<com.github.javaparser.resolution.model.Value> solveSymbolAsValue(java.lang.String) ,public final SymbolReference<com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration> solveType(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) <variables>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/ObjectCreationContext.java
|
ObjectCreationContext
|
solveType
|
class ObjectCreationContext extends AbstractJavaParserContext<ObjectCreationExpr> {
public ObjectCreationContext(ObjectCreationExpr wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public SymbolReference<ResolvedTypeDeclaration> solveType(String name, List<ResolvedType> typeArguments) {<FILL_FUNCTION_BODY>}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
return JavaParserFactory.getContext(demandParentNode(wrappedNode), typeSolver).solveSymbol(name);
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) {
return JavaParserFactory.getContext(demandParentNode(wrappedNode), typeSolver).solveMethod(name, argumentsTypes, false);
}
}
|
if (wrappedNode.hasScope()) {
Expression scope = wrappedNode.getScope().get();
ResolvedType scopeType = JavaParserFacade.get(typeSolver).getType(scope);
// Be careful, the scope can be an object creation expression like <code>new inner().new Other()</code>
if (scopeType.isReferenceType() && scopeType.asReferenceType().getTypeDeclaration().isPresent()) {
ResolvedReferenceTypeDeclaration scopeTypeDeclaration = scopeType.asReferenceType().getTypeDeclaration().get();
for (ResolvedTypeDeclaration it : scopeTypeDeclaration.internalTypes()) {
if (it.getName().equals(name)) {
return SymbolReference.solved(it);
}
}
}
}
// find first parent node that is not an object creation expression to avoid stack overflow errors, see #1711
Node parentNode = demandParentNode(wrappedNode);
while (parentNode instanceof ObjectCreationExpr) {
parentNode = demandParentNode(parentNode);
}
return JavaParserFactory.getContext(parentNode, typeSolver).solveType(name, typeArguments);
| 235
| 283
| 518
|
<methods>public void <init>(com.github.javaparser.ast.expr.ObjectCreationExpr, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.expr.ObjectCreationExpr getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.expr.ObjectCreationExpr wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/SwitchEntryContext.java
|
SwitchEntryContext
|
solveSymbol
|
class SwitchEntryContext extends AbstractJavaParserContext<SwitchEntry> {
public SwitchEntryContext(SwitchEntry wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {<FILL_FUNCTION_BODY>}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) {
// TODO: Document why staticOnly is forced to be false.
return solveMethodInParentContext(name, argumentsTypes, false);
}
}
|
SwitchNode switchNode = (SwitchNode) demandParentNode(wrappedNode);
ResolvedType type = JavaParserFacade.get(typeSolver).getType(switchNode.getSelector());
if (type.isReferenceType() && type.asReferenceType().getTypeDeclaration().isPresent()) {
ResolvedReferenceTypeDeclaration typeDeclaration = type.asReferenceType().getTypeDeclaration().get();
if (typeDeclaration.isEnum()) {
if (type instanceof ReferenceTypeImpl) {
ReferenceTypeImpl referenceType = (ReferenceTypeImpl) type;
if(referenceType.getTypeDeclaration().isPresent()) {
ResolvedReferenceTypeDeclaration typeUsageTypeDeclaration = referenceType.getTypeDeclaration().get();
if (typeUsageTypeDeclaration.asEnum().hasEnumConstant(name)) {
return SymbolReference.solved(typeUsageTypeDeclaration.asEnum().getEnumConstant(name));
}
if (typeUsageTypeDeclaration.hasField(name)) {
return SymbolReference.solved(typeUsageTypeDeclaration.getField(name));
}
} else {
// Consider IllegalStateException or similar?
}
} else {
throw new UnsupportedOperationException();
}
}
}
// look for declaration in a pattern label for this entry
for (Expression e : wrappedNode.getLabels()) {
if (!(e instanceof PatternExpr)) {
continue;
}
PatternExpr pattern = (PatternExpr) e;
if (pattern.getNameAsString().equals(name)) {
JavaParserPatternDeclaration decl = JavaParserSymbolDeclaration.patternVar(pattern, typeSolver);
return SymbolReference.solved(decl);
}
}
// look for declaration in this and previous switch entry statements
for (SwitchEntry seStmt : switchNode.getEntries()) {
for (Statement stmt : seStmt.getStatements()) {
SymbolDeclarator symbolDeclarator = JavaParserFactory.getSymbolDeclarator(stmt, typeSolver);
SymbolReference<? extends ResolvedValueDeclaration> symbolReference = solveWith(symbolDeclarator, name);
if (symbolReference.isSolved()) {
return symbolReference;
}
}
// once we reach this switch entry statement, stop: we do not want to look in later switch entry statements
if (seStmt == wrappedNode) {
break;
}
}
return solveSymbolInParentContext(name);
| 161
| 595
| 756
|
<methods>public void <init>(com.github.javaparser.ast.stmt.SwitchEntry, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.stmt.SwitchEntry getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.stmt.SwitchEntry wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/TryWithResourceContext.java
|
TryWithResourceContext
|
solveSymbolAsValue
|
class TryWithResourceContext extends AbstractJavaParserContext<TryStmt> {
public TryWithResourceContext(TryStmt wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public Optional<Value> solveSymbolAsValue(String name) {<FILL_FUNCTION_BODY>}
@Override
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
for (Expression expr : wrappedNode.getResources()) {
if (expr instanceof VariableDeclarationExpr) {
for (VariableDeclarator v : ((VariableDeclarationExpr)expr).getVariables()) {
if (v.getName().getIdentifier().equals(name)) {
return SymbolReference.solved(JavaParserSymbolDeclaration.localVar(v, typeSolver));
}
}
}
}
if (demandParentNode(wrappedNode) instanceof BlockStmt) {
return StatementContext.solveInBlock(name, typeSolver, wrappedNode);
}
return solveSymbolInParentContext(name);
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) {
// TODO: Document why staticOnly is forced to be false.
return solveMethodInParentContext(name, argumentsTypes, false);
}
@Override
public List<VariableDeclarator> localVariablesExposedToChild(Node child) {
NodeList<Expression> resources = wrappedNode.getResources();
for (int i=0;i<resources.size();i++) {
if (child == resources.get(i)) {
return resources.subList(0, i).stream()
.map(e -> e instanceof VariableDeclarationExpr ? ((VariableDeclarationExpr) e).getVariables()
: Collections.<VariableDeclarator>emptyList())
.flatMap(List::stream)
.collect(Collectors.toList());
}
}
if (child == wrappedNode.getTryBlock()) {
List<VariableDeclarator> res = new LinkedList<>();
for (Expression expr : resources) {
if (expr instanceof VariableDeclarationExpr) {
res.addAll(((VariableDeclarationExpr)expr).getVariables());
}
}
return res;
}
return Collections.emptyList();
}
}
|
for (Expression expr : wrappedNode.getResources()) {
if (expr instanceof VariableDeclarationExpr) {
for (VariableDeclarator v : ((VariableDeclarationExpr)expr).getVariables()) {
if (v.getName().getIdentifier().equals(name)) {
ResolvedValueDeclaration decl = JavaParserSymbolDeclaration.localVar(v, typeSolver);
return Optional.of(Value.from(decl));
}
}
}
}
if (demandParentNode(wrappedNode) instanceof BlockStmt) {
return StatementContext.solveInBlockAsValue(name, typeSolver, wrappedNode);
}
return solveSymbolAsValueInParentContext(name);
| 597
| 175
| 772
|
<methods>public void <init>(com.github.javaparser.ast.stmt.TryStmt, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.stmt.TryStmt getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.stmt.TryStmt wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/UnaryExprContext.java
|
UnaryExprContext
|
negatedPatternExprsExposedFromChildren
|
class UnaryExprContext extends AbstractJavaParserContext<UnaryExpr> {
public UnaryExprContext(UnaryExpr wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public List<PatternExpr> patternExprsExposedFromChildren() {
List<PatternExpr> results = new ArrayList<>();
// Propagate any pattern expressions "up"
if(wrappedNode.getOperator() == UnaryExpr.Operator.LOGICAL_COMPLEMENT) {
Context innerContext = JavaParserFactory.getContext(wrappedNode.getExpression(), typeSolver);
// Avoid infinite loop
if(!this.equals(innerContext)) {
// Note that `UnaryExpr.Operator.LOGICAL_COMPLEMENT` is `!`
// Previously negated pattern expressions are now available (double negatives) -- e.g. if(!!("a" instanceof String s)) {}
results.addAll(innerContext.negatedPatternExprsExposedFromChildren());
}
}
return results;
}
@Override
public List<PatternExpr> negatedPatternExprsExposedFromChildren() {<FILL_FUNCTION_BODY>}
}
|
List<PatternExpr> results = new ArrayList<>();
// Propagate any pattern expressions "up"
if(wrappedNode.getOperator() == UnaryExpr.Operator.LOGICAL_COMPLEMENT) {
Context innerContext = JavaParserFactory.getContext(wrappedNode.getExpression(), typeSolver);
if(!this.equals(innerContext)) {
// Note that `UnaryExpr.Operator.LOGICAL_COMPLEMENT` is `!`
// Previously available pattern expressions are now negated (double negatives) -- e.g. if(!("a" instanceof String s)) {}
results.addAll(innerContext.patternExprsExposedFromChildren());
}
}
return results;
| 301
| 175
| 476
|
<methods>public void <init>(com.github.javaparser.ast.expr.UnaryExpr, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.expr.UnaryExpr getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.expr.UnaryExpr wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/VariableDeclarationExprContext.java
|
VariableDeclarationExprContext
|
patternExprsExposedFromChildren
|
class VariableDeclarationExprContext extends AbstractJavaParserContext<VariableDeclarationExpr> {
public VariableDeclarationExprContext(VariableDeclarationExpr wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
public SymbolReference<? extends ResolvedValueDeclaration> solveSymbol(String name) {
List<PatternExpr> patternExprs = patternExprsExposedFromChildren();
for (int i = 0; i < patternExprs.size(); i++) {
PatternExpr patternExpr = patternExprs.get(i);
if(patternExpr.getNameAsString().equals(name)) {
return SymbolReference.solved(JavaParserSymbolDeclaration.patternVar(patternExpr, typeSolver));
}
}
// Default to solving in parent context if unable to solve directly here.
return solveSymbolInParentContext(name);
}
@Override
public List<VariableDeclarator> localVariablesExposedToChild(Node child) {
for (int i = 0; i < wrappedNode.getVariables().size(); i++) {
if (child == wrappedNode.getVariable(i)) {
return wrappedNode.getVariables().subList(0, i);
}
}
// TODO: Consider pattern exprs
return Collections.emptyList();
}
@Override
public List<PatternExpr> patternExprsExposedFromChildren() {<FILL_FUNCTION_BODY>}
@Override
public List<PatternExpr> negatedPatternExprsExposedFromChildren() {
// Variable declarations never make pattern expressions available.
return Collections.emptyList();
}
}
|
// Variable declarations never make pattern expressions available.
return Collections.emptyList();
| 411
| 25
| 436
|
<methods>public void <init>(com.github.javaparser.ast.expr.VariableDeclarationExpr, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.expr.VariableDeclarationExpr getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.expr.VariableDeclarationExpr wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/contexts/VariableDeclaratorContext.java
|
VariableDeclaratorContext
|
negatedPatternExprsExposedFromChildren
|
class VariableDeclaratorContext extends AbstractJavaParserContext<VariableDeclarator> {
public VariableDeclaratorContext(VariableDeclarator wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public List<VariableDeclarator> localVariablesExposedToChild(Node child) {
if (wrappedNode.getInitializer().isPresent() && wrappedNode.getInitializer().get() == child) {
return Collections.singletonList(wrappedNode);
}
return Collections.emptyList();
}
@Override
public List<PatternExpr> patternExprsExposedFromChildren() {
// Variable declarators never make pattern expressions available.
return Collections.emptyList();
}
@Override
public List<PatternExpr> negatedPatternExprsExposedFromChildren() {<FILL_FUNCTION_BODY>}
}
|
// Variable declarators never make pattern expressions available.
return Collections.emptyList();
| 233
| 25
| 258
|
<methods>public void <init>(com.github.javaparser.ast.body.VariableDeclarator, com.github.javaparser.resolution.TypeSolver) ,public boolean equals(java.lang.Object) ,public final Optional<com.github.javaparser.resolution.Context> getParent() ,public com.github.javaparser.ast.body.VariableDeclarator getWrappedNode() ,public int hashCode() ,public Optional<com.github.javaparser.resolution.MethodUsage> solveMethodAsUsage(java.lang.String, List<com.github.javaparser.resolution.types.ResolvedType>) ,public SymbolReference<? extends com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveSymbolInParentContext(java.lang.String) ,public static SymbolReference<com.github.javaparser.resolution.declarations.ResolvedValueDeclaration> solveWith(com.github.javaparser.resolution.SymbolDeclarator, java.lang.String) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.body.VariableDeclarator wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/AstResolutionUtils.java
|
AstResolutionUtils
|
hasDirectlyAnnotation
|
class AstResolutionUtils {
static String containerName(Node container) {
String packageName = getPackageName(container);
String className = getClassName("", container);
return packageName +
((!packageName.isEmpty() && !className.isEmpty()) ? "." : "") +
className;
}
/*
* Returns the package name from a node (that can be null) or an empty string
*/
static String getPackageName(Node container) {
String packageName = "";
if (container == null) return packageName;
Optional<CompilationUnit> cu = container.findCompilationUnit();
if (cu.isPresent()) {
packageName = cu.get().getPackageDeclaration().map(pd -> pd.getNameAsString()).orElse("");
}
return packageName;
}
static String getClassName(String base, Node container) {
if (container instanceof com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) {
String b = getClassName(base, container.getParentNode().orElse(null));
String cn = ((com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) container).getName().getId();
if (b.isEmpty()) {
return cn;
}
return b + "." + cn;
}
if (container instanceof com.github.javaparser.ast.body.EnumDeclaration) {
String b = getClassName(base, container.getParentNode().orElse(null));
String cn = ((com.github.javaparser.ast.body.EnumDeclaration) container).getName().getId();
if (b.isEmpty()) {
return cn;
}
return b + "." + cn;
}
if (container instanceof com.github.javaparser.ast.body.AnnotationDeclaration) {
String b = getClassName(base, container.getParentNode().orElse(null));
String cn = ((com.github.javaparser.ast.body.AnnotationDeclaration) container).getName().getId();
if (b.isEmpty()) {
return cn;
}
return b + "." + cn;
}
if (container != null) {
return getClassName(base, container.getParentNode().orElse(null));
}
return base;
}
static boolean hasDirectlyAnnotation(NodeWithAnnotations<?> nodeWithAnnotations, TypeSolver typeSolver,
String canonicalName) {<FILL_FUNCTION_BODY>}
static <N extends ResolvedReferenceTypeDeclaration> List<ResolvedConstructorDeclaration> getConstructors(
NodeWithMembers<?> wrappedNode,
TypeSolver typeSolver,
N container) {
List<ResolvedConstructorDeclaration> declared = wrappedNode.getConstructors().stream()
.map(c -> new JavaParserConstructorDeclaration<N>(container, c, typeSolver))
.collect(Collectors.toList());
if (declared.isEmpty()) {
// If there are no constructors insert the default constructor
return ImmutableList.of(new DefaultConstructorDeclaration<N>(container));
}
return declared;
}
}
|
for (AnnotationExpr annotationExpr : nodeWithAnnotations.getAnnotations()) {
SymbolReference<ResolvedTypeDeclaration> ref = JavaParserFactory.getContext(annotationExpr, typeSolver)
.solveType(annotationExpr.getNameAsString());
if (ref.isSolved()) {
if (ref.getCorrespondingDeclaration().getQualifiedName().equals(canonicalName)) {
return true;
}
} else {
throw new UnsolvedSymbolException(annotationExpr.getName().getId());
}
}
return false;
| 792
| 139
| 931
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnnotationDeclaration.java
|
JavaParserAnnotationDeclaration
|
getQualifiedName
|
class JavaParserAnnotationDeclaration extends AbstractTypeDeclaration implements ResolvedAnnotationDeclaration {
private com.github.javaparser.ast.body.AnnotationDeclaration wrappedNode;
private TypeSolver typeSolver;
private JavaParserTypeAdapter<AnnotationDeclaration> javaParserTypeAdapter;
public JavaParserAnnotationDeclaration(AnnotationDeclaration wrappedNode, TypeSolver typeSolver) {
this.wrappedNode = wrappedNode;
this.typeSolver = typeSolver;
this.javaParserTypeAdapter = new JavaParserTypeAdapter<>(wrappedNode, typeSolver);
}
@Override
public List<ResolvedReferenceType> getAncestors(boolean acceptIncompleteList) {
List<ResolvedReferenceType> ancestors = new ArrayList<>();
ancestors.add(new ReferenceTypeImpl(typeSolver.solveType("java.lang.annotation.Annotation")));
return ancestors;
}
@Override
public Set<ResolvedReferenceTypeDeclaration> internalTypes() {
return javaParserTypeAdapter.internalTypes();
}
@Override
public List<ResolvedFieldDeclaration> getAllFields() {
return wrappedNode.getFields().stream()
.flatMap(field -> field.getVariables().stream())
.map(var -> new JavaParserFieldDeclaration(var, typeSolver))
.collect(Collectors.toList());
}
@Override
public Set<ResolvedMethodDeclaration> getDeclaredMethods() {
// TODO #1838
throw new UnsupportedOperationException();
}
@Override
public boolean isAssignableBy(ResolvedType type) {
// TODO #1836
throw new UnsupportedOperationException();
}
@Override
public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) {
throw new UnsupportedOperationException();
}
@Override
public boolean hasDirectlyAnnotation(String canonicalName) {
return AstResolutionUtils.hasDirectlyAnnotation(wrappedNode, typeSolver, canonicalName);
}
/*
* Returns a set of the declared annotation on this type
*/
@Override
public Set<ResolvedAnnotationDeclaration> getDeclaredAnnotations() {
return javaParserTypeAdapter.getDeclaredAnnotations();
}
@Override
public String getPackageName() {
return AstResolutionUtils.getPackageName(wrappedNode);
}
@Override
public String getClassName() {
return AstResolutionUtils.getClassName("", wrappedNode);
}
@Override
public String getQualifiedName() {<FILL_FUNCTION_BODY>}
@Override
public String getName() {
return wrappedNode.getName().getId();
}
/**
* Annotation declarations cannot have type parameters and hence this method always returns an empty list.
*
* @return An empty list.
*/
@Override
public List<ResolvedTypeParameterDeclaration> getTypeParameters() {
// Annotation declarations cannot have type parameters - i.e. we can always return an empty list.
return Collections.emptyList();
}
@Override
public Optional<ResolvedReferenceTypeDeclaration> containerType() {
// TODO #1841
throw new UnsupportedOperationException("containerType is not supported for " + this.getClass().getCanonicalName());
}
@Override
public List<ResolvedAnnotationMemberDeclaration> getAnnotationMembers() {
return wrappedNode.getMembers().stream()
.filter(m -> m instanceof AnnotationMemberDeclaration)
.map(m -> new JavaParserAnnotationMemberDeclaration((AnnotationMemberDeclaration)m, typeSolver))
.collect(Collectors.toList());
}
@Override
public List<ResolvedConstructorDeclaration> getConstructors() {
return Collections.emptyList();
}
@Override
public boolean isInheritable() {
return wrappedNode.getAnnotationByClass(Inherited.class).isPresent();
}
@Override
public Optional<Node> toAst() {
return Optional.of(wrappedNode);
}
}
|
String containerName = AstResolutionUtils.containerName(wrappedNode.getParentNode().orElse(null));
if (containerName.isEmpty()) {
return wrappedNode.getName().getId();
}
return containerName + "." + wrappedNode.getName();
| 1,019
| 68
| 1,087
|
<methods>public non-sealed void <init>() ,public final Set<com.github.javaparser.resolution.MethodUsage> getAllMethods() ,public final boolean isFunctionalInterface() <variables>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnonymousClassDeclaration.java
|
JavaParserAnonymousClassDeclaration
|
getAllFields
|
class JavaParserAnonymousClassDeclaration extends AbstractClassDeclaration
implements MethodUsageResolutionCapability {
private final TypeSolver typeSolver;
private final ObjectCreationExpr wrappedNode;
private final ResolvedTypeDeclaration superTypeDeclaration;
private final String name = "Anonymous-" + UUID.randomUUID();
public JavaParserAnonymousClassDeclaration(ObjectCreationExpr wrappedNode,
TypeSolver typeSolver) {
this.typeSolver = typeSolver;
this.wrappedNode = wrappedNode;
ClassOrInterfaceType superType = wrappedNode.getType();
String superTypeName = superType.getName().getId();
if (superType.getScope().isPresent()) {
superTypeName = superType.getScope().get().asString() + "." + superTypeName;
}
Context context = new ObjectCreationContext(wrappedNode, typeSolver);
superTypeDeclaration = context.solveType(superTypeName).getCorrespondingDeclaration();
}
public ResolvedTypeDeclaration getSuperTypeDeclaration() {
return superTypeDeclaration;
}
public <T extends Node> List<T> findMembersOfKind(final Class<T> memberClass) {
if (wrappedNode.getAnonymousClassBody().isPresent()) {
return wrappedNode
.getAnonymousClassBody()
.get()
.stream()
.filter(node -> memberClass.isAssignableFrom(node.getClass()))
.map(memberClass::cast)
.collect(Collectors.toList());
}
return Collections.emptyList();
}
public Context getContext() {
return JavaParserFactory.getContext(wrappedNode, typeSolver);
}
@Override
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes,
boolean staticOnly) {
return getContext().solveMethod(name, argumentsTypes, staticOnly);
}
@Override
public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> argumentTypes,
Context invocationContext, List<ResolvedType> typeParameters) {
return getContext().solveMethodAsUsage(name, argumentTypes);
}
@Override
protected ResolvedReferenceType object() {
return new ReferenceTypeImpl(typeSolver.getSolvedJavaLangObject());
}
@Override
public Optional<ResolvedReferenceType> getSuperClass() {
ResolvedReferenceTypeDeclaration superRRTD = superTypeDeclaration.asReferenceType();
if (superRRTD == null) {
return Optional.empty();
}
return Optional.of(new ReferenceTypeImpl(superRRTD));
}
@Override
public List<ResolvedReferenceType> getInterfaces() {
return superTypeDeclaration.asReferenceType()
.getAncestors()
.stream()
.filter(type -> type.getTypeDeclaration().isPresent())
.filter(type -> type.getTypeDeclaration().get().isInterface())
.collect(Collectors.toList());
}
@Override
public List<ResolvedConstructorDeclaration> getConstructors() {
if (superTypeDeclaration.isInterface()) {
return Collections.singletonList(new DefaultConstructorDeclaration<>(this));
}
return superTypeDeclaration.asReferenceType().getConstructors();
}
@Override
public AccessSpecifier accessSpecifier() {
return AccessSpecifier.PRIVATE;
}
@Override
public List<ResolvedReferenceType> getAncestors(boolean acceptIncompleteList) {
ImmutableList.Builder<ResolvedReferenceType> builder = ImmutableList.builder();
// Only add the super type if it is present (e.g. java.lang.Object has no super class)
getSuperClass().ifPresent(builder::add);
// All all ancestors of the super type..?
builder.addAll(superTypeDeclaration.asReferenceType().getAncestors(acceptIncompleteList));
return builder.build();
}
@Override
public List<ResolvedFieldDeclaration> getAllFields() {<FILL_FUNCTION_BODY>}
@Override
public Set<ResolvedMethodDeclaration> getDeclaredMethods() {
return
findMembersOfKind(MethodDeclaration.class)
.stream()
.map(method -> new JavaParserMethodDeclaration(method, typeSolver))
.collect(Collectors.toSet());
}
@Override
public boolean isAssignableBy(ResolvedType type) {
return false;
}
@Override
public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) {
return false;
}
@Override
public boolean hasDirectlyAnnotation(String qualifiedName) {
return false;
}
@Override
public String getPackageName() {
return AstResolutionUtils.getPackageName(wrappedNode);
}
@Override
public String getClassName() {
return AstResolutionUtils.getClassName("", wrappedNode);
}
@Override
public String getQualifiedName() {
String containerName = AstResolutionUtils.containerName(wrappedNode.getParentNode().orElse(null));
if (containerName.isEmpty()) {
return getName();
}
return containerName + "." + getName();
}
@Override
public Set<ResolvedReferenceTypeDeclaration> internalTypes() {
return
findMembersOfKind(TypeDeclaration.class)
.stream()
.map(typeMember -> JavaParserFacade.get(typeSolver).getTypeDeclaration(typeMember))
.collect(Collectors.toSet());
}
@Override
public String getName() {
return name;
}
@Override
public List<ResolvedTypeParameterDeclaration> getTypeParameters() {
return Lists.newArrayList();
}
@Override
public Optional<ResolvedReferenceTypeDeclaration> containerType() {
throw new UnsupportedOperationException("containerType is not supported for " + this.getClass().getCanonicalName());
}
@Override
public Optional<Node> toAst() {
return Optional.of(wrappedNode);
}
}
|
List<JavaParserFieldDeclaration> myFields = findMembersOfKind(FieldDeclaration.class)
.stream()
.flatMap(field -> field.getVariables()
.stream()
.map(variable -> new JavaParserFieldDeclaration(variable, typeSolver))
)
.collect(Collectors.toList());
// TODO: Figure out if it is appropriate to remove the orElseThrow() -- if so, how...
List<ResolvedFieldDeclaration> superClassFields = getSuperClass()
.orElseThrow(() -> new RuntimeException("super class unexpectedly empty"))
.getTypeDeclaration()
.orElseThrow(() -> new RuntimeException("TypeDeclaration unexpectedly empty."))
.getAllFields();
// TODO: Figure out if it is appropriate to remove the orElseThrow() -- if so, how...
List<ResolvedFieldDeclaration> interfaceFields =
getInterfaces().stream()
.flatMap(interfaceReferenceType -> interfaceReferenceType
.getTypeDeclaration().orElseThrow(() -> new RuntimeException("TypeDeclaration unexpectedly empty."))
.getAllFields()
.stream()
)
.collect(Collectors.toList());
return ImmutableList
.<ResolvedFieldDeclaration>builder()
.addAll(myFields)
.addAll(superClassFields)
.addAll(interfaceFields)
.build();
| 1,566
| 346
| 1,912
|
<methods>public non-sealed void <init>() ,public final com.github.javaparser.resolution.declarations.ResolvedClassDeclaration asClass() ,public final List<com.github.javaparser.resolution.types.ResolvedReferenceType> getAllInterfaces() ,public final List<com.github.javaparser.resolution.types.ResolvedReferenceType> getAllSuperClasses() ,public boolean hasName() <variables>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserConstructorDeclaration.java
|
JavaParserConstructorDeclaration
|
getSpecifiedException
|
class JavaParserConstructorDeclaration<N extends ResolvedReferenceTypeDeclaration> implements ResolvedConstructorDeclaration {
private N declaringType;
private com.github.javaparser.ast.body.ConstructorDeclaration wrappedNode;
private TypeSolver typeSolver;
JavaParserConstructorDeclaration(N declaringType, com.github.javaparser.ast.body.ConstructorDeclaration wrappedNode,
TypeSolver typeSolver) {
this.declaringType = declaringType;
this.wrappedNode = wrappedNode;
this.typeSolver = typeSolver;
}
@Override
public N declaringType() {
return declaringType;
}
@Override
public int getNumberOfParams() {
return this.wrappedNode.getParameters().size();
}
@Override
public ResolvedParameterDeclaration getParam(int i) {
if (i < 0 || i >= getNumberOfParams()) {
throw new IllegalArgumentException(String.format("No param with index %d. Number of params: %d", i, getNumberOfParams()));
}
return new JavaParserParameterDeclaration(wrappedNode.getParameters().get(i), typeSolver);
}
@Override
public String getName() {
return this.declaringType.getName();
}
/**
* Returns the JavaParser node associated with this JavaParserConstructorDeclaration.
*
* @return A visitable JavaParser node wrapped by this object.
*/
public com.github.javaparser.ast.body.ConstructorDeclaration getWrappedNode() {
return wrappedNode;
}
@Override
public AccessSpecifier accessSpecifier() {
return wrappedNode.getAccessSpecifier();
}
@Override
public List<ResolvedTypeParameterDeclaration> getTypeParameters() {
return this.wrappedNode.getTypeParameters().stream().map((astTp) -> new JavaParserTypeParameter(astTp, typeSolver)).collect(Collectors.toList());
}
@Override
public int getNumberOfSpecifiedExceptions() {
return wrappedNode.getThrownExceptions().size();
}
@Override
public ResolvedType getSpecifiedException(int index) {<FILL_FUNCTION_BODY>}
@Override
public Optional<Node> toAst() {
return Optional.of(wrappedNode);
}
}
|
if (index < 0 || index >= getNumberOfSpecifiedExceptions()) {
throw new IllegalArgumentException(String.format("No exception with index %d. Number of exceptions: %d",
index, getNumberOfSpecifiedExceptions()));
}
return JavaParserFacade.get(typeSolver)
.convert(wrappedNode.getThrownExceptions().get(index), wrappedNode);
| 595
| 98
| 693
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserFieldDeclaration.java
|
JavaParserFieldDeclaration
|
declaringType
|
class JavaParserFieldDeclaration implements ResolvedFieldDeclaration {
private VariableDeclarator variableDeclarator;
private com.github.javaparser.ast.body.FieldDeclaration wrappedNode;
private TypeSolver typeSolver;
public JavaParserFieldDeclaration(VariableDeclarator variableDeclarator, TypeSolver typeSolver) {
if (typeSolver == null) {
throw new IllegalArgumentException("typeSolver should not be null");
}
this.variableDeclarator = variableDeclarator;
this.typeSolver = typeSolver;
if (!(demandParentNode(variableDeclarator) instanceof com.github.javaparser.ast.body.FieldDeclaration)) {
throw new IllegalStateException(demandParentNode(variableDeclarator).getClass().getCanonicalName());
}
this.wrappedNode = (com.github.javaparser.ast.body.FieldDeclaration) demandParentNode(variableDeclarator);
}
@Override
public ResolvedType getType() {
return JavaParserFacade.get(typeSolver).convert(variableDeclarator.getType(), wrappedNode);
}
@Override
public String getName() {
return variableDeclarator.getName().getId();
}
@Override
public boolean isStatic() {
return wrappedNode.hasModifier(Modifier.Keyword.STATIC);
}
@Override
public boolean isVolatile() {
return wrappedNode.hasModifier(Modifier.Keyword.VOLATILE);
}
@Override
public boolean isField() {
return true;
}
/**
* Returns the JavaParser node associated with this JavaParserFieldDeclaration.
*
* @return A visitable JavaParser node wrapped by this object.
*/
public com.github.javaparser.ast.body.FieldDeclaration getWrappedNode() {
return wrappedNode;
}
public VariableDeclarator getVariableDeclarator() {
return variableDeclarator;
}
@Override
public String toString() {
return "JavaParserFieldDeclaration{" + getName() + "}";
}
@Override
public AccessSpecifier accessSpecifier() {
return wrappedNode.getAccessSpecifier();
}
@Override
public ResolvedTypeDeclaration declaringType() {<FILL_FUNCTION_BODY>}
@Override
public Optional<Node> toAst() {
return Optional.ofNullable(wrappedNode);
}
}
|
Optional<TypeDeclaration> typeDeclaration = wrappedNode.findAncestor(TypeDeclaration.class);
if (typeDeclaration.isPresent()) {
return JavaParserFacade.get(typeSolver).getTypeDeclaration(typeDeclaration.get());
}
throw new IllegalStateException();
| 631
| 72
| 703
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserMethodDeclaration.java
|
JavaParserMethodDeclaration
|
getSpecifiedException
|
class JavaParserMethodDeclaration implements ResolvedMethodDeclaration, TypeVariableResolutionCapability {
private com.github.javaparser.ast.body.MethodDeclaration wrappedNode;
private TypeSolver typeSolver;
public JavaParserMethodDeclaration(com.github.javaparser.ast.body.MethodDeclaration wrappedNode, TypeSolver typeSolver) {
this.wrappedNode = wrappedNode;
this.typeSolver = typeSolver;
}
@Override
public String toString() {
return "JavaParserMethodDeclaration{" +
"wrappedNode=" + wrappedNode +
", typeSolver=" + typeSolver +
'}';
}
@Override
public ResolvedReferenceTypeDeclaration declaringType() {
if (demandParentNode(wrappedNode) instanceof ObjectCreationExpr) {
ObjectCreationExpr parentNode = (ObjectCreationExpr) demandParentNode(wrappedNode);
return new JavaParserAnonymousClassDeclaration(parentNode, typeSolver);
}
// TODO Fix: to use getSymbolResolver() we have to fix many unit tests
// that throw IllegalStateException("Symbol resolution not configured: to configure consider setting a SymbolResolver in the ParserConfiguration"
// return wrappedNode.getSymbolResolver().toTypeDeclaration(wrappedNode);
return symbolResolver(typeSolver).toTypeDeclaration(demandParentNode(wrappedNode));
}
private SymbolResolver symbolResolver(TypeSolver typeSolver) {
return new JavaSymbolSolver(typeSolver);
}
@Override
public ResolvedType getReturnType() {
return JavaParserFacade.get(typeSolver).convert(wrappedNode.getType(), getContext());
}
@Override
public int getNumberOfParams() {
return wrappedNode.getParameters().size();
}
@Override
public ResolvedParameterDeclaration getParam(int i) {
if (i < 0 || i >= getNumberOfParams()) {
throw new IllegalArgumentException(String.format("No param with index %d. Number of params: %d", i, getNumberOfParams()));
}
return new JavaParserParameterDeclaration(wrappedNode.getParameters().get(i), typeSolver);
}
public MethodUsage getUsage(Node node) {
throw new UnsupportedOperationException();
}
public MethodUsage resolveTypeVariables(Context context, List<ResolvedType> parameterTypes) {
return new MethodDeclarationCommonLogic(this, typeSolver).resolveTypeVariables(context, parameterTypes);
}
private Context getContext() {
return JavaParserFactory.getContext(wrappedNode, typeSolver);
}
@Override
public boolean isAbstract() {
return !wrappedNode.getBody().isPresent();
}
@Override
public String getName() {
return wrappedNode.getName().getId();
}
@Override
public List<ResolvedTypeParameterDeclaration> getTypeParameters() {
return this.wrappedNode.getTypeParameters().stream().map((astTp) -> new JavaParserTypeParameter(astTp, typeSolver)).collect(Collectors.toList());
}
@Override
public boolean isDefaultMethod() {
return wrappedNode.isDefault();
}
@Override
public boolean isStatic() {
return wrappedNode.isStatic();
}
/**
* Returns the JavaParser node associated with this JavaParserMethodDeclaration.
*
* @return A visitable JavaParser node wrapped by this object.
*/
public com.github.javaparser.ast.body.MethodDeclaration getWrappedNode() {
return wrappedNode;
}
@Override
public AccessSpecifier accessSpecifier() {
return wrappedNode.getAccessSpecifier();
}
@Override
public int getNumberOfSpecifiedExceptions() {
return wrappedNode.getThrownExceptions().size();
}
@Override
public ResolvedType getSpecifiedException(int index) {<FILL_FUNCTION_BODY>}
@Override
public Optional<Node> toAst() {
return Optional.of(wrappedNode);
}
@Override
public String toDescriptor() {
return wrappedNode.toDescriptor();
}
}
|
if (index < 0 || index >= getNumberOfSpecifiedExceptions()) {
throw new IllegalArgumentException(String.format("No exception with index %d. Number of exceptions: %d",
index, getNumberOfSpecifiedExceptions()));
}
return JavaParserFacade.get(typeSolver).convert(wrappedNode.getThrownExceptions()
.get(index), wrappedNode);
| 1,062
| 98
| 1,160
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserParameterDeclaration.java
|
JavaParserParameterDeclaration
|
getType
|
class JavaParserParameterDeclaration implements ResolvedParameterDeclaration {
private final Parameter wrappedNode;
private final TypeSolver typeSolver;
public JavaParserParameterDeclaration(Parameter wrappedNode, TypeSolver typeSolver) {
this.wrappedNode = wrappedNode;
this.typeSolver = typeSolver;
}
@Override
public String getName() {
return wrappedNode.getName().getId();
}
@Override
public boolean isVariadic() {
return wrappedNode.isVarArgs();
}
@Override
public ResolvedType getType() {<FILL_FUNCTION_BODY>}
/**
* Returns the JavaParser node associated with this JavaParserParameterDeclaration.
*
* @return A visitable JavaParser node wrapped by this object.
*/
public Parameter getWrappedNode() {
return wrappedNode;
}
@Override
public Optional<Node> toAst() {
return Optional.of(wrappedNode);
}
}
|
if (wrappedNode.getType().isUnknownType() && JavaParserFactory.getContext(wrappedNode, typeSolver) instanceof LambdaExprContext) {
Optional<Value> value = JavaParserFactory.getContext(wrappedNode, typeSolver).solveSymbolAsValue(wrappedNode.getNameAsString());
if (value.isPresent()) {
return value.get().getType();
}
}
ResolvedType res = JavaParserFacade.get(typeSolver).convert(wrappedNode.getType(), wrappedNode);
if (isVariadic()) {
res = new ResolvedArrayType(res);
}
return res;
| 258
| 165
| 423
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserSymbolDeclaration.java
|
JavaParserSymbolDeclaration
|
getParamPos
|
class JavaParserSymbolDeclaration {
public static JavaParserFieldDeclaration field(VariableDeclarator wrappedNode, TypeSolver typeSolver) {
return new JavaParserFieldDeclaration(wrappedNode, typeSolver);
}
public static JavaParserParameterDeclaration parameter(Parameter parameter, TypeSolver typeSolver) {
return new JavaParserParameterDeclaration(parameter, typeSolver);
}
public static JavaParserVariableDeclaration localVar(VariableDeclarator variableDeclarator, TypeSolver typeSolver) {
return new JavaParserVariableDeclaration(variableDeclarator, typeSolver);
}
public static JavaParserPatternDeclaration patternVar(PatternExpr patternExpr, TypeSolver typeSolver) {
return new JavaParserPatternDeclaration(patternExpr, typeSolver);
}
public static int getParamPos(Parameter parameter) {<FILL_FUNCTION_BODY>}
private JavaParserSymbolDeclaration() {
// This private constructor is used to hide the public one
}
}
|
int pos = 0;
for (Node node : demandParentNode(parameter).getChildNodes()) {
if (node == parameter) {
return pos;
}
if (node instanceof Parameter) {
pos++;
}
}
return pos;
| 242
| 71
| 313
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeAdapter.java
|
JavaParserTypeAdapter
|
internalTypes
|
class JavaParserTypeAdapter<T extends Node & NodeWithSimpleName<T> & NodeWithMembers<T> & NodeWithAnnotations<T>> {
private T wrappedNode;
private TypeSolver typeSolver;
public JavaParserTypeAdapter(T wrappedNode, TypeSolver typeSolver) {
this.wrappedNode = wrappedNode;
this.typeSolver = typeSolver;
}
public String getPackageName() {
return AstResolutionUtils.getPackageName(wrappedNode);
}
public String getClassName() {
return AstResolutionUtils.getClassName("", wrappedNode);
}
public String getQualifiedName() {
String containerName = AstResolutionUtils.containerName(wrappedNode.getParentNode().orElse(null));
if (containerName.isEmpty()) {
return wrappedNode.getName().getId();
}
return containerName + "." + wrappedNode.getName().getId();
}
public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) {
List<ResolvedReferenceType> ancestorsOfOther = other.getAllAncestors();
ancestorsOfOther.add(new ReferenceTypeImpl(other));
for (ResolvedReferenceType ancestorOfOther : ancestorsOfOther) {
if (ancestorOfOther.getQualifiedName().equals(this.getQualifiedName())) {
return true;
}
}
return false;
}
public boolean isAssignableBy(ResolvedType type) {
if (type.isNull()) {
return true;
}
if (type.isReferenceType()) {
ResolvedReferenceTypeDeclaration other = typeSolver.solveType(type.describe());
return isAssignableBy(other);
}
throw new UnsupportedOperationException();
}
/**
* This method is deprecated because it receives the TypesSolver as a parameter.
* Eventually we would like to remove all usages of TypeSolver as a parameter.
*
* Also, resolution should move out of declarations, so that they are pure declarations and the resolution should
* work for JavaParser, Reflection and Javassist classes in the same way and not be specific to the three
* implementations.
*/
@Deprecated
public SymbolReference<ResolvedTypeDeclaration> solveType(String name) {
if(wrappedNode instanceof NodeWithTypeParameters<?>) {
NodeList<TypeParameter> typeParameters = ((NodeWithTypeParameters<?>) wrappedNode).getTypeParameters();
for (com.github.javaparser.ast.type.TypeParameter typeParameter : typeParameters) {
if (typeParameter.getName().getId().equals(name)) {
return SymbolReference.solved(new JavaParserTypeVariableDeclaration(typeParameter, typeSolver));
}
}
}
// Member classes & interfaces
for (BodyDeclaration<?> member : this.wrappedNode.getMembers()) {
if (member instanceof com.github.javaparser.ast.body.TypeDeclaration) {
com.github.javaparser.ast.body.TypeDeclaration<?> internalType = (com.github.javaparser.ast.body.TypeDeclaration<?>) member;
String prefix = internalType.getName().asString() + ".";
if (internalType.getName().getId().equals(name)) {
if (internalType instanceof ClassOrInterfaceDeclaration) {
if (((ClassOrInterfaceDeclaration) internalType).isInterface()) {
return SymbolReference.solved(new JavaParserInterfaceDeclaration((com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) internalType, typeSolver));
}
return SymbolReference.solved(new JavaParserClassDeclaration((com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) internalType, typeSolver));
}
if (internalType instanceof EnumDeclaration) {
return SymbolReference.solved(new JavaParserEnumDeclaration((com.github.javaparser.ast.body.EnumDeclaration) internalType, typeSolver));
}
if (internalType instanceof AnnotationDeclaration) {
return SymbolReference.solved(new JavaParserAnnotationDeclaration((com.github.javaparser.ast.body.AnnotationDeclaration) internalType, typeSolver));
}
throw new UnsupportedOperationException();
}
if (name.startsWith(prefix) && name.length() > prefix.length()) {
if (internalType instanceof ClassOrInterfaceDeclaration) {
if (((ClassOrInterfaceDeclaration) internalType).isInterface()) {
return new JavaParserInterfaceDeclaration((com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) internalType, typeSolver).solveType(name.substring(prefix.length()));
}
return new JavaParserClassDeclaration((com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) internalType, typeSolver).solveType(name.substring(prefix.length()));
}
if (internalType instanceof EnumDeclaration) {
return new SymbolSolver(typeSolver).solveTypeInType(new JavaParserEnumDeclaration((com.github.javaparser.ast.body.EnumDeclaration) internalType, typeSolver), name.substring(prefix.length()));
}
if (internalType instanceof AnnotationDeclaration) {
return SymbolReference.solved(new JavaParserAnnotationDeclaration((com.github.javaparser.ast.body.AnnotationDeclaration) internalType, typeSolver));
}
throw new UnsupportedOperationException();
}
}
}
return SymbolReference.unsolved();
}
public Optional<ResolvedReferenceTypeDeclaration> containerType() {
return wrappedNode
.getParentNode()
.filter(parentNode -> !(parentNode instanceof CompilationUnit))
.map(node -> node.getSymbolResolver().toTypeDeclaration(node));
}
public List<ResolvedFieldDeclaration> getFieldsForDeclaredVariables() {
List<ResolvedFieldDeclaration> fields = new ArrayList<>();
if (wrappedNode.getMembers() != null) {
for (BodyDeclaration<?> member : this.wrappedNode.getMembers()) {
if (member.isFieldDeclaration()) {
FieldDeclaration field = member.asFieldDeclaration();
for (VariableDeclarator vd : field.getVariables()) {
fields.add(new JavaParserFieldDeclaration(vd, typeSolver));
}
}
}
}
return fields;
}
/*
* Returns a set of the declared annotation on this type
*/
public Set<ResolvedAnnotationDeclaration> getDeclaredAnnotations() {
return wrappedNode.getAnnotations().stream()
.map(annotation -> annotation.resolve())
.collect(Collectors.toSet());
}
public Set<ResolvedReferenceTypeDeclaration> internalTypes() {<FILL_FUNCTION_BODY>}
}
|
// Use a special Set implementation that avoids calculating the hashCode of the node,
// since this can be very time-consuming for big node trees, and we are sure there are
// no duplicates in the members list.
Set<ResolvedReferenceTypeDeclaration> res = Collections.newSetFromMap(new IdentityHashMap<>());
for (BodyDeclaration<?> member : this.wrappedNode.getMembers()) {
if (member instanceof TypeDeclaration) {
res.add(JavaParserFacade.get(typeSolver).getTypeDeclaration((TypeDeclaration) member));
}
}
return res;
| 1,693
| 151
| 1,844
|
<no_super_class>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeParameter.java
|
JavaParserTypeParameter
|
getContainer
|
class JavaParserTypeParameter extends AbstractTypeDeclaration implements ResolvedTypeParameterDeclaration {
private com.github.javaparser.ast.type.TypeParameter wrappedNode;
private TypeSolver typeSolver;
public JavaParserTypeParameter(com.github.javaparser.ast.type.TypeParameter wrappedNode, TypeSolver typeSolver) {
this.wrappedNode = wrappedNode;
this.typeSolver = typeSolver;
}
@Override
public Set<ResolvedMethodDeclaration> getDeclaredMethods() {
return Collections.emptySet();
}
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> parameterTypes) {
return getContext().solveMethod(name, parameterTypes, false);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof JavaParserTypeParameter)) return false;
JavaParserTypeParameter that = (JavaParserTypeParameter) o;
return wrappedNode != null && wrappedNode.equals(that.wrappedNode);
}
@Override
public int hashCode() {
int result = wrappedNode != null ? wrappedNode.hashCode() : 0;
result = 31 * result + (typeSolver != null ? typeSolver.hashCode() : 0);
return result;
}
@Override
public String getName() {
return wrappedNode.getName().getId();
}
@Override
public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) {
return isAssignableBy(new ReferenceTypeImpl(other));
}
@Override
public String getContainerQualifiedName() {
ResolvedTypeParametrizable container = getContainer();
if (container instanceof ResolvedReferenceTypeDeclaration) {
return ((ResolvedReferenceTypeDeclaration) container).getQualifiedName();
}
if (container instanceof JavaParserConstructorDeclaration) {
return ((JavaParserConstructorDeclaration) container).getQualifiedSignature();
}
return ((JavaParserMethodDeclaration) container).getQualifiedSignature();
}
@Override
public String getContainerId() {
ResolvedTypeParametrizable container = getContainer();
if (container instanceof ResolvedReferenceTypeDeclaration) {
return ((ResolvedReferenceTypeDeclaration) container).getId();
}
if (container instanceof JavaParserConstructorDeclaration) {
return ((JavaParserConstructorDeclaration) container).getQualifiedSignature();
}
return ((JavaParserMethodDeclaration) container).getQualifiedSignature();
}
@Override
public ResolvedTypeParametrizable getContainer() {<FILL_FUNCTION_BODY>}
@Override
public String getQualifiedName() {
return String.format("%s.%s", getContainerQualifiedName(), getName());
}
@Override
public List<Bound> getBounds() {
return wrappedNode.getTypeBound().stream().map((astB) -> toBound(astB, typeSolver)).collect(Collectors.toList());
}
private Bound toBound(ClassOrInterfaceType classOrInterfaceType, TypeSolver typeSolver) {
ResolvedType type = JavaParserFacade.get(typeSolver).convertToUsage(classOrInterfaceType);
return Bound.extendsBound(type);
}
public Context getContext() {
throw new UnsupportedOperationException();
}
public ResolvedType getUsage(Node node) {
throw new UnsupportedOperationException();
}
@Override
public boolean isAssignableBy(ResolvedType type) {
throw new UnsupportedOperationException();
}
@Override
public ResolvedFieldDeclaration getField(String name) {
throw new UnsupportedOperationException();
}
@Override
public boolean hasField(String name) {
return false;
}
@Override
public List<ResolvedFieldDeclaration> getAllFields() {
return new ArrayList<>();
}
@Override
public List<ResolvedReferenceType> getAncestors(boolean acceptIncompleteList) {
throw new UnsupportedOperationException();
}
@Override
public boolean isTypeParameter() {
return true;
}
@Override
public ResolvedTypeParameterDeclaration asTypeParameter() {
return this;
}
@Override
public boolean hasDirectlyAnnotation(String canonicalName) {
throw new UnsupportedOperationException();
}
@Override
public List<ResolvedTypeParameterDeclaration> getTypeParameters() {
return Collections.emptyList();
}
/**
* Returns the JavaParser node associated with this JavaParserTypeParameter.
*
* @return A visitable JavaParser node wrapped by this object.
*/
public com.github.javaparser.ast.type.TypeParameter getWrappedNode() {
return wrappedNode;
}
@Override
public String toString() {
return "JPTypeParameter(" + wrappedNode.getName() + ", bounds=" + wrappedNode.getTypeBound() + ")";
}
@Override
public Optional<ResolvedReferenceTypeDeclaration> containerType() {
ResolvedTypeParametrizable container = getContainer();
if (container instanceof ResolvedReferenceTypeDeclaration) {
return Optional.of((ResolvedReferenceTypeDeclaration) container);
}
return Optional.empty();
}
@Override
public List<ResolvedConstructorDeclaration> getConstructors() {
return Collections.emptyList();
}
@Override
public ResolvedReferenceType object() {
return new ReferenceTypeImpl(typeSolver.getSolvedJavaLangObject());
}
@Override
public Optional<Node> toAst() {
return Optional.of(wrappedNode);
}
}
|
Node parentNode = demandParentNode(wrappedNode);
if (parentNode instanceof com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) {
com.github.javaparser.ast.body.ClassOrInterfaceDeclaration jpTypeDeclaration = (com.github.javaparser.ast.body.ClassOrInterfaceDeclaration) parentNode;
return JavaParserFacade.get(typeSolver).getTypeDeclaration(jpTypeDeclaration);
}
if (parentNode instanceof com.github.javaparser.ast.body.ConstructorDeclaration){
com.github.javaparser.ast.body.ConstructorDeclaration jpConstructorDeclaration = (com.github.javaparser.ast.body.ConstructorDeclaration) parentNode;
Optional<ClassOrInterfaceDeclaration> jpTypeDeclaration = jpConstructorDeclaration.findAncestor(com.github.javaparser.ast.body.ClassOrInterfaceDeclaration.class);
if (jpTypeDeclaration.isPresent()) {
ResolvedReferenceTypeDeclaration typeDeclaration = JavaParserFacade.get(typeSolver).getTypeDeclaration(jpTypeDeclaration.get());
if (typeDeclaration.isClass()) {
return new JavaParserConstructorDeclaration(typeDeclaration.asClass(), jpConstructorDeclaration, typeSolver);
}
}
} else {
com.github.javaparser.ast.body.MethodDeclaration jpMethodDeclaration = (com.github.javaparser.ast.body.MethodDeclaration) parentNode;
return new JavaParserMethodDeclaration(jpMethodDeclaration, typeSolver);
}
throw new UnsupportedOperationException();
| 1,461
| 380
| 1,841
|
<methods>public non-sealed void <init>() ,public final Set<com.github.javaparser.resolution.MethodUsage> getAllMethods() ,public final boolean isFunctionalInterface() <variables>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeVariableDeclaration.java
|
JavaParserTypeVariableDeclaration
|
isAssignableBy
|
class JavaParserTypeVariableDeclaration extends AbstractTypeDeclaration {
private TypeParameter wrappedNode;
private TypeSolver typeSolver;
public JavaParserTypeVariableDeclaration(TypeParameter wrappedNode, TypeSolver typeSolver) {
this.wrappedNode = wrappedNode;
this.typeSolver = typeSolver;
}
@Override
public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) {
return isAssignableBy(new ReferenceTypeImpl(other));
}
@Override
public String getPackageName() {
return AstResolutionUtils.getPackageName(wrappedNode);
}
@Override
public String getClassName() {
return AstResolutionUtils.getClassName("", wrappedNode);
}
@Override
public String getQualifiedName() {
return getName();
}
public Context getContext() {
throw new UnsupportedOperationException();
}
@Override
public String toString() {
return "JavaParserTypeVariableDeclaration{" +
wrappedNode.getName() +
'}';
}
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> parameterTypes) {
throw new UnsupportedOperationException();
}
public ResolvedType getUsage(Node node) {
throw new UnsupportedOperationException();
}
@Override
public boolean isAssignableBy(ResolvedType type) {<FILL_FUNCTION_BODY>}
@Override
public boolean isTypeParameter() {
return true;
}
@Override
public ResolvedFieldDeclaration getField(String name) {
throw new UnsupportedOperationException();
}
@Override
public boolean hasField(String name) {
return false;
}
@Override
public List<ResolvedFieldDeclaration> getAllFields() {
return new ArrayList<>();
}
@Override
public List<ResolvedReferenceType> getAncestors(boolean acceptIncompleteList) {
if (wrappedNode.getTypeBound().isEmpty()) {
// Every type variable declared as a type parameter has a bound.
// If no bound is declared for a type variable, Object is assumed.
// https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.4
return Collections.singletonList(new ReferenceTypeImpl(typeSolver.getSolvedJavaLangObject()));
}
List<ResolvedReferenceType> ancestors = new ArrayList<>();
for (ClassOrInterfaceType type : wrappedNode.getTypeBound()) {
try {
ResolvedType resolvedType = JavaParserFacade.get(typeSolver).convertToUsage(type);
ancestors.add(resolvedType.asReferenceType());
} catch (UnsolvedSymbolException e) {
if (!acceptIncompleteList) {
// Only throw if an incomplete ancestor list is unacceptable.
throw e;
}
}
}
return ancestors;
}
@Override
public Set<ResolvedMethodDeclaration> getDeclaredMethods() {
return Collections.emptySet();
}
@Override
public String getName() {
return wrappedNode.getName().getId();
}
@Override
public boolean isType() {
return true;
}
@Override
public boolean hasDirectlyAnnotation(String canonicalName) {
throw new UnsupportedOperationException();
}
@Override
public boolean isClass() {
return false;
}
@Override
public boolean isInterface() {
return false;
}
@Override
public List<ResolvedTypeParameterDeclaration> getTypeParameters() {
return Collections.emptyList();
}
@Override
public ResolvedTypeParameterDeclaration asTypeParameter() {
return new JavaParserTypeParameter(this.wrappedNode, typeSolver);
}
/**
* Returns the JavaParser node associated with this JavaParserTypeVariableDeclaration.
*
* @return A visitable JavaParser node wrapped by this object.
*/
public TypeParameter getWrappedNode() {
return wrappedNode;
}
@Override
public Optional<ResolvedReferenceTypeDeclaration> containerType() {
return asTypeParameter().containerType();
}
@Override
public List<ResolvedConstructorDeclaration> getConstructors() {
return Collections.emptyList();
}
@Override
public Optional<Node> toAst() {
return Optional.of(wrappedNode);
}
}
|
if (type.isTypeVariable()) {
throw new UnsupportedOperationException("Is this type variable declaration assignable by " + type.describe());
}
throw new UnsupportedOperationException("Is this type variable declaration assignable by " + type);
| 1,153
| 62
| 1,215
|
<methods>public non-sealed void <init>() ,public final Set<com.github.javaparser.resolution.MethodUsage> getAllMethods() ,public final boolean isFunctionalInterface() <variables>
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarators/FieldSymbolDeclarator.java
|
FieldSymbolDeclarator
|
getSymbolDeclarations
|
class FieldSymbolDeclarator extends AbstractSymbolDeclarator<FieldDeclaration> {
public FieldSymbolDeclarator(FieldDeclaration wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public List<ResolvedValueDeclaration> getSymbolDeclarations() {<FILL_FUNCTION_BODY>}
}
|
List<ResolvedValueDeclaration> symbols = new LinkedList<>();
for (VariableDeclarator v : wrappedNode.getVariables()) {
symbols.add(JavaParserSymbolDeclaration.field(v, typeSolver));
}
return symbols;
| 93
| 64
| 157
|
<methods>public void <init>(com.github.javaparser.ast.body.FieldDeclaration, com.github.javaparser.resolution.TypeSolver) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.body.FieldDeclaration wrappedNode
|
javaparser_javaparser
|
javaparser/javaparser-symbol-solver-core/src/main/java/com/github/javaparser/symbolsolver/javaparsermodel/declarators/ParameterSymbolDeclarator.java
|
ParameterSymbolDeclarator
|
getSymbolDeclarations
|
class ParameterSymbolDeclarator extends AbstractSymbolDeclarator<Parameter> {
public ParameterSymbolDeclarator(Parameter wrappedNode, TypeSolver typeSolver) {
super(wrappedNode, typeSolver);
}
@Override
public List<ResolvedValueDeclaration> getSymbolDeclarations() {<FILL_FUNCTION_BODY>}
}
|
List<ResolvedValueDeclaration> symbols = new LinkedList<>();
symbols.add(JavaParserSymbolDeclaration.parameter(wrappedNode, typeSolver));
return symbols;
| 92
| 45
| 137
|
<methods>public void <init>(com.github.javaparser.ast.body.Parameter, com.github.javaparser.resolution.TypeSolver) <variables>protected com.github.javaparser.resolution.TypeSolver typeSolver,protected com.github.javaparser.ast.body.Parameter wrappedNode
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.