issue_id
int64 2.04k
425k
| title
stringlengths 9
251
| body
stringlengths 4
32.8k
⌀ | status
stringclasses 6
values | after_fix_sha
stringlengths 7
7
| project_name
stringclasses 6
values | repo_url
stringclasses 6
values | repo_name
stringclasses 6
values | language
stringclasses 1
value | issue_url
null | before_fix_sha
null | pull_url
null | commit_datetime
timestamp[us, tz=UTC] | report_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 23
187
| chunk_content
stringlengths 1
22k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
211,674 |
Bug 211674 [ataspectj] after throwing annotation style is too sensitive to parameter positions
|
Reported on the list by Ashley Williams: Having converted my aspects to use the @AspectJ style, I'm now getting a strange error message when a compile my tracing aspect,. First here is the section of code: @Pointcut("execution(@Tracing * *(..)) && @annotation(tracing)") void annotatedMethods(Tracing tracing) { } @AfterThrowing(pointcut = "annotatedMethods(tracing)", throwing = "t") public void logException(JoinPoint thisJoinPoint, Tracing tracing, Throwable t) { Level level = Level.toLevel(tracing.level()); if (logger.isEnabledFor(level)) { logger.log(level, formatter.formatSignatureThrowing(thisJoinPoint), t); } } So I am matching on all methods annotated with @Tracing and logging the subclass of Throwable that may have been thrown. However when I run my test case i get the following error: java.lang.VerifyError: (class: com/db/abfo/tracing/PojoOne, method: calculate signature: ()V) catch_type not a subclass of Throwable This used to work when I used the aspectj after throwing language extention form: pointcut annotatedMethods(Tracing tracing) : execution(@Tracing * *(..)) && @annotation(tracing); after(Tracing tracing) throwing(Throwable t) : annotatedMethods(tracing) { Level level = tracing.level().getLevel(); if (logger.isEnabledFor(level)) { logger.log(level, formatter.formatSignatureThrowing(thisJoinPoint), t); } }
|
resolved fixed
|
9de03b7
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2007-12-02T09:24:51Z | 2007-12-01T17:26:40Z |
tests/src/org/aspectj/systemtest/ajc154/Ajc154Tests.java
|
public void testDualParameterizationsNotAllowed_pr165631() { runTest("dual parameterizations not allowed"); }
public void testSuppressWarnings1_pr166238() {
runTest("Suppress warnings1");
}
public void testSuppressWarnings2_pr166238() {
runTest("Suppress warnings2");
}
public void testNullReturnedFromGetField_pr172107() { runTest("null returned from getField()"); }
public static Test suite() {
return XMLBasedAjcTestCase.loadSuite(Ajc154Tests.class);
}
protected File getSpecFile() {
return new File("../tests/src/org/aspectj/systemtest/ajc154/ajc154.xml");
}
public SyntheticRepository createRepos(File cpentry) {
ClassPath cp = new ClassPath(cpentry+File.pathSeparator+System.getProperty("java.class.path"));
return SyntheticRepository.getInstance(cp);
}
protected JavaClass getClassFrom(File where,String clazzname) throws ClassNotFoundException {
SyntheticRepository repos = createRepos(where);
return repos.loadClass(clazzname);
}
private class BeanDesignatorHandler implements PointcutDesignatorHandler {
|
211,674 |
Bug 211674 [ataspectj] after throwing annotation style is too sensitive to parameter positions
|
Reported on the list by Ashley Williams: Having converted my aspects to use the @AspectJ style, I'm now getting a strange error message when a compile my tracing aspect,. First here is the section of code: @Pointcut("execution(@Tracing * *(..)) && @annotation(tracing)") void annotatedMethods(Tracing tracing) { } @AfterThrowing(pointcut = "annotatedMethods(tracing)", throwing = "t") public void logException(JoinPoint thisJoinPoint, Tracing tracing, Throwable t) { Level level = Level.toLevel(tracing.level()); if (logger.isEnabledFor(level)) { logger.log(level, formatter.formatSignatureThrowing(thisJoinPoint), t); } } So I am matching on all methods annotated with @Tracing and logging the subclass of Throwable that may have been thrown. However when I run my test case i get the following error: java.lang.VerifyError: (class: com/db/abfo/tracing/PojoOne, method: calculate signature: ()V) catch_type not a subclass of Throwable This used to work when I used the aspectj after throwing language extention form: pointcut annotatedMethods(Tracing tracing) : execution(@Tracing * *(..)) && @annotation(tracing); after(Tracing tracing) throwing(Throwable t) : annotatedMethods(tracing) { Level level = tracing.level().getLevel(); if (logger.isEnabledFor(level)) { logger.log(level, formatter.formatSignatureThrowing(thisJoinPoint), t); } }
|
resolved fixed
|
9de03b7
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2007-12-02T09:24:51Z | 2007-12-01T17:26:40Z |
tests/src/org/aspectj/systemtest/ajc154/Ajc154Tests.java
|
private String askedToParse;
public boolean simulateDynamicTest = false;
public String getDesignatorName() {
return "bean";
}
/* (non-Javadoc)
* @see org.aspectj.weaver.tools.PointcutDesignatorHandler#parse(java.lang.String)
*/
public ContextBasedMatcher parse(String expression) {
this.askedToParse = expression;
return new BeanPointcutExpression(expression,this.simulateDynamicTest);
}
public String getExpressionLastAskedToParse() {
return this.askedToParse;
}
}
private class BeanPointcutExpression implements ContextBasedMatcher {
|
211,674 |
Bug 211674 [ataspectj] after throwing annotation style is too sensitive to parameter positions
|
Reported on the list by Ashley Williams: Having converted my aspects to use the @AspectJ style, I'm now getting a strange error message when a compile my tracing aspect,. First here is the section of code: @Pointcut("execution(@Tracing * *(..)) && @annotation(tracing)") void annotatedMethods(Tracing tracing) { } @AfterThrowing(pointcut = "annotatedMethods(tracing)", throwing = "t") public void logException(JoinPoint thisJoinPoint, Tracing tracing, Throwable t) { Level level = Level.toLevel(tracing.level()); if (logger.isEnabledFor(level)) { logger.log(level, formatter.formatSignatureThrowing(thisJoinPoint), t); } } So I am matching on all methods annotated with @Tracing and logging the subclass of Throwable that may have been thrown. However when I run my test case i get the following error: java.lang.VerifyError: (class: com/db/abfo/tracing/PojoOne, method: calculate signature: ()V) catch_type not a subclass of Throwable This used to work when I used the aspectj after throwing language extention form: pointcut annotatedMethods(Tracing tracing) : execution(@Tracing * *(..)) && @annotation(tracing); after(Tracing tracing) throwing(Throwable t) : annotatedMethods(tracing) { Level level = tracing.level().getLevel(); if (logger.isEnabledFor(level)) { logger.log(level, formatter.formatSignatureThrowing(thisJoinPoint), t); } }
|
resolved fixed
|
9de03b7
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2007-12-02T09:24:51Z | 2007-12-01T17:26:40Z |
tests/src/org/aspectj/systemtest/ajc154/Ajc154Tests.java
|
private final String beanNamePattern;
private final boolean simulateDynamicTest;
public BeanPointcutExpression(String beanNamePattern, boolean simulateDynamicTest) {
this.beanNamePattern = beanNamePattern;
this.simulateDynamicTest = simulateDynamicTest;
}
public boolean couldMatchJoinPointsInType(Class aClass) {
return true;
}
/* (non-Javadoc)
* @see org.aspectj.weaver.tools.ContextBasedMatcher#couldMatchJoinPointsInType(java.lang.Class)
*/
|
211,674 |
Bug 211674 [ataspectj] after throwing annotation style is too sensitive to parameter positions
|
Reported on the list by Ashley Williams: Having converted my aspects to use the @AspectJ style, I'm now getting a strange error message when a compile my tracing aspect,. First here is the section of code: @Pointcut("execution(@Tracing * *(..)) && @annotation(tracing)") void annotatedMethods(Tracing tracing) { } @AfterThrowing(pointcut = "annotatedMethods(tracing)", throwing = "t") public void logException(JoinPoint thisJoinPoint, Tracing tracing, Throwable t) { Level level = Level.toLevel(tracing.level()); if (logger.isEnabledFor(level)) { logger.log(level, formatter.formatSignatureThrowing(thisJoinPoint), t); } } So I am matching on all methods annotated with @Tracing and logging the subclass of Throwable that may have been thrown. However when I run my test case i get the following error: java.lang.VerifyError: (class: com/db/abfo/tracing/PojoOne, method: calculate signature: ()V) catch_type not a subclass of Throwable This used to work when I used the aspectj after throwing language extention form: pointcut annotatedMethods(Tracing tracing) : execution(@Tracing * *(..)) && @annotation(tracing); after(Tracing tracing) throwing(Throwable t) : annotatedMethods(tracing) { Level level = tracing.level().getLevel(); if (logger.isEnabledFor(level)) { logger.log(level, formatter.formatSignatureThrowing(thisJoinPoint), t); } }
|
resolved fixed
|
9de03b7
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2007-12-02T09:24:51Z | 2007-12-01T17:26:40Z |
tests/src/org/aspectj/systemtest/ajc154/Ajc154Tests.java
|
public boolean couldMatchJoinPointsInType(Class aClass, MatchingContext context) {
if (this.beanNamePattern.equals(context.getBinding("beanName"))) {
return true;
} else {
return false;
}
}
/* (non-Javadoc)
* @see org.aspectj.weaver.tools.ContextBasedMatcher#mayNeedDynamicTest()
*/
public boolean mayNeedDynamicTest() {
return this.simulateDynamicTest;
}
public FuzzyBoolean matchesStatically(MatchingContext matchContext) {
if (this.simulateDynamicTest) return FuzzyBoolean.MAYBE;
if (this.beanNamePattern.equals(matchContext.getBinding("beanName"))) {
return FuzzyBoolean.YES;
} else {
return FuzzyBoolean.NO;
}
}
/* (non-Javadoc)
* @see org.aspectj.weaver.tools.ContextBasedMatcher#matchesDynamically(org.aspectj.weaver.tools.MatchingContext)
*/
public boolean matchesDynamically(MatchingContext matchContext) {
return this.beanNamePattern.equals(matchContext.getBinding("beanName"));
}
}
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
/*******************************************************************************
* Copyright (c) 2000, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http:www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.aspectj.org.eclipse.jdt.core.dom;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.aspectj.ajdt.internal.compiler.ast.AdviceDeclaration;
import org.aspectj.ajdt.internal.compiler.ast.AspectDeclaration;
import org.aspectj.ajdt.internal.compiler.ast.DeclareDeclaration;
import org.aspectj.ajdt.internal.compiler.ast.InterTypeConstructorDeclaration;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
import org.aspectj.ajdt.internal.compiler.ast.InterTypeDeclaration;
import org.aspectj.ajdt.internal.compiler.ast.InterTypeFieldDeclaration;
import org.aspectj.ajdt.internal.compiler.ast.InterTypeMethodDeclaration;
import org.aspectj.ajdt.internal.compiler.ast.PointcutDeclaration;
import org.aspectj.org.eclipse.jdt.core.compiler.CategorizedProblem;
import org.aspectj.org.eclipse.jdt.core.compiler.CharOperation;
import org.aspectj.org.eclipse.jdt.core.compiler.IProblem;
import org.aspectj.org.eclipse.jdt.core.compiler.InvalidInputException;
import org.aspectj.org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.Argument;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ForeachStatement;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.JavadocArgumentExpression;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.JavadocFieldReference;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.JavadocMessageSend;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.ParameterizedSingleTypeReference;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.StringLiteralConcatenation;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.aspectj.org.eclipse.jdt.internal.compiler.ast.Wildcard;
import org.aspectj.org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.aspectj.org.eclipse.jdt.internal.compiler.env.IGenericType;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.aspectj.org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.aspectj.org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.aspectj.org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
import org.aspectj.weaver.AdviceKind;
import org.aspectj.weaver.patterns.Declare;
import org.aspectj.weaver.patterns.DeclareAnnotation;
import org.aspectj.weaver.patterns.DeclareErrorOrWarning;
import org.aspectj.weaver.patterns.DeclareParents;
import org.aspectj.weaver.patterns.DeclarePrecedence;
import org.aspectj.weaver.patterns.DeclareSoft;
import org.aspectj.weaver.patterns.PatternNode;
import org.aspectj.weaver.patterns.SignaturePattern;
import org.aspectj.weaver.patterns.TypePattern;
import org.eclipse.core.runtime.IProgressMonitor;
/**
* Internal class for converting internal compiler ASTs into public ASTs.
*/
public class AjASTConverter extends ASTConverter {
public AjASTConverter(Map options, boolean resolveBindings, IProgressMonitor monitor) {
super(options,resolveBindings,monitor);
}
public ASTNode convert(AdviceDeclaration adviceDeclaration){
org.aspectj.org.eclipse.jdt.core.dom.AdviceDeclaration adviceDecl = null;
if (adviceDeclaration.kind.equals(AdviceKind.Before)){
adviceDecl = new org.aspectj.org.eclipse.jdt.core.dom.BeforeAdviceDeclaration(this.ast);
} else if (adviceDeclaration.kind.equals(AdviceKind.After)){
adviceDecl = new org.aspectj.org.eclipse.jdt.core.dom.AfterAdviceDeclaration(this.ast);
} else if (adviceDeclaration.kind.equals(AdviceKind.AfterThrowing)){
adviceDecl = new AfterThrowingAdviceDeclaration(this.ast);
if (adviceDeclaration.extraArgument != null) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
SingleVariableDeclaration throwing = convert(adviceDeclaration.extraArgument);
((AfterThrowingAdviceDeclaration)adviceDecl).setThrowing(throwing);
}
} else if (adviceDeclaration.kind.equals(AdviceKind.AfterReturning)){
adviceDecl = new AfterReturningAdviceDeclaration(this.ast);
if (adviceDeclaration.extraArgument != null) {
SingleVariableDeclaration returning = convert(adviceDeclaration.extraArgument);
((AfterReturningAdviceDeclaration)adviceDecl).setReturning(returning);
}
} else if (adviceDeclaration.kind.equals(AdviceKind.Around)){
adviceDecl = new AroundAdviceDeclaration(this.ast);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeReference = adviceDeclaration.returnType;
if (typeReference != null) {
Type returnType = convertType(typeReference);
setTypeForAroundAdviceDeclaration((AroundAdviceDeclaration)adviceDecl, returnType);
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeParameter[] typeParameters = adviceDeclaration.typeParameters();
if (typeParameters != null) {
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
adviceDecl.setFlags(adviceDecl.getFlags() | ASTNode.MALFORMED);
break;
case AST.JLS3 :
for (int i = 0, max = typeParameters.length; i < max; i++) {
((AroundAdviceDeclaration)adviceDecl).typeParameters().add(convert(typeParameters[i]));
}
}
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
org.aspectj.weaver.patterns.Pointcut pointcut = adviceDeclaration.pointcutDesignator.getPointcut();
adviceDecl.setPointcut(convert(pointcut));
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference[] thrownExceptions = adviceDeclaration.thrownExceptions;
if (thrownExceptions != null) {
int thrownExceptionsLength = thrownExceptions.length;
for (int i = 0; i < thrownExceptionsLength; i++) {
adviceDecl.thrownExceptions().add(convert(thrownExceptions[i]));
}
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Argument[] parameters = adviceDeclaration.arguments;
if (parameters != null) {
int parametersLength = parameters.length;
for (int i = 0; i < parametersLength; i++) {
adviceDecl.parameters().add(convert(parameters[i]));
}
}
int start = adviceDeclaration.sourceStart;
int end = retrieveIdentifierEndPosition(start, adviceDeclaration.sourceEnd);
int declarationSourceStart = adviceDeclaration.declarationSourceStart;
int declarationSourceEnd = adviceDeclaration.bodyEnd;
adviceDecl.setSourceRange(declarationSourceStart, declarationSourceEnd - declarationSourceStart + 1);
int closingPosition = retrieveRightBraceOrSemiColonPosition(adviceDeclaration.bodyEnd + 1, adviceDeclaration.declarationSourceEnd);
if (closingPosition != -1) {
int startPosition = adviceDecl.getStartPosition();
adviceDecl.setSourceRange(startPosition, closingPosition - startPosition + 1);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement[] statements = adviceDeclaration.statements;
start = retrieveStartBlockPosition(adviceDeclaration.sourceStart, declarationSourceEnd);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
end = retrieveEndBlockPosition(adviceDeclaration.sourceStart, adviceDeclaration.declarationSourceEnd);
Block block = null;
if (start != -1 && end != -1) {
/*
* start or end can be equal to -1 if we have an interface's method.
*/
block = new Block(this.ast);
block.setSourceRange(start, end - start + 1);
adviceDecl.setBody(block);
}
if (block != null && statements != null) {
int statementsLength = statements == null ? 0 : statements.length;
for (int i = 0; i < statementsLength; i++) {
if (statements[i] instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) {
checkAndAddMultipleLocalDeclaration(statements, i, block.statements());
} else {
block.statements().add(convert(statements[i]));
}
}
}
if (block != null) {
adviceDecl.setFlags(adviceDecl.getFlags() | ASTNode.MALFORMED);
}
} else {
start = retrieveStartBlockPosition(adviceDeclaration.sourceStart, declarationSourceEnd);
end = adviceDeclaration.bodyEnd;
IProblem[] problems = adviceDeclaration.compilationResult().problems;
if (problems != null) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
for (int i = 0, max = adviceDeclaration.compilationResult().problemCount; i < max; i++) {
IProblem currentProblem = problems[i];
if (currentProblem.getSourceStart() == start && currentProblem.getID() == IProblem.ParsingErrorInsertToComplete) {
end = currentProblem.getSourceEnd();
break;
}
}
}
int startPosition = adviceDecl.getStartPosition();
adviceDecl.setSourceRange(startPosition, end - startPosition + 1);
if (start != -1 && end != -1) {
/*
* start or end can be equal to -1 if we have an interface's method.
*/
Block block = new Block(this.ast);
block.setSourceRange(start, end - start + 1);
adviceDecl.setBody(block);
}
}
if (this.resolveBindings) {
recordNodes(adviceDecl, adviceDeclaration);
}
} else {
convert(adviceDeclaration.javadoc, adviceDecl);
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
return adviceDecl;
}
public ASTNode convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration methodDeclaration) {
checkCanceled();
if (methodDeclaration instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration) methodDeclaration);
}
MethodDeclaration methodDecl = new MethodDeclaration(this.ast);
boolean isConstructor = methodDeclaration.isConstructor();
methodDecl.setConstructor(isConstructor);
if (methodDeclaration instanceof DeclareDeclaration){
return convert((DeclareDeclaration)methodDeclaration);
} else if (methodDeclaration instanceof InterTypeFieldDeclaration){
return convert((InterTypeFieldDeclaration) methodDeclaration);
} else if (methodDeclaration instanceof InterTypeMethodDeclaration){
methodDecl = new org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration(this.ast);
} else if (methodDeclaration instanceof InterTypeConstructorDeclaration){
methodDecl = new org.aspectj.org.eclipse.jdt.core.dom.InterTypeMethodDeclaration(this.ast);
methodDecl.setConstructor(true);
} else if (methodDeclaration instanceof PointcutDeclaration){
return convert((PointcutDeclaration) methodDeclaration);
} else if (methodDeclaration instanceof AdviceDeclaration){
return convert((AdviceDeclaration)methodDeclaration);
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
setModifiers(methodDecl, methodDeclaration);
final SimpleName methodName = new SimpleName(this.ast);
if (methodDeclaration instanceof InterTypeDeclaration) {
InterTypeDeclaration itd = (InterTypeDeclaration) methodDeclaration;
methodName.internalSetIdentifier(new String(itd.getDeclaredSelector()));
} else {
methodName.internalSetIdentifier(new String(methodDeclaration.selector));
}
int start = methodDeclaration.sourceStart;
int end = retrieveIdentifierEndPosition(start, methodDeclaration.sourceEnd);
methodName.setSourceRange(start, end - start + 1);
methodDecl.setName(methodName);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference[] thrownExceptions = methodDeclaration.thrownExceptions;
if (thrownExceptions != null) {
int thrownExceptionsLength = thrownExceptions.length;
for (int i = 0; i < thrownExceptionsLength; i++) {
methodDecl.thrownExceptions().add(convert(thrownExceptions[i]));
}
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Argument[] parameters = methodDeclaration.arguments;
if (parameters != null) {
int parametersLength = parameters.length;
for (int i = 0; i < parametersLength; i++) {
methodDecl.parameters().add(convert(parameters[i]));
}
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall explicitConstructorCall = null;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (isConstructor) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration constructorDeclaration = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration) methodDeclaration;
explicitConstructorCall = constructorDeclaration.constructorCall;
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
PrimitiveType returnType = new PrimitiveType(this.ast);
returnType.setPrimitiveTypeCode(PrimitiveType.VOID);
returnType.setSourceRange(methodDeclaration.sourceStart, 0);
methodDecl.internalSetReturnType(returnType);
break;
case AST.JLS3 :
methodDecl.setReturnType2(null);
}
} else if (methodDeclaration instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration method = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.MethodDeclaration) methodDeclaration;
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeReference = method.returnType;
if (typeReference != null) {
Type returnType = convertType(typeReference);
int rightParenthesisPosition = retrieveEndOfRightParenthesisPosition(end, method.bodyEnd);
int extraDimensions = retrieveExtraDimension(rightParenthesisPosition, method.bodyEnd);
methodDecl.setExtraDimensions(extraDimensions);
setTypeForMethodDeclaration(methodDecl, returnType, extraDimensions);
}
}
int declarationSourceStart = methodDeclaration.declarationSourceStart;
int declarationSourceEnd = methodDeclaration.bodyEnd;
methodDecl.setSourceRange(declarationSourceStart, declarationSourceEnd - declarationSourceStart + 1);
int closingPosition = retrieveRightBraceOrSemiColonPosition(methodDeclaration.bodyEnd + 1, methodDeclaration.declarationSourceEnd);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (closingPosition != -1) {
int startPosition = methodDecl.getStartPosition();
methodDecl.setSourceRange(startPosition, closingPosition - startPosition + 1);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement[] statements = methodDeclaration.statements;
start = retrieveStartBlockPosition(methodDeclaration.sourceStart, declarationSourceEnd);
end = retrieveEndBlockPosition(methodDeclaration.sourceStart, methodDeclaration.declarationSourceEnd);
Block block = null;
if (start != -1 && end != -1) {
/*
* start or end can be equal to -1 if we have an interface's method.
*/
block = new Block(this.ast);
block.setSourceRange(start, end - start + 1);
methodDecl.setBody(block);
}
if (block != null && (statements != null || explicitConstructorCall != null)) {
if (explicitConstructorCall != null && explicitConstructorCall.accessMode != org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall.ImplicitSuper) {
block.statements().add(super.convert(explicitConstructorCall));
}
int statementsLength = statements == null ? 0 : statements.length;
for (int i = 0; i < statementsLength; i++) {
if (statements[i] instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) {
checkAndAddMultipleLocalDeclaration(statements, i, block.statements());
} else {
block.statements().add(convert(statements[i]));
}
}
}
if (block != null && (Modifier.isAbstract(methodDecl.getModifiers()) || Modifier.isNative(methodDecl.getModifiers()))) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
methodDecl.setFlags(methodDecl.getFlags() | ASTNode.MALFORMED);
}
} else {
if (!methodDeclaration.isNative() && !methodDeclaration.isAbstract()) {
start = retrieveStartBlockPosition(methodDeclaration.sourceStart, declarationSourceEnd);
end = methodDeclaration.bodyEnd;
IProblem[] problems = methodDeclaration.compilationResult().problems;
if (problems != null) {
for (int i = 0, max = methodDeclaration.compilationResult().problemCount; i < max; i++) {
IProblem currentProblem = problems[i];
if (currentProblem.getSourceStart() == start && currentProblem.getID() == IProblem.ParsingErrorInsertToComplete) {
end = currentProblem.getSourceEnd();
break;
}
}
}
int startPosition = methodDecl.getStartPosition();
methodDecl.setSourceRange(startPosition, end - startPosition + 1);
if (start != -1 && end != -1) {
/*
* start or end can be equal to -1 if we have an interface's method.
*/
Block block = new Block(this.ast);
block.setSourceRange(start, end - start + 1);
methodDecl.setBody(block);
}
}
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeParameter[] typeParameters = methodDeclaration.typeParameters();
if (typeParameters != null) {
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
methodDecl.setFlags(methodDecl.getFlags() | ASTNode.MALFORMED);
break;
case AST.JLS3 :
for (int i = 0, max = typeParameters.length; i < max; i++) {
methodDecl.typeParameters().add(convert(typeParameters[i]));
}
}
}
if (this.resolveBindings) {
recordNodes(methodDecl, methodDeclaration);
recordNodes(methodName, methodDeclaration);
if (methodDecl.resolveBinding() != null) {
convert(methodDeclaration.javadoc, methodDecl);
}
} else {
convert(methodDeclaration.javadoc, methodDecl);
}
return methodDecl;
}
public ASTNode convert(DeclareDeclaration declareDecl) {
checkCanceled();
org.aspectj.org.eclipse.jdt.core.dom.DeclareDeclaration declareDeclaration = null;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
Declare declare = declareDecl.declareDecl;
if (declare instanceof DeclareAnnotation) {
DeclareAnnotation da = (DeclareAnnotation)declare;
if (da.getKind().equals(DeclareAnnotation.AT_TYPE)) {
declareDeclaration = new DeclareAtTypeDeclaration(this.ast);
((DeclareAtTypeDeclaration)declareDeclaration).setPatternNode(convert(da.getTypePattern()));
SimpleName annotationName = new SimpleName(this.ast);
annotationName.internalSetIdentifier(new String(da.getAnnotationString()));
((DeclareAtTypeDeclaration)declareDeclaration).setAnnotationName(annotationName);
} else if (da.getKind().equals(DeclareAnnotation.AT_CONSTRUCTOR)) {
declareDeclaration = new DeclareAtConstructorDeclaration(this.ast);
((DeclareAtConstructorDeclaration)declareDeclaration).setPatternNode(convert(da.getSignaturePattern()));
SimpleName annotationName = new SimpleName(this.ast);
annotationName.internalSetIdentifier(new String(da.getAnnotationString()));
((DeclareAtConstructorDeclaration)declareDeclaration).setAnnotationName(annotationName);
} else if (da.getKind().equals(DeclareAnnotation.AT_FIELD)) {
declareDeclaration = new DeclareAtFieldDeclaration(this.ast);
((DeclareAtFieldDeclaration)declareDeclaration).setPatternNode(convert(da.getSignaturePattern()));
SimpleName annotationName = new SimpleName(this.ast);
annotationName.internalSetIdentifier(new String(da.getAnnotationString()));
((DeclareAtFieldDeclaration)declareDeclaration).setAnnotationName(annotationName);
} else if (da.getKind().equals(DeclareAnnotation.AT_METHOD)) {
declareDeclaration = new DeclareAtMethodDeclaration(this.ast);
((DeclareAtMethodDeclaration)declareDeclaration).setPatternNode(convert(da.getSignaturePattern()));
SimpleName annotationName = new SimpleName(this.ast);
annotationName.internalSetIdentifier(new String(da.getAnnotationString()));
((DeclareAtMethodDeclaration)declareDeclaration).setAnnotationName(annotationName);
}
} else if (declare instanceof DeclareErrorOrWarning){
DeclareErrorOrWarning deow = (DeclareErrorOrWarning)declare;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (deow.isError()) {
declareDeclaration = new DeclareErrorDeclaration(this.ast);
((DeclareErrorDeclaration)declareDeclaration).setPointcut(convert(deow.getPointcut()));
StringLiteral message = new StringLiteral(this.ast);
message.setEscapedValue(updateString(deow.getMessage()));
((DeclareErrorDeclaration)declareDeclaration).setMessage(message);
} else {
declareDeclaration = new DeclareWarningDeclaration(this.ast);
((DeclareWarningDeclaration)declareDeclaration).setPointcut(convert(deow.getPointcut()));
StringLiteral message = new StringLiteral(this.ast);
message.setEscapedValue(updateString(deow.getMessage()));
((DeclareWarningDeclaration)declareDeclaration).setMessage(message);
}
} else if (declare instanceof DeclareParents) {
DeclareParents dp = (DeclareParents)declare;
declareDeclaration = new org.aspectj.org.eclipse.jdt.core.dom.DeclareParentsDeclaration(this.ast,dp.isExtends());
org.aspectj.org.eclipse.jdt.core.dom.PatternNode pNode = convert(dp.getChild());
if (pNode instanceof org.aspectj.org.eclipse.jdt.core.dom.TypePattern) {
((DeclareParentsDeclaration)declareDeclaration).setChildTypePattern((org.aspectj.org.eclipse.jdt.core.dom.TypePattern)pNode);
}
TypePattern[] weaverTypePatterns = dp.getParents().getTypePatterns();
List typePatterns = ((DeclareParentsDeclaration)declareDeclaration).parentTypePatterns();
for (int i = 0; i < weaverTypePatterns.length; i++) {
typePatterns.add(convert(weaverTypePatterns[i]));
}
} else if (declare instanceof DeclarePrecedence) {
declareDeclaration = new org.aspectj.org.eclipse.jdt.core.dom.DeclarePrecedenceDeclaration(this.ast);
DeclarePrecedence dp = (DeclarePrecedence)declare;
TypePattern[] weaverTypePatterns = dp.getPatterns().getTypePatterns();
List typePatterns = ((DeclarePrecedenceDeclaration)declareDeclaration).typePatterns();
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
for (int i = 0; i < weaverTypePatterns.length; i++) {
typePatterns.add(convert(weaverTypePatterns[i]));
}
} else if (declare instanceof DeclareSoft) {
declareDeclaration = new DeclareSoftDeclaration(this.ast);
DeclareSoft ds = (DeclareSoft)declare;
((DeclareSoftDeclaration)declareDeclaration).setPointcut(convert(ds.getPointcut()));
org.aspectj.org.eclipse.jdt.core.dom.PatternNode pNode = convert(ds.getException());
if (pNode instanceof org.aspectj.org.eclipse.jdt.core.dom.TypePattern) {
((DeclareSoftDeclaration)declareDeclaration).setTypePattern((org.aspectj.org.eclipse.jdt.core.dom.TypePattern)pNode);
}
}
declareDeclaration.setSourceRange(declareDecl.declarationSourceStart,
declareDecl.declarationSourceEnd - declareDecl.declarationSourceStart + 1);
return declareDeclaration;
}
private String updateString(String message) {
StringBuffer sb = new StringBuffer(message);
int nextQuote = sb.toString().indexOf("\"");
while (nextQuote != -1) {
sb.insert(nextQuote,"\\");
nextQuote = sb.toString().indexOf("\"");
}
int nextNewLine = sb.toString().indexOf("\n");
while (nextNewLine != -1) {
sb.insert(nextNewLine,"\\");
nextNewLine = sb.toString().indexOf("\n");
}
if(!sb.toString().startsWith("\"")) {
sb.insert(0,"\"");
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
if(!sb.toString().endsWith("\"")) {
sb.insert(sb.toString().length(),"\"");
}
return sb.toString();
}
public ASTNode convert(InterTypeFieldDeclaration fieldDecl) {
checkCanceled();
VariableDeclarationFragment variableDeclarationFragment = convertToVariableDeclarationFragment(fieldDecl);
final org.aspectj.org.eclipse.jdt.core.dom.InterTypeFieldDeclaration fieldDeclaration = new org.aspectj.org.eclipse.jdt.core.dom.InterTypeFieldDeclaration(this.ast);
fieldDeclaration.fragments().add(variableDeclarationFragment);
IVariableBinding binding = null;
if (this.resolveBindings) {
recordNodes(variableDeclarationFragment, fieldDecl);
binding = variableDeclarationFragment.resolveBinding();
}
fieldDeclaration.setSourceRange(fieldDecl.declarationSourceStart, fieldDecl.declarationSourceEnd - fieldDecl.declarationSourceStart + 1);
Type type = convertType(fieldDecl.returnType);
setTypeForField(fieldDeclaration, type, variableDeclarationFragment.getExtraDimensions());
setModifiers(fieldDeclaration, fieldDecl);
if (!(this.resolveBindings && binding == null)) {
convert(fieldDecl.javadoc, fieldDeclaration);
}
return fieldDeclaration;
}
public ASTNode convert(PointcutDeclaration pointcutDeclaration) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
checkCanceled();
org.aspectj.org.eclipse.jdt.core.dom.PointcutDeclaration pointcutDecl = new org.aspectj.org.eclipse.jdt.core.dom.PointcutDeclaration(this.ast);
setModifiers(pointcutDecl, pointcutDeclaration);
final SimpleName pointcutName = new SimpleName(this.ast);
pointcutName.internalSetIdentifier(new String(pointcutDeclaration.selector));
int start = pointcutDeclaration.sourceStart;
int end = retrieveIdentifierEndPosition(start, pointcutDeclaration.sourceEnd);
pointcutName.setSourceRange(start, end - start + 1);
pointcutDecl.setSourceRange(pointcutDeclaration.declarationSourceStart, (pointcutDeclaration.bodyEnd - pointcutDeclaration.declarationSourceStart + 1));
pointcutDecl.setName(pointcutName);
if (pointcutDeclaration.pointcutDesignator != null){
pointcutDecl.setDesignator((org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator)convert(pointcutDeclaration.pointcutDesignator.getPointcut()));
} else {
pointcutDecl.setDesignator(new org.aspectj.org.eclipse.jdt.core.dom.DefaultPointcut(this.ast,pointcutDeclaration.toString()));
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Argument[] parameters = pointcutDeclaration.arguments;
if (parameters != null) {
int parametersLength = parameters.length;
for (int i = 0; i < parametersLength; i++) {
pointcutDecl.parameters().add(convert(parameters[i]));
}
}
if (this.resolveBindings) {
recordNodes(pointcutDecl, pointcutDeclaration);
recordNodes(pointcutName, pointcutDeclaration);
} else {
convert(pointcutDeclaration.javadoc, pointcutDecl);
}
return pointcutDecl;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
public org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator convert(org.aspectj.weaver.patterns.Pointcut pointcut){
org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator pointcutDesi = null;
if (pointcut instanceof org.aspectj.weaver.patterns.ReferencePointcut){
pointcutDesi = new org.aspectj.org.eclipse.jdt.core.dom.ReferencePointcut(this.ast);
final SimpleName pointcutName = new SimpleName(this.ast);
int start = pointcut.getStart();
int end = retrieveIdentifierEndPosition(start, pointcut.getEnd());
pointcutName.setSourceRange(start, end - start + 1);
pointcutName.internalSetIdentifier(((org.aspectj.weaver.patterns.ReferencePointcut)pointcut).name);
((org.aspectj.org.eclipse.jdt.core.dom.ReferencePointcut)pointcutDesi).setName(pointcutName);
} else if (pointcut instanceof org.aspectj.weaver.patterns.NotPointcut) {
pointcutDesi = new org.aspectj.org.eclipse.jdt.core.dom.NotPointcut(this.ast);
final org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator body = convert(((org.aspectj.weaver.patterns.NotPointcut)pointcut).getNegatedPointcut());
((org.aspectj.org.eclipse.jdt.core.dom.NotPointcut)pointcutDesi).setBody(body);
} else if (pointcut instanceof org.aspectj.weaver.patterns.PerObject) {
pointcutDesi = new org.aspectj.org.eclipse.jdt.core.dom.PerObject(this.ast);
final org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator body = convert(((org.aspectj.weaver.patterns.PerObject)pointcut).getEntry());
((org.aspectj.org.eclipse.jdt.core.dom.PerObject)pointcutDesi).setBody(body);
} else if (pointcut instanceof org.aspectj.weaver.patterns.PerCflow) {
pointcutDesi = new org.aspectj.org.eclipse.jdt.core.dom.PerCflow(this.ast);
final org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator body = convert(((org.aspectj.weaver.patterns.PerCflow)pointcut).getEntry());
((org.aspectj.org.eclipse.jdt.core.dom.PerCflow)pointcutDesi).setBody(body);
} else if (pointcut instanceof org.aspectj.weaver.patterns.PerTypeWithin) {
pointcutDesi = new org.aspectj.org.eclipse.jdt.core.dom.PerTypeWithin(this.ast);
} else if (pointcut instanceof org.aspectj.weaver.patterns.CflowPointcut) {
pointcutDesi = new org.aspectj.org.eclipse.jdt.core.dom.CflowPointcut(this.ast);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
final org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator body = convert(((org.aspectj.weaver.patterns.CflowPointcut)pointcut).getEntry());
((org.aspectj.org.eclipse.jdt.core.dom.CflowPointcut)pointcutDesi).setBody(body);
((org.aspectj.org.eclipse.jdt.core.dom.CflowPointcut)pointcutDesi).setIsCflowBelow(((org.aspectj.weaver.patterns.CflowPointcut)pointcut).isCflowBelow());
} else if (pointcut instanceof org.aspectj.weaver.patterns.AndPointcut) {
pointcutDesi = new org.aspectj.org.eclipse.jdt.core.dom.AndPointcut(this.ast);
final org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator left = convert(((org.aspectj.weaver.patterns.AndPointcut)pointcut).getLeft());
final org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator right = convert(((org.aspectj.weaver.patterns.AndPointcut)pointcut).getRight());
((org.aspectj.org.eclipse.jdt.core.dom.AndPointcut)pointcutDesi).setLeft(left);
((org.aspectj.org.eclipse.jdt.core.dom.AndPointcut)pointcutDesi).setRight(right);
} else if (pointcut instanceof org.aspectj.weaver.patterns.OrPointcut) {
pointcutDesi = new org.aspectj.org.eclipse.jdt.core.dom.OrPointcut(this.ast);
final org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator left = convert(((org.aspectj.weaver.patterns.OrPointcut)pointcut).getLeft());
final org.aspectj.org.eclipse.jdt.core.dom.PointcutDesignator right = convert(((org.aspectj.weaver.patterns.OrPointcut)pointcut).getRight());
((org.aspectj.org.eclipse.jdt.core.dom.OrPointcut)pointcutDesi).setLeft(left);
((org.aspectj.org.eclipse.jdt.core.dom.OrPointcut)pointcutDesi).setRight(right);
} else {
pointcutDesi = new org.aspectj.org.eclipse.jdt.core.dom.DefaultPointcut(this.ast,pointcut.toString());
}
pointcutDesi.setSourceRange(pointcut.getStart(),(pointcut.getEnd() - pointcut.getStart() + 1));
return pointcutDesi;
}
public org.aspectj.org.eclipse.jdt.core.dom.PatternNode convert(PatternNode patternNode){
org.aspectj.org.eclipse.jdt.core.dom.PatternNode pNode = null;
if (patternNode instanceof TypePattern) {
TypePattern typePat = (TypePattern)patternNode;
pNode = new DefaultTypePattern(this.ast,typePat.toString());
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
pNode.setSourceRange(typePat.getStart(),(typePat.getEnd() - typePat.getStart() + 1));
} else if (patternNode instanceof SignaturePattern) {
SignaturePattern sigPat = (SignaturePattern)patternNode;
pNode = new org.aspectj.org.eclipse.jdt.core.dom.SignaturePattern(this.ast,sigPat.toString());
pNode.setSourceRange(sigPat.getStart(),(sigPat.getEnd() - sigPat.getStart() + 1));
}
return pNode;
}
public ASTNode convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration annotationTypeMemberDeclaration) {
checkCanceled();
if (this.ast.apiLevel == AST.JLS2_INTERNAL) {
return null;
}
AnnotationTypeMemberDeclaration annotationTypeMemberDeclaration2 = new AnnotationTypeMemberDeclaration(this.ast);
setModifiers(annotationTypeMemberDeclaration2, annotationTypeMemberDeclaration);
final SimpleName methodName = new SimpleName(this.ast);
methodName.internalSetIdentifier(new String(annotationTypeMemberDeclaration.selector));
int start = annotationTypeMemberDeclaration.sourceStart;
int end = retrieveIdentifierEndPosition(start, annotationTypeMemberDeclaration.sourceEnd);
methodName.setSourceRange(start, end - start + 1);
annotationTypeMemberDeclaration2.setName(methodName);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeReference = annotationTypeMemberDeclaration.returnType;
if (typeReference != null) {
Type returnType = convertType(typeReference);
setTypeForMethodDeclaration(annotationTypeMemberDeclaration2, returnType, 0);
}
int declarationSourceStart = annotationTypeMemberDeclaration.declarationSourceStart;
int declarationSourceEnd = annotationTypeMemberDeclaration.bodyEnd;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
annotationTypeMemberDeclaration2.setSourceRange(declarationSourceStart, declarationSourceEnd - declarationSourceStart + 1);
convert(annotationTypeMemberDeclaration.javadoc, annotationTypeMemberDeclaration2);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression memberValue = annotationTypeMemberDeclaration.defaultValue;
if (memberValue != null) {
annotationTypeMemberDeclaration2.setDefault(super.convert(memberValue));
}
if (this.resolveBindings) {
recordNodes(annotationTypeMemberDeclaration2, annotationTypeMemberDeclaration);
recordNodes(methodName, annotationTypeMemberDeclaration);
annotationTypeMemberDeclaration2.resolveBinding();
}
return annotationTypeMemberDeclaration2;
}
public SingleVariableDeclaration convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.Argument argument) {
SingleVariableDeclaration variableDecl = new SingleVariableDeclaration(this.ast);
setModifiers(variableDecl, argument);
final SimpleName name = new SimpleName(this.ast);
name.internalSetIdentifier(new String(argument.name));
int start = argument.sourceStart;
int nameEnd = argument.sourceEnd;
name.setSourceRange(start, nameEnd - start + 1);
variableDecl.setName(name);
final int typeSourceEnd = argument.type.sourceEnd;
final int extraDimensions = retrieveExtraDimension(nameEnd + 1, typeSourceEnd);
variableDecl.setExtraDimensions(extraDimensions);
final boolean isVarArgs = argument.isVarArgs();
if (isVarArgs && extraDimensions == 0) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
argument.type.sourceEnd = retrieveEllipsisStartPosition(argument.type.sourceStart, typeSourceEnd);
}
Type type = convertType(argument.type);
int typeEnd = type.getStartPosition() + type.getLength() - 1;
int rightEnd = Math.max(typeEnd, argument.declarationSourceEnd);
/*
* There is extra work to do to set the proper type positions
* See PR http:bugs.eclipse.org/bugs/show_bug.cgi?id=23284
*/
if (isVarArgs) {
setTypeForSingleVariableDeclaration(variableDecl, type, extraDimensions + 1);
if (extraDimensions != 0) {
variableDecl.setFlags(variableDecl.getFlags() | ASTNode.MALFORMED);
}
} else {
setTypeForSingleVariableDeclaration(variableDecl, type, extraDimensions);
}
variableDecl.setSourceRange(argument.declarationSourceStart, rightEnd - argument.declarationSourceStart + 1);
if (isVarArgs) {
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
variableDecl.setFlags(variableDecl.getFlags() | ASTNode.MALFORMED);
break;
case AST.JLS3 :
variableDecl.setVarargs(true);
}
}
if (this.resolveBindings) {
recordNodes(name, argument);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
recordNodes(variableDecl, argument);
variableDecl.resolveBinding();
}
return variableDecl;
}
}
}
}
}
}
}
}
}
}
}
public ArrayInitializer convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.ArrayInitializer expression) {
ArrayInitializer arrayInitializer = new ArrayInitializer(this.ast);
if (this.resolveBindings) {
recordNodes(arrayInitializer, expression);
}
arrayInitializer.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression[] expressions = expression.expressions;
if (expressions != null) {
int length = expressions.length;
for (int i = 0; i < length; i++) {
Expression expr = super.convert(expressions[i]);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (this.resolveBindings) {
recordNodes(expr, expressions[i]);
}
arrayInitializer.expressions().add(expr);
}
}
return arrayInitializer;
}
}
}
}
}
}
}
/*
* Internal use only
* Used to convert class body declarations
*/
public TypeDeclaration convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode[] nodes) {
final TypeDeclaration typeDecl = TypeDeclaration.getTypeDeclaration(this.ast);
typeDecl.setInterface(false);
int nodesLength = nodes.length;
for (int i = 0; i < nodesLength; i++) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode node = nodes[i];
if (node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.Initializer) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Initializer oldInitializer = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.Initializer) node;
Initializer initializer = new Initializer(this.ast);
initializer.setBody(convert(oldInitializer.block));
setModifiers(initializer, oldInitializer);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
initializer.setSourceRange(oldInitializer.declarationSourceStart, oldInitializer.sourceEnd - oldInitializer.declarationSourceStart + 1);
convert(oldInitializer.javadoc, initializer);
typeDecl.bodyDeclarations().add(initializer);
} else if (node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration fieldDeclaration = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration) node;
if (i > 0
&& (nodes[i - 1] instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration)
&& ((org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration)nodes[i - 1]).declarationSourceStart == fieldDeclaration.declarationSourceStart) {
FieldDeclaration currentFieldDeclaration = (FieldDeclaration) typeDecl.bodyDeclarations().get(typeDecl.bodyDeclarations().size() - 1);
currentFieldDeclaration.fragments().add(convertToVariableDeclarationFragment(fieldDeclaration));
} else {
typeDecl.bodyDeclarations().add(convertToFieldDeclaration(fieldDeclaration));
}
} else if(node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration) {
AbstractMethodDeclaration nextMethodDeclaration = (AbstractMethodDeclaration) node;
if (!nextMethodDeclaration.isDefaultConstructor() && !nextMethodDeclaration.isClinit()) {
typeDecl.bodyDeclarations().add(convert(nextMethodDeclaration));
}
} else if(node instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration nextMemberDeclaration = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) node;
ASTNode nextMemberDeclarationNode = convert(nextMemberDeclaration);
if (nextMemberDeclarationNode == null) {
typeDecl.setFlags(typeDecl.getFlags() | ASTNode.MALFORMED);
} else {
typeDecl.bodyDeclarations().add(nextMemberDeclarationNode);
}
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
return typeDecl;
}
}
}
}
}
}
}
}
}
}
public Block convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.Block statement) {
Block block = new Block(this.ast);
if (statement.sourceEnd > 0) {
block.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement[] statements = statement.statements;
if (statements != null) {
int statementsLength = statements.length;
for (int i = 0; i < statementsLength; i++) {
if (statements[i] instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) {
checkAndAddMultipleLocalDeclaration(statements, i, block.statements());
} else {
block.statements().add(convert(statements[i]));
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
}
return block;
}
public BreakStatement convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.BreakStatement statement) {
BreakStatement breakStatement = new BreakStatement(this.ast);
breakStatement.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
if (statement.label != null) {
final SimpleName name = new SimpleName(this.ast);
name.internalSetIdentifier(new String(statement.label));
retrieveIdentifierAndSetPositions(statement.sourceStart, statement.sourceEnd, name);
breakStatement.setLabel(name);
}
retrieveSemiColonPosition(breakStatement);
return breakStatement;
}
}
}
}
}
}
public CharacterLiteral convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.CharLiteral expression) {
int length = expression.sourceEnd - expression.sourceStart + 1;
int sourceStart = expression.sourceStart;
CharacterLiteral literal = new CharacterLiteral(this.ast);
if (this.resolveBindings) {
this.recordNodes(literal, expression);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
literal.internalSetEscapedValue(new String(this.compilationUnitSource, sourceStart, length));
literal.setSourceRange(sourceStart, length);
removeLeadingAndTrailingCommentsFromLiteral(literal);
return literal;
}
public Expression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.ClassLiteralAccess expression) {
TypeLiteral typeLiteral = new TypeLiteral(this.ast);
if (this.resolveBindings) {
this.recordNodes(typeLiteral, expression);
}
typeLiteral.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
typeLiteral.setType(convertType(expression.type));
return typeLiteral;
}
public CompilationUnit convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration unit, char[] source) {
this.compilationUnitSource = source;
this.compilationUnitSourceLength = source.length;
this.scanner.setSource(source, unit.compilationResult);
CompilationUnit compilationUnit = new CompilationUnit(this.ast);
int[][] comments = unit.comments;
if (comments != null) {
buildCommentsTable(compilationUnit, comments);
}
if (this.resolveBindings) {
recordNodes(compilationUnit, unit);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
if (unit.currentPackage != null) {
PackageDeclaration packageDeclaration = convertPackage(unit);
compilationUnit.setPackage(packageDeclaration);
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.ImportReference[] imports = unit.imports;
if (imports != null) {
int importLength = imports.length;
for (int i = 0; i < importLength; i++) {
compilationUnit.imports().add(convertImport(imports[i]));
}
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration[] types = unit.types;
if (types != null) {
int typesLength = types.length;
for (int i = 0; i < typesLength; i++) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration declaration = types[i];
if (CharOperation.equals(declaration.name, TypeConstants.PACKAGE_INFO_NAME)) {
continue;
}
ASTNode type = convert(declaration);
if (type == null) {
compilationUnit.setFlags(compilationUnit.getFlags() | ASTNode.MALFORMED);
} else {
compilationUnit.types().add(type);
}
}
}
compilationUnit.setSourceRange(unit.sourceStart, unit.sourceEnd - unit.sourceStart + 1);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
int problemLength = unit.compilationResult.problemCount;
if (problemLength != 0) {
CategorizedProblem[] resizedProblems = null;
final CategorizedProblem[] problems = unit.compilationResult.getProblems();
final int realProblemLength=problems.length;
if (realProblemLength == problemLength) {
resizedProblems = problems;
} else {
System.arraycopy(problems, 0, (resizedProblems = new CategorizedProblem[realProblemLength]), 0, realProblemLength);
}
ASTSyntaxErrorPropagator syntaxErrorPropagator = new ASTSyntaxErrorPropagator(resizedProblems);
compilationUnit.accept(syntaxErrorPropagator);
compilationUnit.setProblems(resizedProblems);
}
if (this.resolveBindings) {
lookupForScopes();
}
compilationUnit.initCommentMapper(this.scanner);
return compilationUnit;
}
}
}
}
}
}
}
}
}
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
}
}
}
}
}
}
}
}
}
}
public StringLiteral convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExtendedStringLiteral expression) {
expression.computeConstant();
StringLiteral literal = new StringLiteral(this.ast);
if (this.resolveBindings) {
this.recordNodes(literal, expression);
}
literal.setLiteralValue(expression.constant.stringValue());
literal.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
return literal;
}
public BooleanLiteral convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.FalseLiteral expression) {
final BooleanLiteral literal = new BooleanLiteral(this.ast);
literal.setBooleanValue(false);
if (this.resolveBindings) {
this.recordNodes(literal, expression);
}
literal.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
return literal;
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
public Expression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldReference reference) {
if (reference.receiver.isSuper()) {
final SuperFieldAccess superFieldAccess = new SuperFieldAccess(this.ast);
if (this.resolveBindings) {
recordNodes(superFieldAccess, reference);
}
if (reference.receiver instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference) {
Name qualifier = convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference) reference.receiver);
superFieldAccess.setQualifier(qualifier);
if (this.resolveBindings) {
recordNodes(qualifier, reference.receiver);
}
}
final SimpleName simpleName = new SimpleName(this.ast);
simpleName.internalSetIdentifier(new String(reference.token));
int sourceStart = (int)(reference.nameSourcePosition>>>32);
int length = (int)(reference.nameSourcePosition & 0xFFFFFFFF) - sourceStart + 1;
simpleName.setSourceRange(sourceStart, length);
superFieldAccess.setName(simpleName);
if (this.resolveBindings) {
recordNodes(simpleName, reference);
}
superFieldAccess.setSourceRange(reference.receiver.sourceStart, reference.sourceEnd - reference.receiver.sourceStart + 1);
return superFieldAccess;
} else {
final FieldAccess fieldAccess = new FieldAccess(this.ast);
if (this.resolveBindings) {
recordNodes(fieldAccess, reference);
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
Expression receiver = super.convert(reference.receiver);
fieldAccess.setExpression(receiver);
final SimpleName simpleName = new SimpleName(this.ast);
simpleName.internalSetIdentifier(new String(reference.token));
int sourceStart = (int)(reference.nameSourcePosition>>>32);
int length = (int)(reference.nameSourcePosition & 0xFFFFFFFF) - sourceStart + 1;
simpleName.setSourceRange(sourceStart, length);
fieldAccess.setName(simpleName);
if (this.resolveBindings) {
recordNodes(simpleName, reference);
}
fieldAccess.setSourceRange(receiver.getStartPosition(), reference.sourceEnd - receiver.getStartPosition() + 1);
return fieldAccess;
}
}
public NumberLiteral convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.FloatLiteral expression) {
int length = expression.sourceEnd - expression.sourceStart + 1;
int sourceStart = expression.sourceStart;
NumberLiteral literal = new NumberLiteral(this.ast);
literal.internalSetToken(new String(this.compilationUnitSource, sourceStart, length));
if (this.resolveBindings) {
this.recordNodes(literal, expression);
}
literal.setSourceRange(sourceStart, length);
removeLeadingAndTrailingCommentsFromLiteral(literal);
return literal;
}
public Statement convert(ForeachStatement statement) {
switch(this.ast.apiLevel) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
case AST.JLS2_INTERNAL :
return createFakeEmptyStatement(statement);
case AST.JLS3 :
EnhancedForStatement enhancedForStatement = new EnhancedForStatement(this.ast);
enhancedForStatement.setParameter(convertToSingleVariableDeclaration(statement.elementVariable));
enhancedForStatement.setExpression(super.convert(statement.collection));
enhancedForStatement.setBody(convert(statement.action));
int start = statement.sourceStart;
int end = statement.sourceEnd;
enhancedForStatement.setSourceRange(start, end - start + 1);
return enhancedForStatement;
default:
return createFakeEmptyStatement(statement);
}
}
public ForStatement convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.ForStatement statement) {
ForStatement forStatement = new ForStatement(this.ast);
forStatement.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement[] initializations = statement.initializations;
if (initializations != null) {
if (initializations[0] instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) {
VariableDeclarationExpression variableDeclarationExpression = convertToVariableDeclarationExpression((org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) initializations[0]);
int initializationsLength = initializations.length;
for (int i = 1; i < initializationsLength; i++) {
variableDeclarationExpression.fragments().add(convertToVariableDeclarationFragment((org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration)initializations[i]));
}
if (initializationsLength != 1) {
int start = variableDeclarationExpression.getStartPosition();
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
int end = ((org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) initializations[initializationsLength - 1]).declarationSourceEnd;
variableDeclarationExpression.setSourceRange(start, end - start + 1);
}
forStatement.initializers().add(variableDeclarationExpression);
} else {
int initializationsLength = initializations.length;
for (int i = 0; i < initializationsLength; i++) {
Expression initializer = convertToExpression(initializations[i]);
if (initializer != null) {
forStatement.initializers().add(initializer);
} else {
forStatement.setFlags(forStatement.getFlags() | ASTNode.MALFORMED);
}
}
}
}
if (statement.condition != null) {
forStatement.setExpression(super.convert(statement.condition));
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement[] increments = statement.increments;
if (increments != null) {
int incrementsLength = increments.length;
for (int i = 0; i < incrementsLength; i++) {
forStatement.updaters().add(convertToExpression(increments[i]));
}
}
forStatement.setBody(convert(statement.action));
return forStatement;
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
public IfStatement convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.IfStatement statement) {
IfStatement ifStatement = new IfStatement(this.ast);
ifStatement.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
ifStatement.setExpression(super.convert(statement.condition));
ifStatement.setThenStatement(convert(statement.thenStatement));
if (statement.elseStatement != null) {
ifStatement.setElseStatement(convert(statement.elseStatement));
}
return ifStatement;
}
public InstanceofExpression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.InstanceOfExpression expression) {
InstanceofExpression instanceOfExpression = new InstanceofExpression(this.ast);
if (this.resolveBindings) {
recordNodes(instanceOfExpression, expression);
}
Expression leftExpression = super.convert(expression.expression);
instanceOfExpression.setLeftOperand(leftExpression);
instanceOfExpression.setRightOperand(convertType(expression.type));
int startPosition = leftExpression.getStartPosition();
instanceOfExpression.setSourceRange(startPosition, expression.sourceEnd - startPosition + 1);
return instanceOfExpression;
}
public NumberLiteral convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.IntLiteral expression) {
int length = expression.sourceEnd - expression.sourceStart + 1;
int sourceStart = expression.sourceStart;
final NumberLiteral literal = new NumberLiteral(this.ast);
literal.internalSetToken(new String(this.compilationUnitSource, sourceStart, length));
if (this.resolveBindings) {
this.recordNodes(literal, expression);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
literal.setSourceRange(sourceStart, length);
removeLeadingAndTrailingCommentsFromLiteral(literal);
return literal;
}
public NumberLiteral convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.IntLiteralMinValue expression) {
int length = expression.sourceEnd - expression.sourceStart + 1;
int sourceStart = expression.sourceStart;
NumberLiteral literal = new NumberLiteral(this.ast);
literal.internalSetToken(new String(this.compilationUnitSource, sourceStart, length));
if (this.resolveBindings) {
this.recordNodes(literal, expression);
}
literal.setSourceRange(sourceStart, length);
removeLeadingAndTrailingCommentsFromLiteral(literal);
return literal;
}
public void convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.Javadoc javadoc, BodyDeclaration bodyDeclaration) {
if (bodyDeclaration.getJavadoc() == null) {
if (javadoc != null) {
if (this.commentMapper == null || !this.commentMapper.hasSameTable(this.commentsTable)) {
this.commentMapper = new DefaultCommentMapper(this.commentsTable);
}
Comment comment = this.commentMapper.getComment(javadoc.sourceStart);
if (comment != null && comment.isDocComment() && comment.getParent() == null) {
Javadoc docComment = (Javadoc) comment;
if (this.resolveBindings) {
recordNodes(docComment, javadoc);
Iterator tags = docComment.tags().listIterator();
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
while (tags.hasNext()) {
recordNodes(javadoc, (TagElement) tags.next());
}
}
bodyDeclaration.setJavadoc(docComment);
}
}
}
}
public void convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.Javadoc javadoc, PackageDeclaration packageDeclaration) {
if (ast.apiLevel == AST.JLS3 && packageDeclaration.getJavadoc() == null) {
if (javadoc != null) {
if (this.commentMapper == null || !this.commentMapper.hasSameTable(this.commentsTable)) {
this.commentMapper = new DefaultCommentMapper(this.commentsTable);
}
Comment comment = this.commentMapper.getComment(javadoc.sourceStart);
if (comment != null && comment.isDocComment() && comment.getParent() == null) {
Javadoc docComment = (Javadoc) comment;
if (this.resolveBindings) {
recordNodes(docComment, javadoc);
Iterator tags = docComment.tags().listIterator();
while (tags.hasNext()) {
recordNodes(javadoc, (TagElement) tags.next());
}
}
packageDeclaration.setJavadoc(docComment);
}
}
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
public LabeledStatement convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.LabeledStatement statement) {
LabeledStatement labeledStatement = new LabeledStatement(this.ast);
labeledStatement.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement body = statement.statement;
labeledStatement.setBody(convert(body));
final SimpleName name = new SimpleName(this.ast);
name.internalSetIdentifier(new String(statement.label));
retrieveIdentifierAndSetPositions(statement.sourceStart, statement.sourceEnd, name);
labeledStatement.setLabel(name);
return labeledStatement;
}
public InfixExpression convert(StringLiteralConcatenation expression) {
expression.computeConstant();
final InfixExpression infixExpression = new InfixExpression(this.ast);
infixExpression.setOperator(InfixExpression.Operator.PLUS);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression[] stringLiterals = expression.literals;
infixExpression.setLeftOperand(super.convert(stringLiterals[0]));
infixExpression.setRightOperand(super.convert(stringLiterals[1]));
for (int i = 2; i < expression.counter; i++) {
infixExpression.extendedOperands().add(super.convert(stringLiterals[i]));
}
if (this.resolveBindings) {
this.recordNodes(infixExpression, expression);
}
infixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
return infixExpression;
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
public NormalAnnotation convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.NormalAnnotation annotation) {
final NormalAnnotation normalAnnotation = new NormalAnnotation(this.ast);
setTypeNameForAnnotation(annotation, normalAnnotation);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.MemberValuePair[] memberValuePairs = annotation.memberValuePairs;
if (memberValuePairs != null) {
for (int i = 0, max = memberValuePairs.length; i < max; i++) {
normalAnnotation.values().add(convert(memberValuePairs[i]));
}
}
int start = annotation.sourceStart;
int end = annotation.declarationSourceEnd;
normalAnnotation.setSourceRange(start, end - start + 1);
if (this.resolveBindings) {
recordNodes(normalAnnotation, annotation);
}
return normalAnnotation;
}
public NullLiteral convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.NullLiteral expression) {
final NullLiteral literal = new NullLiteral(this.ast);
if (this.resolveBindings) {
this.recordNodes(literal, expression);
}
literal.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
return literal;
}
public Expression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.OR_OR_Expression expression) {
final InfixExpression infixExpression = new InfixExpression(this.ast);
if (this.resolveBindings) {
recordNodes(infixExpression, expression);
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
Expression leftExpression = super.convert(expression.left);
infixExpression.setLeftOperand(leftExpression);
infixExpression.setRightOperand(super.convert(expression.right));
infixExpression.setOperator(InfixExpression.Operator.CONDITIONAL_OR);
int sourceStart = leftExpression.getStartPosition();
infixExpression.setSourceRange(sourceStart, expression.sourceEnd - sourceStart + 1);
return infixExpression;
}
public PostfixExpression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.PostfixExpression expression) {
final PostfixExpression postfixExpression = new PostfixExpression(this.ast);
if (this.resolveBindings) {
recordNodes(postfixExpression, expression);
}
postfixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
postfixExpression.setOperand(super.convert(expression.lhs));
switch (expression.operator) {
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.PLUS :
postfixExpression.setOperator(PostfixExpression.Operator.INCREMENT);
break;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.MINUS :
postfixExpression.setOperator(PostfixExpression.Operator.DECREMENT);
break;
}
return postfixExpression;
}
public PrefixExpression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.PrefixExpression expression) {
final PrefixExpression prefixExpression = new PrefixExpression(this.ast);
if (this.resolveBindings) {
recordNodes(prefixExpression, expression);
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
prefixExpression.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
prefixExpression.setOperand(super.convert(expression.lhs));
switch (expression.operator) {
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.PLUS :
prefixExpression.setOperator(PrefixExpression.Operator.INCREMENT);
break;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.MINUS :
prefixExpression.setOperator(PrefixExpression.Operator.DECREMENT);
break;
}
return prefixExpression;
}
public Expression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedAllocationExpression allocation) {
final ClassInstanceCreation classInstanceCreation = new ClassInstanceCreation(this.ast);
if (allocation.enclosingInstance != null) {
classInstanceCreation.setExpression(super.convert(allocation.enclosingInstance));
}
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
classInstanceCreation.internalSetName(convert(allocation.type));
break;
case AST.JLS3 :
classInstanceCreation.setType(convertType(allocation.type));
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression[] arguments = allocation.arguments;
if (arguments != null) {
int length = arguments.length;
for (int i = 0; i < length; i++) {
Expression argument = super.convert(arguments[i]);
if (this.resolveBindings) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
recordNodes(argument, arguments[i]);
}
classInstanceCreation.arguments().add(argument);
}
}
if (allocation.typeArguments != null) {
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
classInstanceCreation.setFlags(classInstanceCreation.getFlags() | ASTNode.MALFORMED);
break;
case AST.JLS3 :
for (int i = 0, max = allocation.typeArguments.length; i < max; i++) {
classInstanceCreation.typeArguments().add(convertType(allocation.typeArguments[i]));
}
}
}
if (allocation.anonymousType != null) {
int declarationSourceStart = allocation.sourceStart;
classInstanceCreation.setSourceRange(declarationSourceStart, allocation.anonymousType.bodyEnd - declarationSourceStart + 1);
final AnonymousClassDeclaration anonymousClassDeclaration = new AnonymousClassDeclaration(this.ast);
int start = retrieveStartBlockPosition(allocation.anonymousType.sourceEnd, allocation.anonymousType.bodyEnd);
anonymousClassDeclaration.setSourceRange(start, allocation.anonymousType.bodyEnd - start + 1);
classInstanceCreation.setAnonymousClassDeclaration(anonymousClassDeclaration);
buildBodyDeclarations(allocation.anonymousType, anonymousClassDeclaration);
if (this.resolveBindings) {
recordNodes(classInstanceCreation, allocation.anonymousType);
recordNodes(anonymousClassDeclaration, allocation.anonymousType);
anonymousClassDeclaration.resolveBinding();
}
return classInstanceCreation;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
} else {
final int start = allocation.sourceStart;
classInstanceCreation.setSourceRange(start, allocation.sourceEnd - start + 1);
if (this.resolveBindings) {
recordNodes(classInstanceCreation, allocation);
}
removeTrailingCommentFromExpressionEndingWithAParen(classInstanceCreation);
return classInstanceCreation;
}
}
public Name convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference nameReference) {
return setQualifiedNameNameAndSourceRanges(nameReference.tokens, nameReference.sourcePositions, nameReference);
}
public Name convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference reference) {
return convert(reference.qualification);
}
public ThisExpression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedThisReference reference) {
final ThisExpression thisExpression = new ThisExpression(this.ast);
thisExpression.setSourceRange(reference.sourceStart, reference.sourceEnd - reference.sourceStart + 1);
thisExpression.setQualifier(convert(reference.qualification));
if (this.resolveBindings) {
recordNodes(thisExpression, reference);
recordPendingThisExpressionScopeResolution(thisExpression);
}
return thisExpression;
}
public Expression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.Reference reference) {
if (reference instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.NameReference) {
return super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.NameReference) reference);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
if (reference instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.ThisReference) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.ThisReference) reference);
}
if (reference instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.ArrayReference) {
return super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.ArrayReference) reference);
}
if (reference instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldReference) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldReference) reference);
}
return null;
}
public ReturnStatement convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.ReturnStatement statement) {
final ReturnStatement returnStatement = new ReturnStatement(this.ast);
returnStatement.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
if (statement.expression != null) {
returnStatement.setExpression(super.convert(statement.expression));
}
retrieveSemiColonPosition(returnStatement);
return returnStatement;
}
public SingleMemberAnnotation convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.SingleMemberAnnotation annotation) {
final SingleMemberAnnotation singleMemberAnnotation = new SingleMemberAnnotation(this.ast);
setTypeNameForAnnotation(annotation, singleMemberAnnotation);
singleMemberAnnotation.setValue(super.convert(annotation.memberValue));
int start = annotation.sourceStart;
int end = annotation.declarationSourceEnd;
singleMemberAnnotation.setSourceRange(start, end - start + 1);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (this.resolveBindings) {
recordNodes(singleMemberAnnotation, annotation);
}
return singleMemberAnnotation;
}
public SimpleName convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.SingleNameReference nameReference) {
final SimpleName name = new SimpleName(this.ast);
name.internalSetIdentifier(new String(nameReference.token));
if (this.resolveBindings) {
recordNodes(name, nameReference);
}
name.setSourceRange(nameReference.sourceStart, nameReference.sourceEnd - nameReference.sourceStart + 1);
return name;
}
public Statement convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement statement) {
if (statement instanceof ForeachStatement) {
return convert((ForeachStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration) {
return convertToVariableDeclarationStatement((org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration)statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.AssertStatement) {
return super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.AssertStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.Block) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.Block) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.BreakStatement) {
return super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.BreakStatement) statement);
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.ContinueStatement) {
return super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.ContinueStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.CaseStatement) {
return super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.CaseStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.DoStatement) {
return super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.DoStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.EmptyStatement) {
return super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.EmptyStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall) {
return super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.ForStatement) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.ForStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.IfStatement) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.IfStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.LabeledStatement) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.LabeledStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.ReturnStatement) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.ReturnStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.SwitchStatement) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.SwitchStatement) statement);
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.SynchronizedStatement) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.SynchronizedStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.ThrowStatement) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.ThrowStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.TryStatement) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.TryStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) {
ASTNode result = convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) statement);
if (result == null) {
return createFakeEmptyStatement(statement);
}
switch(result.getNodeType()) {
case ASTNode.ENUM_DECLARATION:
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
return createFakeEmptyStatement(statement);
case AST.JLS3 :
final TypeDeclarationStatement typeDeclarationStatement = new TypeDeclarationStatement(this.ast);
typeDeclarationStatement.setDeclaration((EnumDeclaration) result);
AbstractTypeDeclaration typeDecl = typeDeclarationStatement.getDeclaration();
typeDeclarationStatement.setSourceRange(typeDecl.getStartPosition(), typeDecl.getLength());
return typeDeclarationStatement;
}
break;
case ASTNode.ANNOTATION_TYPE_DECLARATION :
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
return createFakeEmptyStatement(statement);
case AST.JLS3 :
TypeDeclarationStatement typeDeclarationStatement = new TypeDeclarationStatement(this.ast);
typeDeclarationStatement.setDeclaration((AnnotationTypeDeclaration) result);
AbstractTypeDeclaration typeDecl = typeDeclarationStatement.getDeclaration();
typeDeclarationStatement.setSourceRange(typeDecl.getStartPosition(), typeDecl.getLength());
return typeDeclarationStatement;
}
break;
default:
TypeDeclaration typeDeclaration = (TypeDeclaration) result;
if (typeDeclaration == null) {
return createFakeEmptyStatement(statement);
} else {
TypeDeclarationStatement typeDeclarationStatement = new TypeDeclarationStatement(this.ast);
typeDeclarationStatement.setDeclaration(typeDeclaration);
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
TypeDeclaration typeDecl = typeDeclarationStatement.internalGetTypeDeclaration();
typeDeclarationStatement.setSourceRange(typeDecl.getStartPosition(), typeDecl.getLength());
break;
case AST.JLS3 :
AbstractTypeDeclaration typeDeclAST3 = typeDeclarationStatement.getDeclaration();
typeDeclarationStatement.setSourceRange(typeDeclAST3.getStartPosition(), typeDeclAST3.getLength());
break;
}
return typeDeclarationStatement;
}
}
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.WhileStatement) {
return super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.WhileStatement) statement);
}
if (statement instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression) {
final Expression expr = super.convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression) statement);
final ExpressionStatement stmt = new ExpressionStatement(this.ast);
stmt.setExpression(expr);
stmt.setSourceRange(expr.getStartPosition(), expr.getLength());
retrieveSemiColonPosition(stmt);
return stmt;
}
return createFakeEmptyStatement(statement);
}
public Expression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.StringLiteral expression) {
if (expression instanceof StringLiteralConcatenation) {
return convert((StringLiteralConcatenation) expression);
}
int length = expression.sourceEnd - expression.sourceStart + 1;
int sourceStart = expression.sourceStart;
StringLiteral literal = new StringLiteral(this.ast);
if (this.resolveBindings) {
this.recordNodes(literal, expression);
}
literal.internalSetEscapedValue(new String(this.compilationUnitSource, sourceStart, length));
literal.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
return literal;
}
public SwitchStatement convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.SwitchStatement statement) {
SwitchStatement switchStatement = new SwitchStatement(this.ast);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
switchStatement.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
switchStatement.setExpression(super.convert(statement.expression));
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement[] statements = statement.statements;
if (statements != null) {
int statementsLength = statements.length;
for (int i = 0; i < statementsLength; i++) {
switchStatement.statements().add(convert(statements[i]));
}
}
return switchStatement;
}
public SynchronizedStatement convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.SynchronizedStatement statement) {
SynchronizedStatement synchronizedStatement = new SynchronizedStatement(this.ast);
synchronizedStatement.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
synchronizedStatement.setBody(convert(statement.block));
synchronizedStatement.setExpression(super.convert(statement.expression));
return synchronizedStatement;
}
public Expression convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.ThisReference reference) {
if (reference.isImplicitThis()) {
return null;
} else if (reference instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference) reference);
} else if (reference instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedThisReference) {
return convert((org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedThisReference) reference);
} else {
ThisExpression thisExpression = new ThisExpression(this.ast);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
thisExpression.setSourceRange(reference.sourceStart, reference.sourceEnd - reference.sourceStart + 1);
if (this.resolveBindings) {
recordNodes(thisExpression, reference);
recordPendingThisExpressionScopeResolution(thisExpression);
}
return thisExpression;
}
}
public ThrowStatement convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.ThrowStatement statement) {
final ThrowStatement throwStatement = new ThrowStatement(this.ast);
throwStatement.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
throwStatement.setExpression(super.convert(statement.exception));
retrieveSemiColonPosition(throwStatement);
return throwStatement;
}
public BooleanLiteral convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.TrueLiteral expression) {
final BooleanLiteral literal = new BooleanLiteral(this.ast);
literal.setBooleanValue(true);
if (this.resolveBindings) {
this.recordNodes(literal, expression);
}
literal.setSourceRange(expression.sourceStart, expression.sourceEnd - expression.sourceStart + 1);
return literal;
}
public TryStatement convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.TryStatement statement) {
final TryStatement tryStatement = new TryStatement(this.ast);
tryStatement.setSourceRange(statement.sourceStart, statement.sourceEnd - statement.sourceStart + 1);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
tryStatement.setBody(convert(statement.tryBlock));
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Argument[] catchArguments = statement.catchArguments;
if (catchArguments != null) {
int catchArgumentsLength = catchArguments.length;
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Block[] catchBlocks = statement.catchBlocks;
int start = statement.tryBlock.sourceEnd;
for (int i = 0; i < catchArgumentsLength; i++) {
CatchClause catchClause = new CatchClause(this.ast);
int catchClauseSourceStart = retrieveStartingCatchPosition(start, catchArguments[i].sourceStart);
catchClause.setSourceRange(catchClauseSourceStart, catchBlocks[i].sourceEnd - catchClauseSourceStart + 1);
catchClause.setBody(convert(catchBlocks[i]));
catchClause.setException(convert(catchArguments[i]));
tryStatement.catchClauses().add(catchClause);
start = catchBlocks[i].sourceEnd;
}
}
if (statement.finallyBlock != null) {
tryStatement.setFinally(convert(statement.finallyBlock));
}
return tryStatement;
}
public ASTNode convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDeclaration) {
switch (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.kind(typeDeclaration.modifiers)) {
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.ENUM_DECL :
if (this.ast.apiLevel == AST.JLS2_INTERNAL) {
return null;
} else {
return convertToEnumDeclaration(typeDeclaration);
}
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.ANNOTATION_TYPE_DECL :
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (this.ast.apiLevel == AST.JLS2_INTERNAL) {
return null;
} else {
return convertToAnnotationDeclaration(typeDeclaration);
}
}
checkCanceled();
TypeDeclaration typeDecl = TypeDeclaration.getTypeDeclaration(this.ast);
if (typeDeclaration instanceof AspectDeclaration){
org.aspectj.weaver.patterns.PerClause perClause = ((AspectDeclaration)typeDeclaration).perClause;
boolean isPrivileged = ((AspectDeclaration)typeDeclaration).isPrivileged;
if (perClause == null){
typeDecl = new org.aspectj.org.eclipse.jdt.core.dom.AspectDeclaration(this.ast,null, isPrivileged);
} else {
typeDecl = new org.aspectj.org.eclipse.jdt.core.dom.AspectDeclaration(this.ast,convert(perClause), isPrivileged);
}
}
if (typeDeclaration.modifiersSourceStart != -1) {
setModifiers(typeDecl, typeDeclaration);
}
typeDecl.setInterface(org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.kind(typeDeclaration.modifiers) == org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.INTERFACE_DECL);
final SimpleName typeName = new SimpleName(this.ast);
typeName.internalSetIdentifier(new String(typeDeclaration.name));
typeName.setSourceRange(typeDeclaration.sourceStart, typeDeclaration.sourceEnd - typeDeclaration.sourceStart + 1);
typeDecl.setName(typeName);
typeDecl.setSourceRange(typeDeclaration.declarationSourceStart, typeDeclaration.bodyEnd - typeDeclaration.declarationSourceStart + 1);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (typeDeclaration.superclass != null) {
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
typeDecl.internalSetSuperclass(convert(typeDeclaration.superclass));
break;
case AST.JLS3 :
typeDecl.setSuperclassType(convertType(typeDeclaration.superclass));
break;
}
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference[] superInterfaces = typeDeclaration.superInterfaces;
if (superInterfaces != null) {
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
for (int index = 0, length = superInterfaces.length; index < length; index++) {
typeDecl.internalSuperInterfaces().add(convert(superInterfaces[index]));
}
break;
case AST.JLS3 :
for (int index = 0, length = superInterfaces.length; index < length; index++) {
typeDecl.superInterfaceTypes().add(convertType(superInterfaces[index]));
}
}
}
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeParameter[] typeParameters = typeDeclaration.typeParameters;
if (typeParameters != null) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
typeDecl.setFlags(typeDecl.getFlags() | ASTNode.MALFORMED);
break;
case AST.JLS3 :
for (int index = 0, length = typeParameters.length; index < length; index++) {
typeDecl.typeParameters().add(convert(typeParameters[index]));
}
}
}
buildBodyDeclarations(typeDeclaration, typeDecl);
if (this.resolveBindings) {
recordNodes(typeDecl, typeDeclaration);
recordNodes(typeName, typeDeclaration);
typeDecl.resolveBinding();
}
return typeDecl;
}
public TypeParameter convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeParameter typeParameter) {
final TypeParameter typeParameter2 = new TypeParameter(this.ast);
final SimpleName simpleName = new SimpleName(this.ast);
simpleName.internalSetIdentifier(new String(typeParameter.name));
int start = typeParameter.sourceStart;
int end = typeParameter.sourceEnd;
simpleName.setSourceRange(start, end - start + 1);
typeParameter2.setName(simpleName);
final TypeReference superType = typeParameter.type;
end = typeParameter.declarationSourceEnd;
if (superType != null) {
Type type = convertType(superType);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
typeParameter2.typeBounds().add(type);
end = type.getStartPosition() + type.getLength() - 1;
}
TypeReference[] bounds = typeParameter.bounds;
if (bounds != null) {
Type type = null;
for (int index = 0, length = bounds.length; index < length; index++) {
type = convertType(bounds[index]);
typeParameter2.typeBounds().add(type);
end = type.getStartPosition() + type.getLength() - 1;
}
}
start = typeParameter.declarationSourceStart;
end = retrieveClosingAngleBracketPosition(end);
typeParameter2.setSourceRange(start, end - start + 1);
if (this.resolveBindings) {
recordName(simpleName, typeParameter);
recordNodes(typeParameter2, typeParameter);
typeParameter2.resolveBinding();
}
return typeParameter2;
}
public Name convert(org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeReference) {
char[][] typeName = typeReference.getTypeName();
int length = typeName.length;
if (length > 1) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference qualifiedTypeReference = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference) typeReference;
final long[] positions = qualifiedTypeReference.sourcePositions;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
return setQualifiedNameNameAndSourceRanges(typeName, positions, typeReference);
} else {
final SimpleName name = new SimpleName(this.ast);
name.internalSetIdentifier(new String(typeName[0]));
name.setSourceRange(typeReference.sourceStart, typeReference.sourceEnd - typeReference.sourceStart + 1);
if (this.resolveBindings) {
recordNodes(name, typeReference);
}
return name;
}
}
protected FieldDeclaration convertToFieldDeclaration(org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration fieldDecl) {
VariableDeclarationFragment variableDeclarationFragment = convertToVariableDeclarationFragment(fieldDecl);
final FieldDeclaration fieldDeclaration = new FieldDeclaration(this.ast);
fieldDeclaration.fragments().add(variableDeclarationFragment);
IVariableBinding binding = null;
if (this.resolveBindings) {
recordNodes(variableDeclarationFragment, fieldDecl);
binding = variableDeclarationFragment.resolveBinding();
}
fieldDeclaration.setSourceRange(fieldDecl.declarationSourceStart, fieldDecl.declarationEnd - fieldDecl.declarationSourceStart + 1);
Type type = convertType(fieldDecl.type);
setTypeForField(fieldDeclaration, type, variableDeclarationFragment.getExtraDimensions());
setModifiers(fieldDeclaration, fieldDecl);
if (!(this.resolveBindings && binding == null)) {
convert(fieldDecl.javadoc, fieldDeclaration);
}
return fieldDeclaration;
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
}
}
}
protected VariableDeclarationExpression convertToVariableDeclarationExpression(org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration localDeclaration) {
final VariableDeclarationFragment variableDeclarationFragment = convertToVariableDeclarationFragment(localDeclaration);
final VariableDeclarationExpression variableDeclarationExpression = new VariableDeclarationExpression(this.ast);
variableDeclarationExpression.fragments().add(variableDeclarationFragment);
if (this.resolveBindings) {
recordNodes(variableDeclarationFragment, localDeclaration);
}
variableDeclarationExpression.setSourceRange(localDeclaration.declarationSourceStart, localDeclaration.declarationSourceEnd - localDeclaration.declarationSourceStart + 1);
Type type = convertType(localDeclaration.type);
setTypeForVariableDeclarationExpression(variableDeclarationExpression, type, variableDeclarationFragment.getExtraDimensions());
if (localDeclaration.modifiersSourceStart != -1) {
setModifiers(variableDeclarationExpression, localDeclaration);
}
return variableDeclarationExpression;
}
protected SingleVariableDeclaration convertToSingleVariableDeclaration(LocalDeclaration localDeclaration) {
final SingleVariableDeclaration variableDecl = new SingleVariableDeclaration(this.ast);
setModifiers(variableDecl, localDeclaration);
final SimpleName name = new SimpleName(this.ast);
name.internalSetIdentifier(new String(localDeclaration.name));
int start = localDeclaration.sourceStart;
int nameEnd = localDeclaration.sourceEnd;
name.setSourceRange(start, nameEnd - start + 1);
variableDecl.setName(name);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
final int extraDimensions = retrieveExtraDimension(nameEnd + 1, localDeclaration.type.sourceEnd);
variableDecl.setExtraDimensions(extraDimensions);
Type type = convertType(localDeclaration.type);
int typeEnd = type.getStartPosition() + type.getLength() - 1;
int rightEnd = Math.max(typeEnd, localDeclaration.declarationSourceEnd);
/*
* There is extra work to do to set the proper type positions
* See PR http:bugs.eclipse.org/bugs/show_bug.cgi?id=23284
*/
setTypeForSingleVariableDeclaration(variableDecl, type, extraDimensions);
variableDecl.setSourceRange(localDeclaration.declarationSourceStart, rightEnd - localDeclaration.declarationSourceStart + 1);
if (this.resolveBindings) {
recordNodes(name, localDeclaration);
recordNodes(variableDecl, localDeclaration);
variableDecl.resolveBinding();
}
return variableDecl;
}
protected VariableDeclarationFragment convertToVariableDeclarationFragment(InterTypeFieldDeclaration fieldDeclaration) {
final VariableDeclarationFragment variableDeclarationFragment = new VariableDeclarationFragment(this.ast);
final SimpleName name = new SimpleName(this.ast);
name.internalSetIdentifier(new String(fieldDeclaration.getDeclaredSelector()));
name.setSourceRange(fieldDeclaration.sourceStart, fieldDeclaration.sourceEnd - fieldDeclaration.sourceStart + 1);
variableDeclarationFragment.setName(name);
int start = fieldDeclaration.sourceEnd;
if (fieldDeclaration.initialization != null) {
final Expression expression = super.convert(fieldDeclaration.initialization);
variableDeclarationFragment.setInitializer(expression);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
start = expression.getStartPosition() + expression.getLength();
}
int end = retrievePositionBeforeNextCommaOrSemiColon(start, fieldDeclaration.declarationSourceEnd);
if (end == -1) {
variableDeclarationFragment.setSourceRange(fieldDeclaration.sourceStart, fieldDeclaration.declarationSourceEnd - fieldDeclaration.sourceStart + 1);
variableDeclarationFragment.setFlags(variableDeclarationFragment.getFlags() | ASTNode.MALFORMED);
} else {
variableDeclarationFragment.setSourceRange(fieldDeclaration.sourceStart, end - fieldDeclaration.sourceStart + 1);
}
variableDeclarationFragment.setExtraDimensions(retrieveExtraDimension(fieldDeclaration.sourceEnd + 1, fieldDeclaration.declarationSourceEnd ));
if (this.resolveBindings) {
recordNodes(name, fieldDeclaration);
recordNodes(variableDeclarationFragment, fieldDeclaration);
variableDeclarationFragment.resolveBinding();
}
return variableDeclarationFragment;
}
protected VariableDeclarationFragment convertToVariableDeclarationFragment(org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration fieldDeclaration) {
final VariableDeclarationFragment variableDeclarationFragment = new VariableDeclarationFragment(this.ast);
final SimpleName name = new SimpleName(this.ast);
name.internalSetIdentifier(new String(fieldDeclaration.name));
name.setSourceRange(fieldDeclaration.sourceStart, fieldDeclaration.sourceEnd - fieldDeclaration.sourceStart + 1);
variableDeclarationFragment.setName(name);
int start = fieldDeclaration.sourceEnd;
if (fieldDeclaration.initialization != null) {
final Expression expression = super.convert(fieldDeclaration.initialization);
variableDeclarationFragment.setInitializer(expression);
start = expression.getStartPosition() + expression.getLength();
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
int end = retrievePositionBeforeNextCommaOrSemiColon(start, fieldDeclaration.declarationSourceEnd);
if (end == -1) {
variableDeclarationFragment.setSourceRange(fieldDeclaration.sourceStart, fieldDeclaration.declarationSourceEnd - fieldDeclaration.sourceStart + 1);
variableDeclarationFragment.setFlags(variableDeclarationFragment.getFlags() | ASTNode.MALFORMED);
} else {
variableDeclarationFragment.setSourceRange(fieldDeclaration.sourceStart, end - fieldDeclaration.sourceStart + 1);
}
variableDeclarationFragment.setExtraDimensions(retrieveExtraDimension(fieldDeclaration.sourceEnd + 1, fieldDeclaration.declarationSourceEnd ));
if (this.resolveBindings) {
recordNodes(name, fieldDeclaration);
recordNodes(variableDeclarationFragment, fieldDeclaration);
variableDeclarationFragment.resolveBinding();
}
return variableDeclarationFragment;
}
protected VariableDeclarationFragment convertToVariableDeclarationFragment(org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration localDeclaration) {
final VariableDeclarationFragment variableDeclarationFragment = new VariableDeclarationFragment(this.ast);
final SimpleName name = new SimpleName(this.ast);
name.internalSetIdentifier(new String(localDeclaration.name));
name.setSourceRange(localDeclaration.sourceStart, localDeclaration.sourceEnd - localDeclaration.sourceStart + 1);
variableDeclarationFragment.setName(name);
int start = localDeclaration.sourceEnd;
if (localDeclaration.initialization != null) {
final Expression expression = super.convert(localDeclaration.initialization);
variableDeclarationFragment.setInitializer(expression);
start = expression.getStartPosition() + expression.getLength();
}
int end = retrievePositionBeforeNextCommaOrSemiColon(start, localDeclaration.declarationSourceEnd);
if (end == -1) {
if (localDeclaration.initialization != null) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
variableDeclarationFragment.setSourceRange(localDeclaration.sourceStart, localDeclaration.initialization.sourceEnd - localDeclaration.sourceStart + 1);
} else {
variableDeclarationFragment.setSourceRange(localDeclaration.sourceStart, localDeclaration.sourceEnd - localDeclaration.sourceStart + 1);
}
} else {
variableDeclarationFragment.setSourceRange(localDeclaration.sourceStart, end - localDeclaration.sourceStart + 1);
}
variableDeclarationFragment.setExtraDimensions(retrieveExtraDimension(localDeclaration.sourceEnd + 1, this.compilationUnitSourceLength));
if (this.resolveBindings) {
recordNodes(variableDeclarationFragment, localDeclaration);
recordNodes(name, localDeclaration);
variableDeclarationFragment.resolveBinding();
}
return variableDeclarationFragment;
}
protected VariableDeclarationStatement convertToVariableDeclarationStatement(org.aspectj.org.eclipse.jdt.internal.compiler.ast.LocalDeclaration localDeclaration) {
final VariableDeclarationFragment variableDeclarationFragment = convertToVariableDeclarationFragment(localDeclaration);
final VariableDeclarationStatement variableDeclarationStatement = new VariableDeclarationStatement(this.ast);
variableDeclarationStatement.fragments().add(variableDeclarationFragment);
if (this.resolveBindings) {
recordNodes(variableDeclarationFragment, localDeclaration);
}
variableDeclarationStatement.setSourceRange(localDeclaration.declarationSourceStart, localDeclaration.declarationSourceEnd - localDeclaration.declarationSourceStart + 1);
Type type = convertType(localDeclaration.type);
setTypeForVariableDeclarationStatement(variableDeclarationStatement, type, variableDeclarationFragment.getExtraDimensions());
if (localDeclaration.modifiersSourceStart != -1) {
setModifiers(variableDeclarationStatement, localDeclaration);
}
return variableDeclarationStatement;
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
public Type convertType(TypeReference typeReference) {
if (typeReference instanceof Wildcard) {
final Wildcard wildcard = (Wildcard) typeReference;
final WildcardType wildcardType = new WildcardType(this.ast);
if (wildcard.bound != null) {
final Type bound = convertType(wildcard.bound);
wildcardType.setBound(bound, wildcard.kind == Wildcard.EXTENDS);
int start = wildcard.sourceStart;
wildcardType.setSourceRange(start, bound.getStartPosition() + bound.getLength() - start);
} else {
final int start = wildcard.sourceStart;
final int end = wildcard.sourceEnd;
wildcardType.setSourceRange(start, end - start + 1);
}
if (this.resolveBindings) {
recordNodes(wildcardType, typeReference);
}
return wildcardType;
}
Type type = null;
int sourceStart = -1;
int length = 0;
int dimensions = typeReference.dimensions();
if (typeReference instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.SingleTypeReference) {
char[] name = ((org.aspectj.org.eclipse.jdt.internal.compiler.ast.SingleTypeReference) typeReference).getTypeName()[0];
sourceStart = typeReference.sourceStart;
length = typeReference.sourceEnd - typeReference.sourceStart + 1;
if (isPrimitiveType(name)) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
int end = retrieveEndOfElementTypeNamePosition(sourceStart, sourceStart + length);
if (end == -1) {
end = sourceStart + length - 1;
}
final PrimitiveType primitiveType = new PrimitiveType(this.ast);
primitiveType.setPrimitiveTypeCode(getPrimitiveTypeCode(name));
primitiveType.setSourceRange(sourceStart, end - sourceStart + 1);
type = primitiveType;
} else if (typeReference instanceof ParameterizedSingleTypeReference) {
ParameterizedSingleTypeReference parameterizedSingleTypeReference = (ParameterizedSingleTypeReference) typeReference;
final SimpleName simpleName = new SimpleName(this.ast);
simpleName.internalSetIdentifier(new String(name));
int end = retrieveEndOfElementTypeNamePosition(sourceStart, sourceStart + length);
if (end == -1) {
end = sourceStart + length - 1;
}
simpleName.setSourceRange(sourceStart, end - sourceStart + 1);
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL :
SimpleType simpleType = new SimpleType(this.ast);
simpleType.setName(simpleName);
simpleType.setFlags(simpleType.getFlags() | ASTNode.MALFORMED);
simpleType.setSourceRange(sourceStart, end - sourceStart + 1);
type = simpleType;
if (this.resolveBindings) {
this.recordNodes(simpleName, typeReference);
}
break;
case AST.JLS3 :
simpleType = new SimpleType(this.ast);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
simpleType.setName(simpleName);
simpleType.setSourceRange(simpleName.getStartPosition(), simpleName.getLength());
final ParameterizedType parameterizedType = new ParameterizedType(this.ast);
parameterizedType.setType(simpleType);
type = parameterizedType;
TypeReference[] typeArguments = parameterizedSingleTypeReference.typeArguments;
if (typeArguments != null) {
Type type2 = null;
for (int i = 0, max = typeArguments.length; i < max; i++) {
type2 = convertType(typeArguments[i]);
((ParameterizedType) type).typeArguments().add(type2);
end = type2.getStartPosition() + type2.getLength() - 1;
}
end = retrieveClosingAngleBracketPosition(end + 1);
type.setSourceRange(sourceStart, end - sourceStart + 1);
} else {
type.setSourceRange(sourceStart, end - sourceStart + 1);
}
if (this.resolveBindings) {
this.recordNodes(simpleName, typeReference);
this.recordNodes(simpleType, typeReference);
}
}
} else {
final SimpleName simpleName = new SimpleName(this.ast);
simpleName.internalSetIdentifier(new String(name));
int end = retrieveEndOfElementTypeNamePosition(sourceStart, sourceStart + length);
if (end == -1) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
end = sourceStart + length - 1;
}
simpleName.setSourceRange(sourceStart, end - sourceStart + 1);
final SimpleType simpleType = new SimpleType(this.ast);
simpleType.setName(simpleName);
type = simpleType;
type.setSourceRange(sourceStart, end - sourceStart + 1);
type = simpleType;
if (this.resolveBindings) {
this.recordNodes(simpleName, typeReference);
}
}
if (dimensions != 0) {
type = this.ast.newArrayType(type, dimensions);
type.setSourceRange(sourceStart, length);
ArrayType subarrayType = (ArrayType) type;
int index = dimensions - 1;
while (index > 0) {
subarrayType = (ArrayType) subarrayType.getComponentType();
int end = retrieveProperRightBracketPosition(index, sourceStart);
subarrayType.setSourceRange(sourceStart, end - sourceStart + 1);
index--;
}
if (this.resolveBindings) {
completeRecord((ArrayType) type, typeReference);
}
}
} else {
if (typeReference instanceof ParameterizedQualifiedTypeReference) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
ParameterizedQualifiedTypeReference parameterizedQualifiedTypeReference = (ParameterizedQualifiedTypeReference) typeReference;
char[][] tokens = parameterizedQualifiedTypeReference.tokens;
TypeReference[][] typeArguments = parameterizedQualifiedTypeReference.typeArguments;
long[] positions = parameterizedQualifiedTypeReference.sourcePositions;
sourceStart = (int)(positions[0]>>>32);
switch(this.ast.apiLevel) {
case AST.JLS2_INTERNAL : {
char[][] name = ((org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference) typeReference).getTypeName();
int nameLength = name.length;
sourceStart = (int)(positions[0]>>>32);
length = (int)(positions[nameLength - 1] & 0xFFFFFFFF) - sourceStart + 1;
Name qualifiedName = this.setQualifiedNameNameAndSourceRanges(name, positions, typeReference);
final SimpleType simpleType = new SimpleType(this.ast);
simpleType.setName(qualifiedName);
simpleType.setSourceRange(sourceStart, length);
type = simpleType;
}
break;
case AST.JLS3 :
if (typeArguments != null) {
int numberOfEnclosingType = 0;
int startingIndex = 0;
int endingIndex = 0;
for (int i = 0, max = typeArguments.length; i < max; i++) {
if (typeArguments[i] != null) {
numberOfEnclosingType++;
} else if (numberOfEnclosingType == 0) {
endingIndex++;
}
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
Name name = null;
if (endingIndex - startingIndex == 0) {
final SimpleName simpleName = new SimpleName(this.ast);
simpleName.internalSetIdentifier(new String(tokens[startingIndex]));
recordPendingNameScopeResolution(simpleName);
int start = (int)(positions[startingIndex]>>>32);
int end = (int) positions[startingIndex];
simpleName.setSourceRange(start, end - start + 1);
simpleName.index = 1;
name = simpleName;
if (this.resolveBindings) {
recordNodes(simpleName, typeReference);
}
} else {
name = this.setQualifiedNameNameAndSourceRanges(tokens, positions, endingIndex, typeReference);
}
SimpleType simpleType = new SimpleType(this.ast);
simpleType.setName(name);
int start = (int)(positions[startingIndex]>>>32);
int end = (int) positions[endingIndex];
simpleType.setSourceRange(start, end - start + 1);
ParameterizedType parameterizedType = new ParameterizedType(this.ast);
parameterizedType.setType(simpleType);
if (this.resolveBindings) {
recordNodes(simpleType, typeReference);
recordNodes(parameterizedType, typeReference);
}
start = simpleType.getStartPosition();
end = start + simpleType.getLength() - 1;
for (int i = 0, max = typeArguments[endingIndex].length; i < max; i++) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
final Type type2 = convertType(typeArguments[endingIndex][i]);
parameterizedType.typeArguments().add(type2);
end = type2.getStartPosition() + type2.getLength() - 1;
}
int indexOfEnclosingType = 1;
parameterizedType.index = indexOfEnclosingType;
end = retrieveClosingAngleBracketPosition(end + 1);
length = end + 1;
parameterizedType.setSourceRange(start, end - start + 1);
startingIndex = endingIndex + 1;
Type currentType = parameterizedType;
while(startingIndex < typeArguments.length) {
SimpleName simpleName = new SimpleName(this.ast);
simpleName.internalSetIdentifier(new String(tokens[startingIndex]));
simpleName.index = startingIndex + 1;
start = (int)(positions[startingIndex]>>>32);
end = (int) positions[startingIndex];
simpleName.setSourceRange(start, end - start + 1);
recordPendingNameScopeResolution(simpleName);
QualifiedType qualifiedType = new QualifiedType(this.ast);
qualifiedType.setQualifier(currentType);
qualifiedType.setName(simpleName);
if (this.resolveBindings) {
recordNodes(simpleName, typeReference);
recordNodes(qualifiedType, typeReference);
}
start = currentType.getStartPosition();
end = simpleName.getStartPosition() + simpleName.getLength() - 1;
qualifiedType.setSourceRange(start, end - start + 1);
indexOfEnclosingType++;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
if (typeArguments[startingIndex] != null) {
qualifiedType.index = indexOfEnclosingType;
ParameterizedType parameterizedType2 = new ParameterizedType(this.ast);
parameterizedType2.setType(qualifiedType);
parameterizedType2.index = indexOfEnclosingType;
if (this.resolveBindings) {
recordNodes(parameterizedType2, typeReference);
}
for (int i = 0, max = typeArguments[startingIndex].length; i < max; i++) {
final Type type2 = convertType(typeArguments[startingIndex][i]);
parameterizedType2.typeArguments().add(type2);
end = type2.getStartPosition() + type2.getLength() - 1;
}
end = retrieveClosingAngleBracketPosition(end + 1);
length = end + 1;
parameterizedType2.setSourceRange(start, end - start + 1);
currentType = parameterizedType2;
} else {
currentType = qualifiedType;
qualifiedType.index = indexOfEnclosingType;
}
startingIndex++;
}
if (this.resolveBindings) {
this.recordNodes(currentType, typeReference);
}
type = currentType;
length -= sourceStart;
}
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
} else {
char[][] name = ((org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference) typeReference).getTypeName();
int nameLength = name.length;
long[] positions = ((org.aspectj.org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference) typeReference).sourcePositions;
sourceStart = (int)(positions[0]>>>32);
length = (int)(positions[nameLength - 1] & 0xFFFFFFFF) - sourceStart + 1;
final Name qualifiedName = this.setQualifiedNameNameAndSourceRanges(name, positions, typeReference);
final SimpleType simpleType = new SimpleType(this.ast);
simpleType.setName(qualifiedName);
type = simpleType;
type.setSourceRange(sourceStart, length);
}
if (dimensions != 0) {
type = this.ast.newArrayType(type, dimensions);
if (this.resolveBindings) {
completeRecord((ArrayType) type, typeReference);
}
int end = retrieveEndOfDimensionsPosition(sourceStart+length, this.compilationUnitSourceLength);
if (end != -1) {
type.setSourceRange(sourceStart, end - sourceStart + 1);
} else {
type.setSourceRange(sourceStart, length);
}
ArrayType subarrayType = (ArrayType) type;
int index = dimensions - 1;
while (index > 0) {
subarrayType = (ArrayType) subarrayType.getComponentType();
end = retrieveProperRightBracketPosition(index, sourceStart);
subarrayType.setSourceRange(sourceStart, end - sourceStart + 1);
index--;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
}
}
if (this.resolveBindings) {
this.recordNodes(type, typeReference);
}
return type;
}
protected Comment createComment(int[] positions) {
Comment comment = null;
int start = positions[0];
int end = positions[1];
if (positions[1]>0) {
Javadoc docComment = this.docParser.parse(positions);
if (docComment == null) return null;
comment = docComment;
} else {
end = -end;
if (positions[0]>0) {
comment = new BlockComment(this.ast);
} else {
start = -start;
comment = new LineComment(this.ast);
}
comment.setSourceRange(start, end - start);
}
return comment;
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
protected Statement createFakeEmptyStatement(org.aspectj.org.eclipse.jdt.internal.compiler.ast.Statement statement) {
EmptyStatement emptyStatement = new EmptyStatement(this.ast);
emptyStatement.setFlags(emptyStatement.getFlags() | ASTNode.MALFORMED);
int start = statement.sourceStart;
int end = statement.sourceEnd;
emptyStatement.setSourceRange(start, end - start + 1);
return emptyStatement;
}
/**
* @return a new modifier
*/
private Modifier createModifier(ModifierKeyword keyword) {
final Modifier modifier = new Modifier(this.ast);
modifier.setKeyword(keyword);
int start = this.scanner.getCurrentTokenStartPosition();
int end = this.scanner.getCurrentTokenEndPosition();
modifier.setSourceRange(start, end - start + 1);
return modifier;
}
protected InfixExpression.Operator getOperatorFor(int operatorID) {
switch (operatorID) {
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.EQUAL_EQUAL :
return InfixExpression.Operator.EQUALS;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.LESS_EQUAL :
return InfixExpression.Operator.LESS_EQUALS;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.GREATER_EQUAL :
return InfixExpression.Operator.GREATER_EQUALS;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.NOT_EQUAL :
return InfixExpression.Operator.NOT_EQUALS;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.LEFT_SHIFT :
return InfixExpression.Operator.LEFT_SHIFT;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.RIGHT_SHIFT :
return InfixExpression.Operator.RIGHT_SHIFT_SIGNED;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.UNSIGNED_RIGHT_SHIFT :
return InfixExpression.Operator.RIGHT_SHIFT_UNSIGNED;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.OR_OR :
return InfixExpression.Operator.CONDITIONAL_OR;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.AND_AND :
return InfixExpression.Operator.CONDITIONAL_AND;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.PLUS :
return InfixExpression.Operator.PLUS;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.MINUS :
return InfixExpression.Operator.MINUS;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.REMAINDER :
return InfixExpression.Operator.REMAINDER;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.XOR :
return InfixExpression.Operator.XOR;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.AND :
return InfixExpression.Operator.AND;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.MULTIPLY :
return InfixExpression.Operator.TIMES;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.OR :
return InfixExpression.Operator.OR;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.DIVIDE :
return InfixExpression.Operator.DIVIDE;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.GREATER :
return InfixExpression.Operator.GREATER;
case org.aspectj.org.eclipse.jdt.internal.compiler.ast.OperatorIds.LESS :
return InfixExpression.Operator.LESS;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
return null;
}
protected PrimitiveType.Code getPrimitiveTypeCode(char[] name) {
switch(name[0]) {
case 'i' :
if (name.length == 3 && name[1] == 'n' && name[2] == 't') {
return PrimitiveType.INT;
}
break;
case 'l' :
if (name.length == 4 && name[1] == 'o' && name[2] == 'n' && name[3] == 'g') {
return PrimitiveType.LONG;
}
break;
case 'd' :
if (name.length == 6
&& name[1] == 'o'
&& name[2] == 'u'
&& name[3] == 'b'
&& name[4] == 'l'
&& name[5] == 'e') {
return PrimitiveType.DOUBLE;
}
break;
case 'f' :
if (name.length == 5
&& name[1] == 'l'
&& name[2] == 'o'
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
&& name[3] == 'a'
&& name[4] == 't') {
return PrimitiveType.FLOAT;
}
break;
case 'b' :
if (name.length == 4
&& name[1] == 'y'
&& name[2] == 't'
&& name[3] == 'e') {
return PrimitiveType.BYTE;
} else
if (name.length == 7
&& name[1] == 'o'
&& name[2] == 'o'
&& name[3] == 'l'
&& name[4] == 'e'
&& name[5] == 'a'
&& name[6] == 'n') {
return PrimitiveType.BOOLEAN;
}
break;
case 'c' :
if (name.length == 4
&& name[1] == 'h'
&& name[2] == 'a'
&& name[3] == 'r') {
return PrimitiveType.CHAR;
}
break;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
case 's' :
if (name.length == 5
&& name[1] == 'h'
&& name[2] == 'o'
&& name[3] == 'r'
&& name[4] == 't') {
return PrimitiveType.SHORT;
}
break;
case 'v' :
if (name.length == 4
&& name[1] == 'o'
&& name[2] == 'i'
&& name[3] == 'd') {
return PrimitiveType.VOID;
}
}
return null;
}
protected boolean isPrimitiveType(char[] name) {
switch(name[0]) {
case 'i' :
if (name.length == 3 && name[1] == 'n' && name[2] == 't') {
return true;
}
return false;
case 'l' :
if (name.length == 4 && name[1] == 'o' && name[2] == 'n' && name[3] == 'g') {
return true;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
return false;
case 'd' :
if (name.length == 6
&& name[1] == 'o'
&& name[2] == 'u'
&& name[3] == 'b'
&& name[4] == 'l'
&& name[5] == 'e') {
return true;
}
return false;
case 'f' :
if (name.length == 5
&& name[1] == 'l'
&& name[2] == 'o'
&& name[3] == 'a'
&& name[4] == 't') {
return true;
}
return false;
case 'b' :
if (name.length == 4
&& name[1] == 'y'
&& name[2] == 't'
&& name[3] == 'e') {
return true;
} else
if (name.length == 7
&& name[1] == 'o'
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
&& name[2] == 'o'
&& name[3] == 'l'
&& name[4] == 'e'
&& name[5] == 'a'
&& name[6] == 'n') {
return true;
}
return false;
case 'c' :
if (name.length == 4
&& name[1] == 'h'
&& name[2] == 'a'
&& name[3] == 'r') {
return true;
}
return false;
case 's' :
if (name.length == 5
&& name[1] == 'h'
&& name[2] == 'o'
&& name[3] == 'r'
&& name[4] == 't') {
return true;
}
return false;
case 'v' :
if (name.length == 4
&& name[1] == 'o'
&& name[2] == 'i'
&& name[3] == 'd') {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
return true;
}
return false;
}
return false;
}
private void lookupForScopes() {
if (this.pendingNameScopeResolution != null) {
for (Iterator iterator = this.pendingNameScopeResolution.iterator(); iterator.hasNext(); ) {
Name name = (Name) iterator.next();
this.ast.getBindingResolver().recordScope(name, lookupScope(name));
}
}
if (this.pendingThisExpressionScopeResolution != null) {
for (Iterator iterator = this.pendingThisExpressionScopeResolution.iterator(); iterator.hasNext(); ) {
ThisExpression thisExpression = (ThisExpression) iterator.next();
this.ast.getBindingResolver().recordScope(thisExpression, lookupScope(thisExpression));
}
}
}
private BlockScope lookupScope(ASTNode node) {
ASTNode currentNode = node;
while(currentNode != null
&&!(currentNode instanceof MethodDeclaration)
&& !(currentNode instanceof Initializer)
&& !(currentNode instanceof FieldDeclaration)) {
currentNode = currentNode.getParent();
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
if (currentNode == null) {
return null;
}
if (currentNode instanceof Initializer) {
Initializer initializer = (Initializer) currentNode;
while(!(currentNode instanceof AbstractTypeDeclaration)) {
currentNode = currentNode.getParent();
}
if (currentNode instanceof TypeDeclaration
|| currentNode instanceof EnumDeclaration
|| currentNode instanceof AnnotationTypeDeclaration) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDecl = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) this.ast.getBindingResolver().getCorrespondingNode(currentNode);
if ((initializer.getModifiers() & Modifier.STATIC) != 0) {
return typeDecl.staticInitializerScope;
} else {
return typeDecl.initializerScope;
}
}
} else if (currentNode instanceof FieldDeclaration) {
FieldDeclaration fieldDeclaration = (FieldDeclaration) currentNode;
while(!(currentNode instanceof AbstractTypeDeclaration)) {
currentNode = currentNode.getParent();
}
if (currentNode instanceof TypeDeclaration
|| currentNode instanceof EnumDeclaration
|| currentNode instanceof AnnotationTypeDeclaration) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDecl = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) this.ast.getBindingResolver().getCorrespondingNode(currentNode);
if ((fieldDeclaration.getModifiers() & Modifier.STATIC) != 0) {
return typeDecl.staticInitializerScope;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
} else {
return typeDecl.initializerScope;
}
}
}
AbstractMethodDeclaration abstractMethodDeclaration = (AbstractMethodDeclaration) this.ast.getBindingResolver().getCorrespondingNode(currentNode);
return abstractMethodDeclaration.scope;
}
protected void recordName(Name name, org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode compilerNode) {
if (compilerNode != null) {
recordNodes(name, compilerNode);
if (compilerNode instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeRef = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference) compilerNode;
if (name.isQualifiedName()) {
SimpleName simpleName = null;
while (name.isQualifiedName()) {
simpleName = ((QualifiedName) name).getName();
recordNodes(simpleName, typeRef);
name = ((QualifiedName) name).getQualifier();
recordNodes(name, typeRef);
}
}
}
}
}
protected void recordNodes(ASTNode node, org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode oldASTNode) {
this.ast.getBindingResolver().store(node, oldASTNode);
}
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
protected void recordNodes(org.aspectj.org.eclipse.jdt.internal.compiler.ast.Javadoc javadoc, TagElement tagElement) {
Iterator fragments = tagElement.fragments().listIterator();
while (fragments.hasNext()) {
ASTNode node = (ASTNode) fragments.next();
if (node.getNodeType() == ASTNode.MEMBER_REF) {
MemberRef memberRef = (MemberRef) node;
Name name = memberRef.getName();
int start = name.getStartPosition();
org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode compilerNode = javadoc.getNodeStartingAt(start);
if (compilerNode!= null) {
recordNodes(name, compilerNode);
recordNodes(node, compilerNode);
}
if (memberRef.getQualifier() != null) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeRef = null;
if (compilerNode instanceof JavadocFieldReference) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression expression = ((JavadocFieldReference)compilerNode).receiver;
if (expression instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference) {
typeRef = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference) expression;
}
}
else if (compilerNode instanceof JavadocMessageSend) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression expression = ((JavadocMessageSend)compilerNode).receiver;
if (expression instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference) {
typeRef = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference) expression;
}
}
if (typeRef != null) {
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
recordName(memberRef.getQualifier(), typeRef);
}
}
} else if (node.getNodeType() == ASTNode.METHOD_REF) {
MethodRef methodRef = (MethodRef) node;
Name name = methodRef.getName();
int start = name.getStartPosition();
org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode compilerNode = javadoc.getNodeStartingAt(start);
if (compilerNode != null) {
recordNodes(methodRef, compilerNode);
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeRef = null;
if (compilerNode instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.JavadocAllocationExpression) {
typeRef = ((org.aspectj.org.eclipse.jdt.internal.compiler.ast.JavadocAllocationExpression)compilerNode).type;
if (typeRef != null) recordNodes(name, compilerNode);
}
else if (compilerNode instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.JavadocMessageSend) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression expression = ((org.aspectj.org.eclipse.jdt.internal.compiler.ast.JavadocMessageSend)compilerNode).receiver;
if (expression instanceof org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference) {
typeRef = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference) expression;
}
recordNodes(name, compilerNode);
}
if (typeRef != null && methodRef.getQualifier() != null) {
recordName(methodRef.getQualifier(), typeRef);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
}
Iterator parameters = methodRef.parameters().listIterator();
while (parameters.hasNext()) {
MethodRefParameter param = (MethodRefParameter) parameters.next();
org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression expression = (org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression) javadoc.getNodeStartingAt(param.getStartPosition());
if (expression != null) {
recordNodes(param, expression);
if (expression instanceof JavadocArgumentExpression) {
JavadocArgumentExpression argExpr = (JavadocArgumentExpression) expression;
org.aspectj.org.eclipse.jdt.internal.compiler.ast.TypeReference typeRef = argExpr.argument.type;
if (this.ast.apiLevel >= AST.JLS3) param.setVarargs(argExpr.argument.isVarArgs());
recordNodes(param.getType(), typeRef);
if (param.getType().isSimpleType()) {
recordName(((SimpleType)param.getType()).getName(), typeRef);
} else if (param.getType().isArrayType()) {
Type type = ((ArrayType) param.getType()).getElementType();
recordNodes(type, typeRef);
if (type.isSimpleType()) {
recordName(((SimpleType)type).getName(), typeRef);
}
}
}
}
}
} else if (node.getNodeType() == ASTNode.SIMPLE_NAME ||
node.getNodeType() == ASTNode.QUALIFIED_NAME) {
org.aspectj.org.eclipse.jdt.internal.compiler.ast.ASTNode compilerNode = javadoc.getNodeStartingAt(node.getStartPosition());
recordName((Name) node, compilerNode);
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
} else if (node.getNodeType() == ASTNode.TAG_ELEMENT) {
recordNodes(javadoc, (TagElement) node);
}
}
}
protected void recordPendingNameScopeResolution(Name name) {
if (this.pendingNameScopeResolution == null) {
this.pendingNameScopeResolution = new HashSet();
}
this.pendingNameScopeResolution.add(name);
}
protected void recordPendingThisExpressionScopeResolution(ThisExpression thisExpression) {
if (this.pendingThisExpressionScopeResolution == null) {
this.pendingThisExpressionScopeResolution = new HashSet();
}
this.pendingThisExpressionScopeResolution.add(thisExpression);
}
/**
* Remove whitespaces and comments before and after the expression.
*/
private void trimWhiteSpacesAndComments(org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression expression) {
int start = expression.sourceStart;
int end = expression.sourceEnd;
int token;
int trimLeftPosition = expression.sourceStart;
int trimRightPosition = expression.sourceEnd;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
boolean first = true;
Scanner removeBlankScanner = this.ast.scanner;
try {
removeBlankScanner.setSource(this.compilationUnitSource);
removeBlankScanner.resetTo(start, end);
while (true) {
token = removeBlankScanner.getNextToken();
switch (token) {
case TerminalTokens.TokenNameCOMMENT_JAVADOC :
case TerminalTokens.TokenNameCOMMENT_LINE :
case TerminalTokens.TokenNameCOMMENT_BLOCK :
if (first) {
trimLeftPosition = removeBlankScanner.currentPosition;
}
break;
case TerminalTokens.TokenNameWHITESPACE :
if (first) {
trimLeftPosition = removeBlankScanner.currentPosition;
}
break;
case TerminalTokens.TokenNameEOF :
expression.sourceStart = trimLeftPosition;
expression.sourceEnd = trimRightPosition;
return;
default :
/*
* if we find something else than a whitespace or a comment,
* then we reset the trimRigthPosition to the expression
* source end.
*/
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
trimRightPosition = removeBlankScanner.currentPosition - 1;
first = false;
}
}
} catch (InvalidInputException e){
ignore
}
}
protected int retrieveEndingSemiColonPosition(int start, int end) {
int count = 0;
this.scanner.resetTo(start, end);
try {
int token;
while ((token = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
switch(token) {
case TerminalTokens.TokenNameSEMICOLON:
if (count == 0) {
return this.scanner.currentPosition - 1;
}
break;
case TerminalTokens.TokenNameLBRACE :
count++;
break;
case TerminalTokens.TokenNameRBRACE :
count--;
break;
case TerminalTokens.TokenNameLPAREN :
count++;
break;
case TerminalTokens.TokenNameRPAREN :
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
count--;
break;
case TerminalTokens.TokenNameLBRACKET :
count++;
break;
case TerminalTokens.TokenNameRBRACKET :
count--;
}
}
} catch(InvalidInputException e) {
ignore
}
return -1;
}
/**
* This method is used to retrieve the ending position for a type declaration when the dimension is right after the type
* name.
* For example:
* int[] i; => return 5, but int i[] => return -1;
* @return int the dimension found
*/
protected int retrieveEndOfDimensionsPosition(int start, int end) {
this.scanner.resetTo(start, end);
int foundPosition = -1;
try {
int token;
while ((token = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
switch(token) {
case TerminalTokens.TokenNameLBRACKET:
case TerminalTokens.TokenNameCOMMENT_BLOCK:
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
case TerminalTokens.TokenNameCOMMENT_JAVADOC:
case TerminalTokens.TokenNameCOMMENT_LINE:
break;
case TerminalTokens.TokenNameRBRACKET:166
foundPosition = this.scanner.currentPosition - 1;
break;
default:
return foundPosition;
}
}
} catch(InvalidInputException e) {
ignore
}
return foundPosition;
}
/**
* This method is used to retrieve the position just before the left bracket.
* @return int the dimension found, -1 if none
*/
protected int retrieveEndOfElementTypeNamePosition(int start, int end) {
this.scanner.resetTo(start, end);
try {
int token;
while ((token = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
switch(token) {
case TerminalTokens.TokenNameIdentifier:
case TerminalTokens.TokenNamebyte:
case TerminalTokens.TokenNamechar:
case TerminalTokens.TokenNamedouble:
case TerminalTokens.TokenNamefloat:
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
case TerminalTokens.TokenNameint:
case TerminalTokens.TokenNamelong:
case TerminalTokens.TokenNameshort:
case TerminalTokens.TokenNameboolean:
return this.scanner.currentPosition - 1;
}
}
} catch(InvalidInputException e) {
ignore
}
return -1;
}
/**
* This method is used to retrieve the position after the right parenthesis.
* @return int the position found
*/
protected int retrieveEndOfRightParenthesisPosition(int start, int end) {
this.scanner.resetTo(start, end);
try {
int token;
while ((token = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
switch(token) {
case TerminalTokens.TokenNameRPAREN:
return this.scanner.currentPosition;
}
}
} catch(InvalidInputException e) {
ignore
}
return -1;
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
/**
* This method is used to retrieve the array dimension declared after the
* name of a local or a field declaration.
* For example:
* int i, j[] = null, k[][] = {{}};
* It should return 0 for i, 1 for j and 2 for k.
* @return int the dimension found
*/
protected int retrieveExtraDimension(int start, int end) {
this.scanner.resetTo(start, end);
int dimensions = 0;
try {
int token;
while ((token = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
switch(token) {
case TerminalTokens.TokenNameLBRACKET:
case TerminalTokens.TokenNameCOMMENT_BLOCK:
case TerminalTokens.TokenNameCOMMENT_JAVADOC:
case TerminalTokens.TokenNameCOMMENT_LINE:
break;
case TerminalTokens.TokenNameRBRACKET:166
dimensions++;
break;
default:
return dimensions;
}
}
} catch(InvalidInputException e) {
ignore
|
203,384 |
Bug 203384 AST: Type information not exposed on itmd, itfd...
|
The Types: org/aspectj/org/eclipse/jdt/core/dom/InterTypeFieldDeclaration.java org/aspectj/org/eclipse/jdt/core/dom/InterTypeMethodDeclaration.java Which can be returned by visiting the AjAST tree do not expose the name of the type on which the method or field is added. I require this information in the project I'm currently working on, and would appreciate if it was added.
|
resolved fixed
|
114db35
|
AspectJ
|
https://github.com/eclipse/org.aspectj
|
eclipse/org.aspectj
|
java
| null | null | null | 2008-01-22T18:48:29Z | 2007-09-14T00:33:20Z |
org.aspectj.ajdt.core/src/org/aspectj/org/eclipse/jdt/core/dom/AjASTConverter.java
|
}
return dimensions;
}
protected void retrieveIdentifierAndSetPositions(int start, int end, Name name) {
this.scanner.resetTo(start, end);
int token;
try {
while((token = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
if (token == TerminalTokens.TokenNameIdentifier) {
int startName = this.scanner.startPosition;
int endName = this.scanner.currentPosition - 1;
name.setSourceRange(startName, endName - startName + 1);
return;
}
}
} catch(InvalidInputException e) {
ignore
}
}
/**
* This method is used to retrieve the start position of the block.
* @return int the dimension found, -1 if none
*/
protected int retrieveIdentifierEndPosition(int start, int end) {
this.scanner.resetTo(start, end);
try {
int token;
while ((token = this.scanner.getNextToken()) != TerminalTokens.TokenNameEOF) {
switch(token) {
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.